codekingpro/portable-devtools

1//#region rolldown:runtime
2var __create = Object.create;
3var __defProp = Object.defineProperty;
4var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5var __getOwnPropNames = Object.getOwnPropertyNames;
6var __getProtoOf = Object.getPrototypeOf;
7var __hasOwnProp = Object.prototype.hasOwnProperty;
8var __copyProps = (to, from, except, desc) => {
9	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
10		key = keys[i];
11		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
12			get: ((k) => from[k]).bind(null, key),
13			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
14		});
15	}
16	return to;
17};
18var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
19	value: mod,
20	enumerable: true
21}) : target, mod));
22
23//#endregion
24const path = __toESM(require("path"));
25const fs = __toESM(require("fs"));
26
27//#region src/utils.ts
28function cleanPath(path$1) {
29	let normalized = (0, path.normalize)(path$1);
30	if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1);
31	return normalized;
32}
33const SLASHES_REGEX = /[\\/]/g;
34function convertSlashes(path$1, separator) {
35	return path$1.replace(SLASHES_REGEX, separator);
36}
37const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
38function isRootDirectory(path$1) {
39	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
40}
41function normalizePath(path$1, options) {
42	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
43	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
44	if (resolvePaths) path$1 = (0, path.resolve)(path$1);
45	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
46	if (path$1 === ".") return "";
47	const needsSeperator = path$1[path$1.length - 1] !== pathSeparator;
48	return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator);
49}
50
51//#endregion
52//#region src/api/functions/join-path.ts
53function joinPathWithBasePath(filename, directoryPath) {
54	return directoryPath + filename;
55}
56function joinPathWithRelativePath(root, options) {
57	return function(filename, directoryPath) {
58		const sameRoot = directoryPath.startsWith(root);
59		if (sameRoot) return directoryPath.slice(root.length) + filename;
60		else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
61	};
62}
63function joinPath(filename) {
64	return filename;
65}
66function joinDirectoryPath(filename, directoryPath, separator) {
67	return directoryPath + filename + separator;
68}
69function build$7(root, options) {
70	const { relativePaths, includeBasePath } = options;
71	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
72}
73
74//#endregion
75//#region src/api/functions/push-directory.ts
76function pushDirectoryWithRelativePath(root) {
77	return function(directoryPath, paths) {
78		paths.push(directoryPath.substring(root.length) || ".");
79	};
80}
81function pushDirectoryFilterWithRelativePath(root) {
82	return function(directoryPath, paths, filters) {
83		const relativePath = directoryPath.substring(root.length) || ".";
84		if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
85	};
86}
87const pushDirectory = (directoryPath, paths) => {
88	paths.push(directoryPath || ".");
89};
90const pushDirectoryFilter = (directoryPath, paths, filters) => {
91	const path$1 = directoryPath || ".";
92	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
93};
94const empty$2 = () => {};
95function build$6(root, options) {
96	const { includeDirs, filters, relativePaths } = options;
97	if (!includeDirs) return empty$2;
98	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
99	return filters && filters.length ? pushDirectoryFilter : pushDirectory;
100}
101
102//#endregion
103//#region src/api/functions/push-file.ts
104const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
105	if (filters.every((filter) => filter(filename, false))) counts.files++;
106};
107const pushFileFilter = (filename, paths, _counts, filters) => {
108	if (filters.every((filter) => filter(filename, false))) paths.push(filename);
109};
110const pushFileCount = (_filename, _paths, counts, _filters) => {
111	counts.files++;
112};
113const pushFile = (filename, paths) => {
114	paths.push(filename);
115};
116const empty$1 = () => {};
117function build$5(options) {
118	const { excludeFiles, filters, onlyCounts } = options;
119	if (excludeFiles) return empty$1;
120	if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
121	else if (onlyCounts) return pushFileCount;
122	else return pushFile;
123}
124
125//#endregion
126//#region src/api/functions/get-array.ts
127const getArray = (paths) => {
128	return paths;
129};
130const getArrayGroup = () => {
131	return [""].slice(0, 0);
132};
133function build$4(options) {
134	return options.group ? getArrayGroup : getArray;
135}
136
137//#endregion
138//#region src/api/functions/group-files.ts
139const groupFiles = (groups, directory, files) => {
140	groups.push({
141		directory,
142		files,
143		dir: directory
144	});
145};
146const empty = () => {};
147function build$3(options) {
148	return options.group ? groupFiles : empty;
149}
150
151//#endregion
152//#region src/api/functions/resolve-symlink.ts
153const resolveSymlinksAsync = function(path$1, state, callback$1) {
154	const { queue, fs: fs$1, options: { suppressErrors } } = state;
155	queue.enqueue();
156	fs$1.realpath(path$1, (error, resolvedPath) => {
157		if (error) return queue.dequeue(suppressErrors ? null : error, state);
158		fs$1.stat(resolvedPath, (error$1, stat) => {
159			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
160			if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
161			callback$1(stat, resolvedPath);
162			queue.dequeue(null, state);
163		});
164	});
165};
166const resolveSymlinks = function(path$1, state, callback$1) {
167	const { queue, fs: fs$1, options: { suppressErrors } } = state;
168	queue.enqueue();
169	try {
170		const resolvedPath = fs$1.realpathSync(path$1);
171		const stat = fs$1.statSync(resolvedPath);
172		if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
173		callback$1(stat, resolvedPath);
174	} catch (e) {
175		if (!suppressErrors) throw e;
176	}
177};
178function build$2(options, isSynchronous) {
179	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
180	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
181}
182function isRecursive(path$1, resolved, state) {
183	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
184	let parent = (0, path.dirname)(path$1);
185	let depth = 1;
186	while (parent !== state.root && depth < 2) {
187		const resolvedPath = state.symlinks.get(parent);
188		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
189		if (isSameRoot) depth++;
190		else parent = (0, path.dirname)(parent);
191	}
192	state.symlinks.set(path$1, resolved);
193	return depth > 1;
194}
195function isRecursiveUsingRealPaths(resolved, state) {
196	return state.visited.includes(resolved + state.options.pathSeparator);
197}
198
199//#endregion
200//#region src/api/functions/invoke-callback.ts
201const onlyCountsSync = (state) => {
202	return state.counts;
203};
204const groupsSync = (state) => {
205	return state.groups;
206};
207const defaultSync = (state) => {
208	return state.paths;
209};
210const limitFilesSync = (state) => {
211	return state.paths.slice(0, state.options.maxFiles);
212};
213const onlyCountsAsync = (state, error, callback$1) => {
214	report(error, callback$1, state.counts, state.options.suppressErrors);
215	return null;
216};
217const defaultAsync = (state, error, callback$1) => {
218	report(error, callback$1, state.paths, state.options.suppressErrors);
219	return null;
220};
221const limitFilesAsync = (state, error, callback$1) => {
222	report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
223	return null;
224};
225const groupsAsync = (state, error, callback$1) => {
226	report(error, callback$1, state.groups, state.options.suppressErrors);
227	return null;
228};
229function report(error, callback$1, output, suppressErrors) {
230	if (error && !suppressErrors) callback$1(error, output);
231	else callback$1(null, output);
232}
233function build$1(options, isSynchronous) {
234	const { onlyCounts, group, maxFiles } = options;
235	if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
236	else if (group) return isSynchronous ? groupsSync : groupsAsync;
237	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
238	else return isSynchronous ? defaultSync : defaultAsync;
239}
240
241//#endregion
242//#region src/api/functions/walk-directory.ts
243const readdirOpts = { withFileTypes: true };
244const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
245	state.queue.enqueue();
246	if (currentDepth < 0) return state.queue.dequeue(null, state);
247	const { fs: fs$1 } = state;
248	state.visited.push(crawlPath);
249	state.counts.directories++;
250	fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
251		callback$1(entries, directoryPath, currentDepth);
252		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
253	});
254};
255const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
256	const { fs: fs$1 } = state;
257	if (currentDepth < 0) return;
258	state.visited.push(crawlPath);
259	state.counts.directories++;
260	let entries = [];
261	try {
262		entries = fs$1.readdirSync(crawlPath || ".", readdirOpts);
263	} catch (e) {
264		if (!state.options.suppressErrors) throw e;
265	}
266	callback$1(entries, directoryPath, currentDepth);
267};
268function build(isSynchronous) {
269	return isSynchronous ? walkSync : walkAsync;
270}
271
272//#endregion
273//#region src/api/queue.ts
274/**
275* This is a custom stateless queue to track concurrent async fs calls.
276* It increments a counter whenever a call is queued and decrements it
277* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
278*/
279var Queue = class {
280	count = 0;
281	constructor(onQueueEmpty) {
282		this.onQueueEmpty = onQueueEmpty;
283	}
284	enqueue() {
285		this.count++;
286		return this.count;
287	}
288	dequeue(error, output) {
289		if (this.onQueueEmpty && (--this.count <= 0 || error)) {
290			this.onQueueEmpty(error, output);
291			if (error) {
292				output.controller.abort();
293				this.onQueueEmpty = void 0;
294			}
295		}
296	}
297};
298
299//#endregion
300//#region src/api/counter.ts
301var Counter = class {
302	_files = 0;
303	_directories = 0;
304	set files(num) {
305		this._files = num;
306	}
307	get files() {
308		return this._files;
309	}
310	set directories(num) {
311		this._directories = num;
312	}
313	get directories() {
314		return this._directories;
315	}
316	/**
317	* @deprecated use `directories` instead
318	*/
319	/* c8 ignore next 3 */
320	get dirs() {
321		return this._directories;
322	}
323};
324
325//#endregion
326//#region src/api/aborter.ts
327/**
328* AbortController is not supported on Node 14 so we use this until we can drop
329* support for Node 14.
330*/
331var Aborter = class {
332	aborted = false;
333	abort() {
334		this.aborted = true;
335	}
336};
337
338//#endregion
339//#region src/api/walker.ts
340var Walker = class {
341	root;
342	isSynchronous;
343	state;
344	joinPath;
345	pushDirectory;
346	pushFile;
347	getArray;
348	groupFiles;
349	resolveSymlink;
350	walkDirectory;
351	callbackInvoker;
352	constructor(root, options, callback$1) {
353		this.isSynchronous = !callback$1;
354		this.callbackInvoker = build$1(options, this.isSynchronous);
355		this.root = normalizePath(root, options);
356		this.state = {
357			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
358			paths: [""].slice(0, 0),
359			groups: [],
360			counts: new Counter(),
361			options,
362			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
363			symlinks: /* @__PURE__ */ new Map(),
364			visited: [""].slice(0, 0),
365			controller: new Aborter(),
366			fs: options.fs || fs
367		};
368		this.joinPath = build$7(this.root, options);
369		this.pushDirectory = build$6(this.root, options);
370		this.pushFile = build$5(options);
371		this.getArray = build$4(options);
372		this.groupFiles = build$3(options);
373		this.resolveSymlink = build$2(options, this.isSynchronous);
374		this.walkDirectory = build(this.isSynchronous);
375	}
376	start() {
377		this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
378		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
379		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
380	}
381	walk = (entries, directoryPath, depth) => {
382		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
383		if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
384		const files = this.getArray(this.state.paths);
385		for (let i = 0; i < entries.length; ++i) {
386			const entry = entries[i];
387			if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
388				const filename = this.joinPath(entry.name, directoryPath);
389				this.pushFile(filename, files, this.state.counts, filters);
390			} else if (entry.isDirectory()) {
391				let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
392				if (exclude && exclude(entry.name, path$1)) continue;
393				this.pushDirectory(path$1, paths, filters);
394				this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);
395			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
396				let path$1 = joinPathWithBasePath(entry.name, directoryPath);
397				this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => {
398					if (stat.isDirectory()) {
399						resolvedPath = normalizePath(resolvedPath, this.state.options);
400						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
401						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);
402					} else {
403						resolvedPath = useRealPaths ? resolvedPath : path$1;
404						const filename = (0, path.basename)(resolvedPath);
405						const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options);
406						resolvedPath = this.joinPath(filename, directoryPath$1);
407						this.pushFile(resolvedPath, files, this.state.counts, filters);
408					}
409				});
410			}
411		}
412		this.groupFiles(this.state.groups, directoryPath, files);
413	};
414};
415
416//#endregion
417//#region src/api/async.ts
418function promise(root, options) {
419	return new Promise((resolve$1, reject) => {
420		callback(root, options, (err, output) => {
421			if (err) return reject(err);
422			resolve$1(output);
423		});
424	});
425}
426function callback(root, options, callback$1) {
427	let walker = new Walker(root, options, callback$1);
428	walker.start();
429}
430
431//#endregion
432//#region src/api/sync.ts
433function sync(root, options) {
434	const walker = new Walker(root, options);
435	return walker.start();
436}
437
438//#endregion
439//#region src/builder/api-builder.ts
440var APIBuilder = class {
441	constructor(root, options) {
442		this.root = root;
443		this.options = options;
444	}
445	withPromise() {
446		return promise(this.root, this.options);
447	}
448	withCallback(cb) {
449		callback(this.root, this.options, cb);
450	}
451	sync() {
452		return sync(this.root, this.options);
453	}
454};
455
456//#endregion
457//#region src/builder/index.ts
458let pm = null;
459/* c8 ignore next 6 */
460try {
461	require.resolve("picomatch");
462	pm = require("picomatch");
463} catch {}
464var Builder = class {
465	globCache = {};
466	options = {
467		maxDepth: Infinity,
468		suppressErrors: true,
469		pathSeparator: path.sep,
470		filters: []
471	};
472	globFunction;
473	constructor(options) {
474		this.options = {
475			...this.options,
476			...options
477		};
478		this.globFunction = this.options.globFunction;
479	}
480	group() {
481		this.options.group = true;
482		return this;
483	}
484	withPathSeparator(separator) {
485		this.options.pathSeparator = separator;
486		return this;
487	}
488	withBasePath() {
489		this.options.includeBasePath = true;
490		return this;
491	}
492	withRelativePaths() {
493		this.options.relativePaths = true;
494		return this;
495	}
496	withDirs() {
497		this.options.includeDirs = true;
498		return this;
499	}
500	withMaxDepth(depth) {
501		this.options.maxDepth = depth;
502		return this;
503	}
504	withMaxFiles(limit) {
505		this.options.maxFiles = limit;
506		return this;
507	}
508	withFullPaths() {
509		this.options.resolvePaths = true;
510		this.options.includeBasePath = true;
511		return this;
512	}
513	withErrors() {
514		this.options.suppressErrors = false;
515		return this;
516	}
517	withSymlinks({ resolvePaths = true } = {}) {
518		this.options.resolveSymlinks = true;
519		this.options.useRealPaths = resolvePaths;
520		return this.withFullPaths();
521	}
522	withAbortSignal(signal) {
523		this.options.signal = signal;
524		return this;
525	}
526	normalize() {
527		this.options.normalizePath = true;
528		return this;
529	}
530	filter(predicate) {
531		this.options.filters.push(predicate);
532		return this;
533	}
534	onlyDirs() {
535		this.options.excludeFiles = true;
536		this.options.includeDirs = true;
537		return this;
538	}
539	exclude(predicate) {
540		this.options.exclude = predicate;
541		return this;
542	}
543	onlyCounts() {
544		this.options.onlyCounts = true;
545		return this;
546	}
547	crawl(root) {
548		return new APIBuilder(root || ".", this.options);
549	}
550	withGlobFunction(fn) {
551		this.globFunction = fn;
552		return this;
553	}
554	/**
555	* @deprecated Pass options using the constructor instead:
556	* ```ts
557	* new fdir(options).crawl("/path/to/root");
558	* ```
559	* This method will be removed in v7.0
560	*/
561	/* c8 ignore next 4 */
562	crawlWithOptions(root, options) {
563		this.options = {
564			...this.options,
565			...options
566		};
567		return new APIBuilder(root || ".", this.options);
568	}
569	glob(...patterns) {
570		if (this.globFunction) return this.globWithOptions(patterns);
571		return this.globWithOptions(patterns, ...[{ dot: true }]);
572	}
573	globWithOptions(patterns, ...options) {
574		const globFn = this.globFunction || pm;
575		/* c8 ignore next 5 */
576		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
577		var isMatch = this.globCache[patterns.join("\0")];
578		if (!isMatch) {
579			isMatch = globFn(patterns, ...options);
580			this.globCache[patterns.join("\0")] = isMatch;
581		}
582		this.options.filters.push((path$1) => isMatch(path$1));
583		return this;
584	}
585};
586
587//#endregion
588exports.fdir = Builder;