@intlayer/chokidar 7.0.3 → 7.0.4-canary.0

package/dist/esm/utils/runParallel/runTask.mjs

@@ -0,0 +1,153 @@
+import { Writable } from "node:stream";
+
+//#region src/utils/runParallel/runTask.ts
+/**
+* Remove the given value from the array.
+*/
+const remove = (array, x) => {
+	const index = array.indexOf(x);
+	if (index !== -1) array.splice(index, 1);
+};
+const signals = {
+	SIGABRT: 6,
+	SIGALRM: 14,
+	SIGBUS: 10,
+	SIGCHLD: 20,
+	SIGCONT: 19,
+	SIGFPE: 8,
+	SIGHUP: 1,
+	SIGILL: 4,
+	SIGINT: 2,
+	SIGKILL: 9,
+	SIGPIPE: 13,
+	SIGQUIT: 3,
+	SIGSEGV: 11,
+	SIGSTOP: 17,
+	SIGTERM: 15,
+	SIGTRAP: 5,
+	SIGTSTP: 18,
+	SIGTTIN: 21,
+	SIGTTOU: 22,
+	SIGUSR1: 30,
+	SIGUSR2: 31
+};
+/**
+* Converts a signal name to a number.
+*/
+const convert = (signal) => {
+	return signals[signal] || 0;
+};
+/**
+* Simple in-memory writable stream
+*/
+var MemoryStream = class extends Writable {
+	chunks = [];
+	_write(chunk, _encoding, callback) {
+		this.chunks.push(chunk);
+		callback();
+	}
+	toString() {
+		return Buffer.concat(this.chunks).toString("utf8");
+	}
+};
+/**
+* Run npm-scripts of given names in parallel.
+*
+* If a npm-script exited with a non-zero code, this aborts other all npm-scripts.
+*
+* Note: This is a simplified version for our use case.
+* The full implementation would require the actual runTask function from npm-run-all.
+*/
+const runTasks = (tasks, options) => {
+	return new Promise((resolve, reject) => {
+		if (tasks.length === 0) {
+			resolve([]);
+			return;
+		}
+		const results = tasks.map((task) => ({
+			name: task,
+			code: void 0
+		}));
+		const queue = tasks.map((task, index) => ({
+			name: task,
+			index
+		}));
+		const promises = [];
+		let error = null;
+		let aborted = false;
+		/**
+		* Done.
+		*/
+		const done = () => {
+			if (error == null) resolve(results);
+			else reject(error);
+		};
+		/**
+		* Aborts all tasks.
+		*/
+		const abort = () => {
+			if (aborted) return;
+			aborted = true;
+			if (promises.length === 0) done();
+			else {
+				for (const p of promises) p.abort?.();
+				Promise.all(promises).then(done, reject);
+			}
+		};
+		/**
+		* Runs a next task.
+		*/
+		const next = () => {
+			if (aborted) return;
+			if (queue.length === 0) {
+				if (promises.length === 0) done();
+				return;
+			}
+			const originalOutputStream = options.stdout;
+			const optionsClone = { ...options };
+			const writer = new MemoryStream();
+			if (options.aggregateOutput) optionsClone.stdout = writer;
+			const task = queue.shift();
+			const promise = Promise.resolve({
+				name: task.name,
+				code: 0,
+				signal: null
+			});
+			promises.push(promise);
+			promise.then((result) => {
+				remove(promises, promise);
+				if (aborted) return;
+				if (options.aggregateOutput) originalOutputStream.write(writer.toString());
+				if (result.code === null && result.signal !== null && result.signal !== void 0) result.code = 128 + convert(result.signal);
+				results[task.index].code = result.code;
+				if (result.code) {
+					error = /* @__PURE__ */ new Error(`Task ${result.name} failed with code ${result.code}`);
+					if (!options.continueOnError) {
+						abort();
+						return;
+					}
+				}
+				if (options.race && !result.code) {
+					abort();
+					return;
+				}
+				next();
+			}, (thisError) => {
+				remove(promises, promise);
+				if (!options.continueOnError || options.race) {
+					error = thisError;
+					abort();
+					return;
+				}
+				next();
+			});
+		};
+		const max = options.maxParallel;
+		const end = typeof max === "number" && max > 0 ? Math.min(tasks.length, max) : tasks.length;
+		for (let i = 0; i < end; ++i) next();
+	});
+};
+
+//#endregion
+export { runTasks };
+//# sourceMappingURL=runTask.mjs.map

package/dist/esm/utils/runParallel/runTask.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runTask.mjs","names":["signals: Record<string, number>","results: TaskResult[]","queue: TaskQueueItem[]","promises: TaskPromise[]","error: Error | null"],"sources":["../../../../src/utils/runParallel/runTask.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nimport { Writable } from 'node:stream';\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Remove the given value from the array.\n */\nconst remove = <T>(array: T[], x: T): void => {\n  const index = array.indexOf(x);\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n};\n\nconst signals: Record<string, number> = {\n  // Signal name mappings to their respective standard numeric codes.\n  // See: https://man7.org/linux/man-pages/man7/signal.7.html\n\n  SIGABRT: 6, // Abort signal from abort(3)\n  SIGALRM: 14, // Timer signal from alarm(2)\n  SIGBUS: 10, // Bus error (bad memory access)\n  SIGCHLD: 20, // Child stopped or terminated\n  SIGCONT: 19, // Continue if stopped\n  SIGFPE: 8, // Floating point exception\n  SIGHUP: 1, // Hangup detected on controlling terminal or death of controlling process\n  SIGILL: 4, // Illegal Instruction\n  SIGINT: 2, // Interrupt from keyboard (Ctrl+C)\n  SIGKILL: 9, // Kill signal (cannot be caught or ignored)\n  SIGPIPE: 13, // Broken pipe: write to pipe with no readers\n  SIGQUIT: 3, // Quit from keyboard (Ctrl+\\)\n  SIGSEGV: 11, // Invalid memory reference (segmentation fault)\n  SIGSTOP: 17, // Stop process (cannot be caught or ignored)\n  SIGTERM: 15, // Termination signal\n  SIGTRAP: 5, // Trace/breakpoint trap\n  SIGTSTP: 18, // Stop typed at tty (Ctrl+Z)\n  SIGTTIN: 21, // tty input for background process\n  SIGTTOU: 22, // tty output for background process\n  SIGUSR1: 30, // User-defined signal 1\n  SIGUSR2: 31, // User-defined signal 2\n};\n\n/**\n * Converts a signal name to a number.\n */\nconst convert = (signal: string): number => {\n  return signals[signal] || 0;\n};\n\n/**\n * Simple in-memory writable stream\n */\nclass MemoryStream extends Writable {\n  private chunks: Buffer[] = [];\n\n  _write(\n    chunk: Buffer,\n    _encoding: string,\n    callback: (error?: Error | null) => void\n  ): void {\n    this.chunks.push(chunk);\n    callback();\n  }\n\n  toString(): string {\n    return Buffer.concat(this.chunks).toString('utf8');\n  }\n}\n\n//------------------------------------------------------------------------------\n// Types\n//------------------------------------------------------------------------------\n\ninterface TaskResult {\n  name: string;\n  code: number | null;\n  signal?: string | null;\n}\n\ninterface TaskQueueItem {\n  name: string;\n  index: number;\n}\n\ninterface RunTaskOptions {\n  stdout: NodeJS.WritableStream;\n  stderr?: NodeJS.WritableStream;\n  aggregateOutput?: boolean;\n  continueOnError?: boolean;\n  race?: boolean;\n  maxParallel?: number;\n}\n\ninterface TaskPromise extends Promise<TaskResult> {\n  abort?: () => void;\n}\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Run npm-scripts of given names in parallel.\n *\n * If a npm-script exited with a non-zero code, this aborts other all npm-scripts.\n *\n * Note: This is a simplified version for our use case.\n * The full implementation would require the actual runTask function from npm-run-all.\n */\nexport const runTasks = (\n  tasks: string[],\n  options: RunTaskOptions\n): Promise<TaskResult[]> => {\n  return new Promise((resolve, reject) => {\n    if (tasks.length === 0) {\n      resolve([]);\n      return;\n    }\n\n    const results: TaskResult[] = tasks.map((task) => ({\n      name: task,\n      code: undefined as any,\n    }));\n    const queue: TaskQueueItem[] = tasks.map((task, index) => ({\n      name: task,\n      index,\n    }));\n    const promises: TaskPromise[] = [];\n    let error: Error | null = null;\n    let aborted = false;\n\n    /**\n     * Done.\n     */\n    const done = (): void => {\n      if (error == null) {\n        resolve(results);\n      } else {\n        reject(error);\n      }\n    };\n\n    /**\n     * Aborts all tasks.\n     */\n    const abort = (): void => {\n      if (aborted) {\n        return;\n      }\n      aborted = true;\n\n      if (promises.length === 0) {\n        done();\n      } else {\n        for (const p of promises) {\n          p.abort?.();\n        }\n        Promise.all(promises).then(done, reject);\n      }\n    };\n\n    /**\n     * Runs a next task.\n     */\n    const next = (): void => {\n      if (aborted) {\n        return;\n      }\n      if (queue.length === 0) {\n        if (promises.length === 0) {\n          done();\n        }\n        return;\n      }\n\n      const originalOutputStream = options.stdout;\n      const optionsClone = { ...options };\n      const writer = new MemoryStream();\n\n      if (options.aggregateOutput) {\n        optionsClone.stdout = writer as any;\n      }\n\n      const task = queue.shift()!;\n\n      // Note: This requires the actual runTask implementation from npm-run-all\n      // For now, this is a placeholder that would need to be implemented\n      const promise = Promise.resolve({\n        name: task.name,\n        code: 0,\n        signal: null,\n      }) as TaskPromise;\n\n      promises.push(promise);\n      promise.then(\n        (result) => {\n          remove(promises, promise);\n          if (aborted) {\n            return;\n          }\n\n          if (options.aggregateOutput) {\n            originalOutputStream.write(writer.toString());\n          }\n\n          // Check if the task failed as a result of a signal, and\n          // amend the exit code as a result.\n          if (\n            result.code === null &&\n            result.signal !== null &&\n            result.signal !== undefined\n          ) {\n            // An exit caused by a signal must return a status code\n            // of 128 plus the value of the signal code.\n            // Ref: https://nodejs.org/api/process.html#process_exit_codes\n            result.code = 128 + convert(result.signal);\n          }\n\n          // Save the result.\n          results[task.index].code = result.code;\n\n          // Aborts all tasks if it's an error.\n          if (result.code) {\n            error = new Error(\n              `Task ${result.name} failed with code ${result.code}`\n            );\n            if (!options.continueOnError) {\n              abort();\n              return;\n            }\n          }\n\n          // Aborts all tasks if options.race is true.\n          if (options.race && !result.code) {\n            abort();\n            return;\n          }\n\n          // Call the next task.\n          next();\n        },\n        (thisError: Error) => {\n          remove(promises, promise);\n          if (!options.continueOnError || options.race) {\n            error = thisError;\n            abort();\n            return;\n          }\n          next();\n        }\n      );\n    };\n\n    const max = options.maxParallel;\n    const end =\n      typeof max === 'number' && max > 0\n        ? Math.min(tasks.length, max)\n        : tasks.length;\n    for (let i = 0; i < end; ++i) {\n      next();\n    }\n  });\n};\n"],"mappings":"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"}

package/dist/esm/utils/runParallel/spawnPosix.mjs

@@ -0,0 +1,58 @@
+import { list } from "./pidTree.mjs";
+import { spawn } from "node:child_process";
+
+//#region src/utils/runParallel/spawnPosix.ts
+/**
+* Kills the new process and its sub processes.
+*/
+const createKillHandler = (child) => {
+	return (signal) => {
+		if (!child.pid) return false;
+		try {
+			list(child.pid, { root: true }, (err, pids) => {
+				if (err) {
+					try {
+						process.kill(-child.pid, signal ?? "SIGTERM");
+					} catch {}
+					return;
+				}
+				if (!pids) {
+					try {
+						process.kill(-child.pid, signal ?? "SIGTERM");
+					} catch {}
+					return;
+				}
+				for (const pid of pids) try {
+					process.kill(pid, signal ?? "SIGTERM");
+				} catch (_err) {}
+			});
+		} catch {
+			try {
+				process.kill(-child.pid, signal ?? "SIGTERM");
+			} catch {}
+		}
+		return true;
+	};
+};
+/**
+* Launches a new process with the given command.
+* This is almost same as `child_process.spawn`.
+*
+* This returns a `ChildProcess` instance.
+* `kill` method of the instance kills the new process and its sub processes.
+*
+* @param command - The command to run.
+* @param args - List of string arguments.
+* @param options - Options.
+* @returns A ChildProcess instance of new process.
+* @private
+*/
+const spawnPosix = (command, args, options) => {
+	const child = spawn(command, args, options);
+	child.kill = createKillHandler(child);
+	return child;
+};
+
+//#endregion
+export { spawnPosix };
+//# sourceMappingURL=spawnPosix.mjs.map

package/dist/esm/utils/runParallel/spawnPosix.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnPosix.mjs","names":["nodeSpawn"],"sources":["../../../../src/utils/runParallel/spawnPosix.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nimport type { SpawnOptions } from 'node:child_process';\nimport { type ChildProcess, spawn as nodeSpawn } from 'node:child_process';\nimport { list } from './pidTree';\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Kills the new process and its sub processes.\n */\nconst createKillHandler = (\n  child: ChildProcess\n): ((signal?: NodeJS.Signals | number) => boolean) => {\n  return (signal?: NodeJS.Signals | number): boolean => {\n    if (!child.pid) return false;\n\n    // Try using list if available\n    try {\n      list(child.pid, { root: true }, (err: Error | null, pids?: number[]) => {\n        if (err) {\n          // Fallback to process group kill\n          try {\n            process.kill(-child.pid!, signal ?? 'SIGTERM');\n          } catch {\n            // ignore\n          }\n          return;\n        }\n\n        if (!pids) {\n          // Fallback to process group kill if no pids returned\n          try {\n            process.kill(-child.pid!, signal ?? 'SIGTERM');\n          } catch {\n            // ignore\n          }\n          return;\n        }\n\n        for (const pid of pids) {\n          try {\n            process.kill(pid, signal ?? 'SIGTERM');\n          } catch (_err) {\n            // ignore.\n          }\n        }\n      });\n    } catch {\n      // pidtree not available, use process group kill\n      try {\n        process.kill(-child.pid, signal ?? 'SIGTERM');\n      } catch {\n        // ignore\n      }\n    }\n\n    return true;\n  };\n};\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Launches a new process with the given command.\n * This is almost same as `child_process.spawn`.\n *\n * This returns a `ChildProcess` instance.\n * `kill` method of the instance kills the new process and its sub processes.\n *\n * @param command - The command to run.\n * @param args - List of string arguments.\n * @param options - Options.\n * @returns A ChildProcess instance of new process.\n * @private\n */\nexport const spawnPosix = (\n  command: string,\n  args: string[],\n  options: SpawnOptions\n): ChildProcess => {\n  const child = nodeSpawn(command, args, options);\n  child.kill = createKillHandler(child);\n\n  return child;\n};\n"],"mappings":";;;;;;;AAeA,MAAM,qBACJ,UACoD;AACpD,SAAQ,WAA8C;AACpD,MAAI,CAAC,MAAM,IAAK,QAAO;AAGvB,MAAI;AACF,QAAK,MAAM,KAAK,EAAE,MAAM,MAAM,GAAG,KAAmB,SAAoB;AACtE,QAAI,KAAK;AAEP,SAAI;AACF,cAAQ,KAAK,CAAC,MAAM,KAAM,UAAU,UAAU;aACxC;AAGR;;AAGF,QAAI,CAAC,MAAM;AAET,SAAI;AACF,cAAQ,KAAK,CAAC,MAAM,KAAM,UAAU,UAAU;aACxC;AAGR;;AAGF,SAAK,MAAM,OAAO,KAChB,KAAI;AACF,aAAQ,KAAK,KAAK,UAAU,UAAU;aAC/B,MAAM;KAIjB;UACI;AAEN,OAAI;AACF,YAAQ,KAAK,CAAC,MAAM,KAAK,UAAU,UAAU;WACvC;;AAKV,SAAO;;;;;;;;;;;;;;;;AAqBX,MAAa,cACX,SACA,MACA,YACiB;CACjB,MAAM,QAAQA,MAAU,SAAS,MAAM,QAAQ;AAC/C,OAAM,OAAO,kBAAkB,MAAM;AAErC,QAAO"}

package/dist/esm/utils/runParallel/spawnWin32.mjs

@@ -0,0 +1,42 @@
+import { spawn } from "node:child_process";
+
+//#region src/utils/runParallel/spawnWin32.ts
+/**
+* Kills the new process and its sub processes forcibly.
+*/
+const createKillHandler = (child) => {
+	return () => {
+		if (!child.pid) return false;
+		try {
+			spawn("taskkill", [
+				"/F",
+				"/T",
+				"/PID",
+				String(child.pid)
+			], { stdio: "ignore" });
+		} catch {}
+		return true;
+	};
+};
+/**
+* Launches a new process with the given command.
+* This is almost same as `child_process.spawn`.
+*
+* This returns a `ChildProcess` instance.
+* `kill` method of the instance kills the new process and its sub processes forcibly.
+*
+* @param command - The command to run.
+* @param args - List of string arguments.
+* @param options - Options.
+* @returns A ChildProcess instance of new process.
+* @private
+*/
+const spawnWin32 = (command, args, options) => {
+	const child = spawn(command, args, options);
+	child.kill = createKillHandler(child);
+	return child;
+};
+
+//#endregion
+export { spawnWin32 };
+//# sourceMappingURL=spawnWin32.mjs.map

package/dist/esm/utils/runParallel/spawnWin32.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnWin32.mjs","names":["nodeSpawn"],"sources":["../../../../src/utils/runParallel/spawnWin32.ts"],"sourcesContent":["//------------------------------------------------------------------------------\n// Requirements\n//------------------------------------------------------------------------------\n\nimport type { SpawnOptions } from 'node:child_process';\nimport { type ChildProcess, spawn as nodeSpawn } from 'node:child_process';\n\n//------------------------------------------------------------------------------\n// Helpers\n//------------------------------------------------------------------------------\n\n/**\n * Kills the new process and its sub processes forcibly.\n */\nconst createKillHandler = (child: ChildProcess) => {\n  return (): boolean => {\n    if (!child.pid) return false;\n\n    try {\n      nodeSpawn('taskkill', ['/F', '/T', '/PID', String(child.pid)], {\n        stdio: 'ignore',\n      });\n    } catch {\n      // ignore\n    }\n\n    return true;\n  };\n};\n\n//------------------------------------------------------------------------------\n// Public Interface\n//------------------------------------------------------------------------------\n\n/**\n * Launches a new process with the given command.\n * This is almost same as `child_process.spawn`.\n *\n * This returns a `ChildProcess` instance.\n * `kill` method of the instance kills the new process and its sub processes forcibly.\n *\n * @param command - The command to run.\n * @param args - List of string arguments.\n * @param options - Options.\n * @returns A ChildProcess instance of new process.\n * @private\n */\nexport const spawnWin32 = (\n  command: string,\n  args: string[],\n  options: SpawnOptions\n): ChildProcess => {\n  const child = nodeSpawn(command, args, options);\n  child.kill = createKillHandler(child);\n\n  return child;\n};\n"],"mappings":";;;;;;AAcA,MAAM,qBAAqB,UAAwB;AACjD,cAAsB;AACpB,MAAI,CAAC,MAAM,IAAK,QAAO;AAEvB,MAAI;AACF,SAAU,YAAY;IAAC;IAAM;IAAM;IAAQ,OAAO,MAAM,IAAI;IAAC,EAAE,EAC7D,OAAO,UACR,CAAC;UACI;AAIR,SAAO;;;;;;;;;;;;;;;;AAqBX,MAAa,cACX,SACA,MACA,YACiB;CACjB,MAAM,QAAQA,MAAU,SAAS,MAAM,QAAQ;AAC/C,OAAM,OAAO,kBAAkB,MAAM;AAErC,QAAO"}

package/dist/esm/utils/runParallel/wmic.mjs

@@ -0,0 +1,50 @@
+import { run } from "./bin.mjs";
+import * as os from "node:os";
+
+//#region src/utils/runParallel/wmic.ts
+/**
+* Gets the list of all the pids of the system through the wmic command.
+* @param callback Callback function with error and process list.
+*/
+const wmic = (callback) => {
+	run("wmic", [
+		"PROCESS",
+		"get",
+		"ParentProcessId,ProcessId"
+	], {
+		windowsHide: true,
+		windowsVerbatimArguments: true
+	}, (err, stdout, code) => {
+		if (err) {
+			callback(err);
+			return;
+		}
+		if (code !== 0) {
+			callback(/* @__PURE__ */ new Error(`pidtree wmic command exited with code ${code}`));
+			return;
+		}
+		if (!stdout) {
+			callback(/* @__PURE__ */ new Error("No stdout received from wmic command"));
+			return;
+		}
+		try {
+			const lines = stdout.split(os.EOL);
+			const list = [];
+			for (let i = 1; i < lines.length; i++) {
+				const trimmed = lines[i].trim();
+				if (!trimmed) continue;
+				const parts = trimmed.split(/\s+/);
+				const ppid = parseInt(parts[0], 10);
+				const pid = parseInt(parts[1], 10);
+				if (!Number.isNaN(ppid) && !Number.isNaN(pid)) list.push([ppid, pid]);
+			}
+			callback(null, list);
+		} catch (error) {
+			callback(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+};
+
+//#endregion
+export { wmic };
+//# sourceMappingURL=wmic.mjs.map

package/dist/esm/utils/runParallel/wmic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wmic.mjs","names":["list: ProcessList"],"sources":["../../../../src/utils/runParallel/wmic.ts"],"sourcesContent":["import type { SpawnOptions } from 'node:child_process';\nimport * as os from 'node:os';\nimport { run } from './bin';\n\ntype ProcessList = [number, number][]; // [PPID, PID][]\ntype ProcessListCallback = (err: Error | null, list?: ProcessList) => void;\n\n/**\n * Gets the list of all the pids of the system through the wmic command.\n * @param callback Callback function with error and process list.\n */\nexport const wmic = (callback: ProcessListCallback): void => {\n  const args = ['PROCESS', 'get', 'ParentProcessId,ProcessId'];\n  const options: SpawnOptions = {\n    windowsHide: true,\n    windowsVerbatimArguments: true,\n  };\n  run('wmic', args, options, (err, stdout, code) => {\n    if (err) {\n      callback(err);\n      return;\n    }\n\n    if (code !== 0) {\n      callback(new Error(`pidtree wmic command exited with code ${code}`));\n      return;\n    }\n\n    // Example of stdout\n    //\n    // ParentProcessId  ProcessId\n    // 0                777\n\n    if (!stdout) {\n      callback(new Error('No stdout received from wmic command'));\n      return;\n    }\n\n    try {\n      const lines = stdout.split(os.EOL);\n\n      const list: ProcessList = [];\n      for (let i = 1; i < lines.length; i++) {\n        const trimmed = lines[i].trim();\n        if (!trimmed) continue;\n        const parts = trimmed.split(/\\s+/);\n        const ppid = parseInt(parts[0], 10); // PPID\n        const pid = parseInt(parts[1], 10); // PID\n        if (!Number.isNaN(ppid) && !Number.isNaN(pid)) {\n          list.push([ppid, pid]);\n        }\n      }\n\n      callback(null, list);\n    } catch (error) {\n      callback(error instanceof Error ? error : new Error(String(error)));\n    }\n  });\n};\n"],"mappings":";;;;;;;;AAWA,MAAa,QAAQ,aAAwC;AAM3D,KAAI,QALS;EAAC;EAAW;EAAO;EAA4B,EAC9B;EAC5B,aAAa;EACb,0BAA0B;EAC3B,GAC2B,KAAK,QAAQ,SAAS;AAChD,MAAI,KAAK;AACP,YAAS,IAAI;AACb;;AAGF,MAAI,SAAS,GAAG;AACd,4BAAS,IAAI,MAAM,yCAAyC,OAAO,CAAC;AACpE;;AAQF,MAAI,CAAC,QAAQ;AACX,4BAAS,IAAI,MAAM,uCAAuC,CAAC;AAC3D;;AAGF,MAAI;GACF,MAAM,QAAQ,OAAO,MAAM,GAAG,IAAI;GAElC,MAAMA,OAAoB,EAAE;AAC5B,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;IACrC,MAAM,UAAU,MAAM,GAAG,MAAM;AAC/B,QAAI,CAAC,QAAS;IACd,MAAM,QAAQ,QAAQ,MAAM,MAAM;IAClC,MAAM,OAAO,SAAS,MAAM,IAAI,GAAG;IACnC,MAAM,MAAM,SAAS,MAAM,IAAI,GAAG;AAClC,QAAI,CAAC,OAAO,MAAM,KAAK,IAAI,CAAC,OAAO,MAAM,IAAI,CAC3C,MAAK,KAAK,CAAC,MAAM,IAAI,CAAC;;AAI1B,YAAS,MAAM,KAAK;WACb,OAAO;AACd,YAAS,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,CAAC;;GAErE"}

package/dist/types/buildIntlayerDictionary/buildIntlayerDictionary.d.ts

@@ -1,14 +1,14 @@
 import { UnmergedDictionaryOutput } from "./writeUnmergedDictionary.js";
 import { MergedDictionaryOutput } from "./writeMergedDictionary.js";
 import { LocalizedDictionaryOutput } from "./writeDynamicDictionary.js";
-import * as _intlayer_types5 from "@intlayer/types";
+import * as _intlayer_types0 from "@intlayer/types";
 import { Dictionary } from "@intlayer/types";
 
 //#region src/buildIntlayerDictionary/buildIntlayerDictionary.d.ts
 /**
  * This function transpile the bundled code to to make dictionaries as JSON files
  */
-declare const buildDictionary: (localDictionariesEntries: Dictionary[], configuration?: _intlayer_types5.IntlayerConfig, formats?: ("cjs" | "esm")[], importOtherDictionaries?: boolean) => Promise<{
+declare const buildDictionary: (localDictionariesEntries: Dictionary[], configuration?: _intlayer_types0.IntlayerConfig, formats?: ("cjs" | "esm")[], importOtherDictionaries?: boolean) => Promise<{
   unmergedDictionaries: UnmergedDictionaryOutput;
   mergedDictionaries: MergedDictionaryOutput;
   dynamicDictionaries: LocalizedDictionaryOutput;

package/dist/types/buildIntlayerDictionary/writeDynamicDictionary.d.ts

@@ -1,5 +1,5 @@
 import { MergedDictionaryOutput } from "./writeMergedDictionary.js";
-import * as _intlayer_types0 from "@intlayer/types";
+import * as _intlayer_types2 from "@intlayer/types";
 import { Dictionary, Locale } from "@intlayer/types";
 
 //#region src/buildIntlayerDictionary/writeDynamicDictionary.d.ts
@@ -12,7 +12,7 @@ type LocalizedDictionaryOutput = Record<string, LocalizedDictionaryResult>;
 /**
  * This function generates the content of the dictionary list file
  */
-declare const generateDictionaryEntryPoint: (localizedDictionariesPathsRecord: LocalizedDictionaryResult, format?: "cjs" | "esm", configuration?: _intlayer_types0.IntlayerConfig) => string;
+declare const generateDictionaryEntryPoint: (localizedDictionariesPathsRecord: LocalizedDictionaryResult, format?: "cjs" | "esm", configuration?: _intlayer_types2.IntlayerConfig) => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -29,7 +29,7 @@ declare const generateDictionaryEntryPoint: (localizedDictionariesPathsRecord: L
  * // { key: 'home', content: { ... } },
  * ```
  */
-declare const writeDynamicDictionary: (mergedDictionaries: MergedDictionaryOutput, configuration?: _intlayer_types0.IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
+declare const writeDynamicDictionary: (mergedDictionaries: MergedDictionaryOutput, configuration?: _intlayer_types2.IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
 //#endregion
 export { DictionaryResult, LocalizedDictionaryOutput, LocalizedDictionaryResult, generateDictionaryEntryPoint, writeDynamicDictionary };
 //# sourceMappingURL=writeDynamicDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeFetchDictionary.d.ts

@@ -1,11 +1,11 @@
 import { LocalizedDictionaryOutput, LocalizedDictionaryResult } from "./writeDynamicDictionary.js";
-import * as _intlayer_types7 from "@intlayer/types";
+import * as _intlayer_types0 from "@intlayer/types";
 
 //#region src/buildIntlayerDictionary/writeFetchDictionary.d.ts
 /**
  * This function generates the content of the dictionary list file
  */
-declare const generateDictionaryEntryPoint: (localedDictionariesPathsRecord: LocalizedDictionaryResult, format?: "cjs" | "esm", configuration?: _intlayer_types7.IntlayerConfig) => string;
+declare const generateDictionaryEntryPoint: (localedDictionariesPathsRecord: LocalizedDictionaryResult, format?: "cjs" | "esm", configuration?: _intlayer_types0.IntlayerConfig) => string;
 /**
  * Write the localized dictionaries to the dictionariesDir
  * @param mergedDictionaries - The merged dictionaries
@@ -22,7 +22,7 @@ declare const generateDictionaryEntryPoint: (localedDictionariesPathsRecord: Loc
  * // { key: 'home', content: { ... } },
  * ```
  */
-declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration?: _intlayer_types7.IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
+declare const writeFetchDictionary: (dynamicDictionaries: LocalizedDictionaryOutput, configuration?: _intlayer_types0.IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<LocalizedDictionaryOutput>;
 //#endregion
 export { generateDictionaryEntryPoint, writeFetchDictionary };
 //# sourceMappingURL=writeFetchDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeMergedDictionary.d.ts

@@ -1,5 +1,5 @@
 import { UnmergedDictionaryOutput } from "./writeUnmergedDictionary.js";
-import * as _intlayer_types4 from "@intlayer/types";
+import * as _intlayer_types6 from "@intlayer/types";
 import { Dictionary } from "@intlayer/types";
 
 //#region src/buildIntlayerDictionary/writeMergedDictionary.d.ts
@@ -24,7 +24,7 @@ type MergedDictionaryOutput = Record<string, MergedDictionaryResult>;
  * // { key: 'home', content: { ... } },
  * ```
  */
-declare const writeMergedDictionaries: (groupedDictionaries: UnmergedDictionaryOutput, configuration?: _intlayer_types4.IntlayerConfig) => Promise<MergedDictionaryOutput>;
+declare const writeMergedDictionaries: (groupedDictionaries: UnmergedDictionaryOutput, configuration?: _intlayer_types6.IntlayerConfig) => Promise<MergedDictionaryOutput>;
 //#endregion
 export { MergedDictionaryOutput, MergedDictionaryResult, writeMergedDictionaries };
 //# sourceMappingURL=writeMergedDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeRemoteDictionary.d.ts

@@ -1,4 +1,4 @@
-import * as _intlayer_types1 from "@intlayer/types";
+import * as _intlayer_types4 from "@intlayer/types";
 import { Dictionary } from "@intlayer/types";
 
 //#region src/buildIntlayerDictionary/writeRemoteDictionary.d.ts
@@ -19,7 +19,7 @@ import { Dictionary } from "@intlayer/types";
  * // { key: 'home', content: { ... } },
  * ```
  */
-declare const writeRemoteDictionary: (remoteDictionaries: Dictionary[], configuration?: _intlayer_types1.IntlayerConfig) => Promise<Dictionary[]>;
+declare const writeRemoteDictionary: (remoteDictionaries: Dictionary[], configuration?: _intlayer_types4.IntlayerConfig) => Promise<Dictionary[]>;
 //#endregion
 export { writeRemoteDictionary };
 //# sourceMappingURL=writeRemoteDictionary.d.ts.map

package/dist/types/createDictionaryEntryPoint/createDictionaryEntryPoint.d.ts

@@ -1,10 +1,10 @@
-import * as _intlayer_types3 from "@intlayer/types";
+import * as _intlayer_types5 from "@intlayer/types";
 
 //#region src/createDictionaryEntryPoint/createDictionaryEntryPoint.d.ts
 /**
  * This function generates a list of dictionaries in the main directory
  */
-declare const createDictionaryEntryPoint: (configuration?: _intlayer_types3.IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<void>;
+declare const createDictionaryEntryPoint: (configuration?: _intlayer_types5.IntlayerConfig, formats?: ("cjs" | "esm")[]) => Promise<void>;
 //#endregion
 export { createDictionaryEntryPoint };
 //# sourceMappingURL=createDictionaryEntryPoint.d.ts.map

package/dist/types/createDictionaryEntryPoint/generateDictionaryListContent.d.ts

@@ -1,10 +1,10 @@
-import * as _intlayer_types2 from "@intlayer/types";
+import * as _intlayer_types7 from "@intlayer/types";
 
 //#region src/createDictionaryEntryPoint/generateDictionaryListContent.d.ts
 /**
  * This function generates the content of the dictionary list file
  */
-declare const generateDictionaryListContent: (dictionaries: string[], functionName: string, format?: "cjs" | "esm", configuration?: _intlayer_types2.IntlayerConfig) => string;
+declare const generateDictionaryListContent: (dictionaries: string[], functionName: string, format?: "cjs" | "esm", configuration?: _intlayer_types7.IntlayerConfig) => string;
 //#endregion
 export { generateDictionaryListContent };
 //# sourceMappingURL=generateDictionaryListContent.d.ts.map

package/dist/types/index.d.ts

@@ -35,7 +35,7 @@ import { getGlobalLimiter, getTaskLimiter, parallelizeGlobal } from "./utils/par
 import { reduceObjectFormat } from "./utils/reduceObjectFormat.js";
 import { resolveObjectPromises } from "./utils/resolveObjectPromises.js";
 import { runOnce } from "./utils/runOnce.js";
-import { ParallelHandle, runParallel } from "./utils/runParallel.js";
+import { ParallelHandle, runParallel } from "./utils/runParallel/index.js";
 import { sortAlphabetically } from "./utils/sortAlphabetically.js";
 import { splitTextByLines } from "./utils/splitTextByLine.js";
 import { verifyIdenticObjectFormat } from "./utils/verifyIdenticObjectFormat.js";
@@ -45,5 +45,6 @@ import { DictionaryStatus } from "./writeContentDeclaration/dictionaryStatus.js"
 import { transformJSFile } from "./writeContentDeclaration/transformJSFile.js";
 import { writeContentDeclaration } from "./writeContentDeclaration/writeContentDeclaration.js";
 import { writeJSFile } from "./writeContentDeclaration/writeJSFile.js";
+import { detectFormatCommand } from "./writeContentDeclaration/detectFormatCommand.js";
 import { processContentDeclarationContent } from "./writeContentDeclaration/processContentDeclarationContent.js";
-export { type DictionaryStatus, type DiffMode, type Extension, type Format, type JSONObject, type JsonChunk, type ListGitFilesOptions, type ListGitLinesOptions, type ParallelHandle, assembleJSON, buildAndWatchIntlayer, buildDictionary, chunkJSON, cleanOutputDir, createDictionaryEntryPoint, createModuleAugmentation, createTypes, detectExportedComponentName, fetchDistantDictionaries, formatLocale, formatPath, generateDictionaryListContent, getBuiltDictionariesPath, getBuiltDynamicDictionariesPath, getBuiltFetchDictionariesPath, getBuiltRemoteDictionariesPath, getBuiltUnmergedDictionariesPath, getChunk, getContentDeclarationFileTemplate, getExtensionFromFormat, getFileHash, getFormatFromExtension, getGlobalLimiter, getTaskLimiter, handleAdditionalContentDeclarationFile, handleContentDeclarationFileChange, handleUnlinkedContentDeclarationFile, isInvalidDictionary, kebabCaseToCamelCase, listDictionaries, listGitFiles, listGitLines, loadContentDeclarations, loadDictionaries, loadLocalDictionaries, loadRemoteDictionaries, pLimit, parallelize, parallelizeGlobal, prepareIntlayer, processContentDeclarationContent, reconstructFromSingleChunk, reduceDictionaryContent, reduceObjectFormat, resolveObjectPromises, runOnce, runParallel, sortAlphabetically, splitTextByLines, transformJSFile, verifyIdenticObjectFormat, watch, writeContentDeclaration, writeJSFile };
+export { type DictionaryStatus, type DiffMode, type Extension, type Format, type JSONObject, type JsonChunk, type ListGitFilesOptions, type ListGitLinesOptions, type ParallelHandle, assembleJSON, buildAndWatchIntlayer, buildDictionary, chunkJSON, cleanOutputDir, createDictionaryEntryPoint, createModuleAugmentation, createTypes, detectExportedComponentName, detectFormatCommand, fetchDistantDictionaries, formatLocale, formatPath, generateDictionaryListContent, getBuiltDictionariesPath, getBuiltDynamicDictionariesPath, getBuiltFetchDictionariesPath, getBuiltRemoteDictionariesPath, getBuiltUnmergedDictionariesPath, getChunk, getContentDeclarationFileTemplate, getExtensionFromFormat, getFileHash, getFormatFromExtension, getGlobalLimiter, getTaskLimiter, handleAdditionalContentDeclarationFile, handleContentDeclarationFileChange, handleUnlinkedContentDeclarationFile, isInvalidDictionary, kebabCaseToCamelCase, listDictionaries, listGitFiles, listGitLines, loadContentDeclarations, loadDictionaries, loadLocalDictionaries, loadRemoteDictionaries, pLimit, parallelize, parallelizeGlobal, prepareIntlayer, processContentDeclarationContent, reconstructFromSingleChunk, reduceDictionaryContent, reduceObjectFormat, resolveObjectPromises, runOnce, runParallel, sortAlphabetically, splitTextByLines, transformJSFile, verifyIdenticObjectFormat, watch, writeContentDeclaration, writeJSFile };

package/dist/types/loadDictionaries/loadRemoteDictionaries.d.ts

@@ -1,11 +1,11 @@
 import { DictionariesStatus } from "./loadDictionaries.js";
-import * as _intlayer_types6 from "@intlayer/types";
+import * as _intlayer_types8 from "@intlayer/types";
 import { Dictionary } from "@intlayer/types";
 import { DictionaryAPI } from "@intlayer/backend";
 
 //#region src/loadDictionaries/loadRemoteDictionaries.d.ts
 declare const formatDistantDictionaries: (dictionaries: (DictionaryAPI | Dictionary)[]) => Dictionary[];
-declare const loadRemoteDictionaries: (configuration?: _intlayer_types6.IntlayerConfig, onStatusUpdate?: (status: DictionariesStatus[]) => void, options?: {
+declare const loadRemoteDictionaries: (configuration?: _intlayer_types8.IntlayerConfig, onStatusUpdate?: (status: DictionariesStatus[]) => void, options?: {
   onStartRemoteCheck?: () => void;
   onStopRemoteCheck?: () => void;
   onError?: (error: Error) => void;

package/dist/types/utils/runParallel/bin.d.ts

@@ -0,0 +1,15 @@
+import { SpawnOptions } from "node:child_process";
+
+//#region src/utils/runParallel/bin.d.ts
+type BinCallback = (err: Error | null, stdout?: string, code?: number) => void;
+/**
+ * Spawn a binary and read its stdout.
+ * @param cmd The name of the binary to spawn.
+ * @param args The arguments for the binary.
+ * @param options Optional option for the spawn function.
+ * @param done Callback function.
+ */
+declare const run: (cmd: string, args: string[], options: SpawnOptions | BinCallback | undefined, done?: BinCallback) => void;
+//#endregion
+export { run };
+//# sourceMappingURL=bin.d.ts.map

package/dist/types/utils/runParallel/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","names":[],"sources":["../../../../src/utils/runParallel/bin.ts"],"sourcesContent":[],"mappings":";;;KAGK,WAAA,SAAoB;;AAFqC;AAsB9D;;;;;cAAa,4CAGF,eAAe,gCACjB"}

package/dist/types/utils/runParallel/bootstrap.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/runParallel/bootstrap.d.ts
+declare const bootstrap: (_name: string) => void | Promise<void>;
+//#endregion
+export { bootstrap };
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/types/utils/runParallel/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","names":[],"sources":["../../../../src/utils/runParallel/bootstrap.ts"],"sourcesContent":[],"mappings":";cAIa,qCAAoC"}

package/dist/types/utils/runParallel/index.d.ts

@@ -0,0 +1,14 @@
+//#region src/utils/runParallel/index.d.ts
+type ParallelHandle = {
+  kill: () => void;
+  result: Promise<any>;
+  commandText: string;
+};
+/**
+ * Start a cross-platform parallel process using npm-run-all approach.
+ * Accepts either a single string (e.g., 'next start') or an array of tokens (e.g., ['next', 'start']).
+ */
+declare const runParallel: (proc?: string | string[]) => ParallelHandle;
+//#endregion
+export { ParallelHandle, runParallel };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/utils/runParallel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/utils/runParallel/index.ts"],"sourcesContent":[],"mappings":";KAIY,cAAA;EAAA,IAAA,EAAA,GAAA,GAAA,IAAA;EAUC,MAAA,EARH,OAsIT,CAAA,GAAA,CAAA;;;;;;;cA9HY,2CAA0C"}

package/dist/types/utils/runParallel/pidTree.d.ts

@@ -0,0 +1,24 @@
+//#region src/utils/runParallel/pidTree.d.ts
+interface ListOptions {
+  root?: boolean;
+  advanced?: boolean;
+}
+type ProcessInfo = {
+  pid: number;
+  ppid?: number;
+};
+type ResultType<T extends ListOptions | undefined> = T extends {
+  advanced: true;
+} ? ProcessInfo[] : number[];
+type ListCallback<T extends ListOptions | undefined> = (err: Error | null, list?: ResultType<T>) => void;
+/**
+ * Get the list of children pids of the given pid.
+ * @param pid A PID. If -1 will return all the pids.
+ * @param options Optional options object.
+ * @param callback Called when the list is ready. If not provided a promise is returned instead.
+ * @returns Only when the callback is not provided.
+ */
+declare const list: <T extends ListOptions | undefined>(pid: number | string, options?: T | ListCallback<T>, callback?: ListCallback<T>) => Promise<ResultType<T>> | undefined;
+//#endregion
+export { list };
+//# sourceMappingURL=pidTree.d.ts.map

package/dist/types/utils/runParallel/pidTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pidTree.d.ts","names":[],"sources":["../../../../src/utils/runParallel/pidTree.ts"],"sourcesContent":[],"mappings":";UAgBU,WAAA;EAAA,IAAA,CAAA,EAAA,OAAW;EAKhB,QAAA,CAAA,EAAA,OAAW;AAAA;KAAX,WAAA,GACqB;EAA2B,GAAA,EAAA,MAAA;EAGjD,IAAA,CAAA,EAAA,MAAA;CAAW;AAAA,KAHV,UAOA,CAAA,UAPqB,WAOT,GAAA,SAAA,CAAA,GAPoC,CAOpC,SAAA;EAAW,QAAA,EAAA,IAAA;CACrB,GALH,WAKG,EAAA,GAAA,MAAA,EAAA;KADF,YAEe,CAAA,UAFQ,WAER,GAAA,SAAA,CAAA,GAAA,CAAA,GAAA,EADb,KACa,GAAA,IAAA,EAAA,IAAA,CAAA,EAAX,UAAW,CAAA,CAAA,CAAA,EAAA,GAAA,IAAA;;;AA8LpB;;;;;AAG0B,cAHb,IAGa,EAAA,CAAA,UAHK,WAGL,GAAA,SAAA,CAAA,CAAA,GAAA,EAAA,MAAA,GAAA,MAAA,EAAA,OAAA,CAAA,EADd,CACc,GADV,YACU,CADG,CACH,CAAA,EAAA,QAAA,CAAA,EAAb,YAAa,CAAA,CAAA,CAAA,EAAA,GACvB,OADuB,CACf,UADe,CACJ,CADI,CAAA,CAAA,GAAA,SAAA"}

package/dist/types/utils/runParallel/ps.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/runParallel/ps.d.ts
+type ProcessList = [number, number][];
+type ProcessListCallback = (err: Error | null, list?: ProcessList) => void;
+/**
+ * Gets the list of all the pids of the system through the ps command.
+ * @param callback Callback function with error and process list.
+ */
+declare const ps: (callback: ProcessListCallback) => void;
+//#endregion
+export { ps };
+//# sourceMappingURL=ps.d.ts.map

package/dist/types/utils/runParallel/ps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ps.d.ts","names":[],"sources":["../../../../src/utils/runParallel/ps.ts"],"sourcesContent":[],"mappings":";KAGK,WAAA;KACA,mBAAA,GADW,CAAA,GAAA,EACiB,KADjB,GAAA,IAAA,EAAA,IAAA,CAAA,EACsC,WADtC,EAAA,GAAA,IAAA;AAAA;AAOhB;;;cAAa,eAAgB"}

package/dist/types/utils/runParallel/runTask.d.ts

@@ -0,0 +1,26 @@
+//#region src/utils/runParallel/runTask.d.ts
+interface TaskResult {
+  name: string;
+  code: number | null;
+  signal?: string | null;
+}
+interface RunTaskOptions {
+  stdout: NodeJS.WritableStream;
+  stderr?: NodeJS.WritableStream;
+  aggregateOutput?: boolean;
+  continueOnError?: boolean;
+  race?: boolean;
+  maxParallel?: number;
+}
+/**
+ * Run npm-scripts of given names in parallel.
+ *
+ * If a npm-script exited with a non-zero code, this aborts other all npm-scripts.
+ *
+ * Note: This is a simplified version for our use case.
+ * The full implementation would require the actual runTask function from npm-run-all.
+ */
+declare const runTasks: (tasks: string[], options: RunTaskOptions) => Promise<TaskResult[]>;
+//#endregion
+export { runTasks };
+//# sourceMappingURL=runTask.d.ts.map