@intlayer/engine 9.0.0-canary.12

package/dist/cjs/utils/getPathHash.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/getPathHash.ts
+/**
+* Fast hashing using cyrb53 algorithm for small unique strings with low collisions risk
+*/
+const getPathHash = (filePath) => {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let i = 0; i < filePath.length; i++) {
+		const ch = filePath.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+};
+
+//#endregion
+exports.getPathHash = getPathHash;
+//# sourceMappingURL=getPathHash.cjs.map

package/dist/cjs/utils/getPathHash.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPathHash.cjs","names":[],"sources":["../../../src/utils/getPathHash.ts"],"sourcesContent":["/**\n * Fast hashing using cyrb53 algorithm for small unique strings with low collisions risk\n */\nexport const getPathHash = (filePath: string) => {\n  let h1 = 0xdeadbeef;\n  let h2 = 0x41c6ce57;\n\n  for (let i = 0; i < filePath.length; i++) {\n    const ch = filePath.charCodeAt(i);\n    h1 = Math.imul(h1 ^ ch, 2654435761);\n    h2 = Math.imul(h2 ^ ch, 1597334677);\n  }\n\n  h1 =\n    Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^\n    Math.imul(h2 ^ (h2 >>> 13), 3266489909);\n  h2 =\n    Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^\n    Math.imul(h1 ^ (h1 >>> 13), 3266489909);\n\n  const hash53 = 4294967296 * (2097151 & h2) + (h1 >>> 0);\n\n  // Returns a string ~11 characters long, e.g., \"_1x9z5k2m8p3\"\n  return hash53.toString(36);\n};\n"],"mappings":";;;;;;AAGA,MAAa,eAAe,aAAqB;CAC/C,IAAI,KAAK;CACT,IAAI,KAAK;AAET,MAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,KAAK,SAAS,WAAW,EAAE;AACjC,OAAK,KAAK,KAAK,KAAK,IAAI,WAAW;AACnC,OAAK,KAAK,KAAK,KAAK,IAAI,WAAW;;AAGrC,MACE,KAAK,KAAK,KAAM,OAAO,IAAK,WAAW,GACvC,KAAK,KAAK,KAAM,OAAO,IAAK,WAAW;AACzC,MACE,KAAK,KAAK,KAAM,OAAO,IAAK,WAAW,GACvC,KAAK,KAAK,KAAM,OAAO,IAAK,WAAW;AAKzC,SAHe,cAAc,UAAU,OAAO,OAAO,IAGvC,SAAS,GAAG"}

package/dist/cjs/utils/index.cjs

@@ -0,0 +1,50 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_pLimit = require('./pLimit.cjs');
+const require_utils_parallelize = require('./parallelize.cjs');
+const require_utils_getPathHash = require('./getPathHash.cjs');
+const require_utils_formatter = require('./formatter.cjs');
+const require_utils_autoDecorateContent = require('./autoDecorateContent.cjs');
+const require_utils_buildComponentFilesList = require('./buildComponentFilesList.cjs');
+const require_utils_splitTextByLine = require('./splitTextByLine.cjs');
+const require_utils_getChunk = require('./getChunk.cjs');
+const require_utils_chunkJSON = require('./chunkJSON.cjs');
+const require_utils_getContentExtension = require('./getContentExtension.cjs');
+const require_utils_getFormatFromExtension = require('./getFormatFromExtension.cjs');
+const require_utils_mergeChunks = require('./mergeChunks.cjs');
+const require_utils_parallelizeGlobal = require('./parallelizeGlobal.cjs');
+const require_utils_reduceObjectFormat = require('./reduceObjectFormat.cjs');
+const require_utils_resolveObjectPromises = require('./resolveObjectPromises.cjs');
+const require_utils_resolveRelativePath = require('./resolveRelativePath.cjs');
+const require_utils_runOnce = require('./runOnce.cjs');
+const require_utils_runParallel_index = require('./runParallel/index.cjs');
+const require_utils_sortAlphabetically = require('./sortAlphabetically.cjs');
+const require_utils_verifyIdenticObjectFormat = require('./verifyIdenticObjectFormat.cjs');
+
+exports.Queue = require_utils_pLimit.Queue;
+exports.assembleJSON = require_utils_chunkJSON.assembleJSON;
+exports.autoDecorateContent = require_utils_autoDecorateContent.autoDecorateContent;
+exports.buildComponentFilesList = require_utils_buildComponentFilesList.buildComponentFilesList;
+exports.chunkJSON = require_utils_chunkJSON.chunkJSON;
+exports.excludeObjectFormat = require_utils_reduceObjectFormat.excludeObjectFormat;
+exports.formatLocale = require_utils_formatter.formatLocale;
+exports.formatPath = require_utils_formatter.formatPath;
+exports.getChunk = require_utils_getChunk.getChunk;
+exports.getContentExtension = require_utils_getContentExtension.getContentExtension;
+exports.getExtensionFromFormat = require_utils_getFormatFromExtension.getExtensionFromFormat;
+exports.getFormatFromExtension = require_utils_getFormatFromExtension.getFormatFromExtension;
+exports.getGlobalLimiter = require_utils_parallelizeGlobal.getGlobalLimiter;
+exports.getPathHash = require_utils_getPathHash.getPathHash;
+exports.getTaskLimiter = require_utils_parallelizeGlobal.getTaskLimiter;
+exports.mergeChunks = require_utils_mergeChunks.mergeChunks;
+exports.pLimit = require_utils_pLimit.pLimit;
+exports.parallelize = require_utils_parallelize.parallelize;
+exports.parallelizeGlobal = require_utils_parallelizeGlobal.parallelizeGlobal;
+exports.reconstructFromSingleChunk = require_utils_chunkJSON.reconstructFromSingleChunk;
+exports.reduceObjectFormat = require_utils_reduceObjectFormat.reduceObjectFormat;
+exports.resolveObjectPromises = require_utils_resolveObjectPromises.resolveObjectPromises;
+exports.resolveRelativePath = require_utils_resolveRelativePath.resolveRelativePath;
+exports.runOnce = require_utils_runOnce.runOnce;
+exports.runParallel = require_utils_runParallel_index.runParallel;
+exports.sortAlphabetically = require_utils_sortAlphabetically.sortAlphabetically;
+exports.splitTextByLines = require_utils_splitTextByLine.splitTextByLines;
+exports.verifyIdenticObjectFormat = require_utils_verifyIdenticObjectFormat.verifyIdenticObjectFormat;

package/dist/cjs/utils/mergeChunks.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/mergeChunks.ts
+const mergeChunks = (chunks) => {
+	if (chunks.length === 0) return {};
+	let result = chunks[0];
+	for (let i = 1; i < chunks.length; i++) result = customChunkMerge(result, chunks[i]);
+	return result;
+};
+const customChunkMerge = (dest, source) => {
+	if (dest === void 0 || dest === null) return source;
+	if (source === void 0 || source === null) return dest;
+	if (Array.isArray(dest) && Array.isArray(source)) {
+		const maxLength = Math.max(dest.length, source.length);
+		const result = [];
+		for (let i = 0; i < maxLength; i++) result[i] = customChunkMerge(dest[i], source[i]);
+		return result;
+	}
+	if (typeof dest === "object" && typeof source === "object") {
+		const result = { ...dest };
+		for (const key of Object.keys(source)) result[key] = customChunkMerge(result[key], source[key]);
+		return result;
+	}
+	return dest;
+};
+
+//#endregion
+exports.mergeChunks = mergeChunks;
+//# sourceMappingURL=mergeChunks.cjs.map

package/dist/cjs/utils/mergeChunks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeChunks.cjs","names":[],"sources":["../../../src/utils/mergeChunks.ts"],"sourcesContent":["export const mergeChunks = (chunks: any[]): any => {\n  if (chunks.length === 0) return {};\n\n  let result = chunks[0];\n\n  for (let i = 1; i < chunks.length; i++) {\n    result = customChunkMerge(result, chunks[i]);\n  }\n\n  return result;\n};\n\nconst customChunkMerge = (dest: any, source: any): any => {\n  if (dest === undefined || dest === null) return source;\n  if (source === undefined || source === null) return dest;\n\n  if (Array.isArray(dest) && Array.isArray(source)) {\n    const maxLength = Math.max(dest.length, source.length);\n    const result = [];\n    for (let i = 0; i < maxLength; i++) {\n      result[i] = customChunkMerge(dest[i], source[i]);\n    }\n    return result;\n  }\n\n  if (typeof dest === 'object' && typeof source === 'object') {\n    const result: any = { ...dest };\n    for (const key of Object.keys(source)) {\n      result[key] = customChunkMerge(result[key], source[key]);\n    }\n    return result;\n  }\n\n  // Primitives: if we are here, both are not null.\n  // Since chunks shouldn't overlap, we can return dest.\n  return dest;\n};\n"],"mappings":";;;AAAA,MAAa,eAAe,WAAuB;AACjD,KAAI,OAAO,WAAW,EAAG,QAAO,EAAE;CAElC,IAAI,SAAS,OAAO;AAEpB,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,UAAS,iBAAiB,QAAQ,OAAO,GAAG;AAG9C,QAAO;;AAGT,MAAM,oBAAoB,MAAW,WAAqB;AACxD,KAAI,SAAS,UAAa,SAAS,KAAM,QAAO;AAChD,KAAI,WAAW,UAAa,WAAW,KAAM,QAAO;AAEpD,KAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,QAAQ,OAAO,EAAE;EAChD,MAAM,YAAY,KAAK,IAAI,KAAK,QAAQ,OAAO,OAAO;EACtD,MAAM,SAAS,EAAE;AACjB,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,IAC7B,QAAO,KAAK,iBAAiB,KAAK,IAAI,OAAO,GAAG;AAElD,SAAO;;AAGT,KAAI,OAAO,SAAS,YAAY,OAAO,WAAW,UAAU;EAC1D,MAAM,SAAc,EAAE,GAAG,MAAM;AAC/B,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,CACnC,QAAO,OAAO,iBAAiB,OAAO,MAAM,OAAO,KAAK;AAE1D,SAAO;;AAKT,QAAO"}

package/dist/cjs/utils/pLimit.cjs

@@ -0,0 +1,134 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/pLimit.ts
+var Node = class {
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node(value);
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (!current) return;
+		this.#head = current.next;
+		this.#size--;
+		return current.value;
+	}
+	peek() {
+		if (!this.#head) return;
+		return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+const pLimit = (concurrency) => {
+	validateConcurrency(concurrency);
+	const queue = new Queue();
+	let activeCount = 0;
+	const idleWaiters = [];
+	const notifyIdleIfNeeded = () => {
+		if (activeCount === 0 && queue.size === 0) while (idleWaiters.length) idleWaiters.pop()?.();
+	};
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue()?.();
+		}
+	};
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+	const run = async (fn, resolve, arguments_) => {
+		const result = (async () => fn(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	};
+	const enqueue = (fn, resolve, arguments_) => {
+		new Promise((internalResolve) => {
+			queue.enqueue(internalResolve);
+		}).then(run.bind(void 0, fn, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (fn, ...arguments_) => new Promise((resolve) => {
+		enqueue(fn, resolve, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			queue.clear();
+			notifyIdleIfNeeded();
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(array, fn) {
+			const promises = array.map((value, index) => this(fn, value, index));
+			return Promise.all(promises);
+		} },
+		onIdle: { 
+		/**
+		* Resolves when `activeCount === 0` and the queue is empty.
+		* Use this to wait for completion without holding a list of Promises.
+		*/
+value() {
+			if (activeCount === 0 && queue.size === 0) return Promise.resolve();
+			return new Promise((resolve) => idleWaiters.push(resolve));
+		} }
+	});
+	return generator;
+};
+const validateConcurrency = (concurrency) => {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+};
+
+//#endregion
+exports.Queue = Queue;
+exports.pLimit = pLimit;
+//# sourceMappingURL=pLimit.cjs.map

package/dist/cjs/utils/pLimit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pLimit.cjs","names":["#head","#tail","#size"],"sources":["../../../src/utils/pLimit.ts"],"sourcesContent":["/*\nHow it works:\n`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.\n*/\n\nclass Node<T> {\n  value: T;\n  next: Node<T> | undefined;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\nexport class Queue<T> {\n  #head: Node<T> | undefined;\n  #tail: Node<T> | undefined;\n  #size!: number;\n\n  constructor() {\n    this.clear();\n  }\n\n  enqueue(value: T): void {\n    const node = new Node(value);\n\n    if (this.#head) {\n      this.#tail!.next = node;\n      this.#tail = node;\n    } else {\n      this.#head = node;\n      this.#tail = node;\n    }\n\n    this.#size++;\n  }\n\n  dequeue(): T | undefined {\n    const current = this.#head;\n    if (!current) {\n      return;\n    }\n\n    this.#head = current.next;\n    this.#size--;\n    return current.value;\n  }\n\n  peek(): T | undefined {\n    if (!this.#head) {\n      return;\n    }\n\n    return this.#head.value;\n\n    // TODO: Node.js 18.\n    // return this.#head?.value;\n  }\n\n  clear(): void {\n    this.#head = undefined;\n    this.#tail = undefined;\n    this.#size = 0;\n  }\n\n  get size(): number {\n    return this.#size;\n  }\n\n  *[Symbol.iterator](): Generator<T, void, unknown> {\n    let current = this.#head;\n\n    while (current) {\n      yield current.value;\n      current = current.next;\n    }\n  }\n\n  *drain(): Generator<T | undefined, void, unknown> {\n    while (this.#head) {\n      yield this.dequeue();\n    }\n  }\n}\n\nexport const pLimit = (concurrency: number) => {\n  validateConcurrency(concurrency);\n\n  const queue = new Queue<() => void>();\n  let activeCount = 0;\n\n  const idleWaiters: Array<() => void> = [];\n  const notifyIdleIfNeeded = (): void => {\n    if (activeCount === 0 && queue.size === 0) {\n      while (idleWaiters.length) idleWaiters.pop()?.();\n    }\n  };\n\n  const resumeNext = (): void => {\n    // Process the next queued function if we're under the concurrency limit\n    if (activeCount < concurrency && queue.size > 0) {\n      activeCount++;\n      queue.dequeue()?.();\n    }\n  };\n\n  const next = (): void => {\n    activeCount--;\n    resumeNext();\n  };\n\n  const run = async (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): Promise<void> => {\n    // Execute the function and capture the result promise\n    const result = (async () => fn(...arguments_))();\n\n    // Resolve immediately with the promise (don't wait for completion)\n    resolve(result);\n\n    // Wait for the function to complete (success or failure)\n    // We catch errors here to prevent unhandled rejections,\n    // but the original promise rejection is preserved for the caller\n    try {\n      await result;\n    } catch {}\n\n    // Decrement active count and process next queued function\n    next();\n  };\n\n  const enqueue = (\n    fn: (...args: any[]) => Promise<any>,\n    resolve: (value: Promise<any>) => void,\n    arguments_: any[]\n  ): void => {\n    // Queue the internal resolve function instead of the run function\n    // to preserve the asynchronous execution context.\n    new Promise<void>((internalResolve) => {\n      queue.enqueue(internalResolve);\n    }).then(run.bind(undefined, fn, resolve, arguments_));\n\n    // Start processing immediately if we haven't reached the concurrency limit\n    if (activeCount < concurrency) {\n      resumeNext();\n    }\n  };\n\n  const generator = (\n    fn: (...args: any[]) => Promise<any>,\n    ...arguments_: any[]\n  ): Promise<any> =>\n    new Promise<any>((resolve) => {\n      enqueue(fn, resolve, arguments_);\n    });\n\n  Object.defineProperties(generator, {\n    activeCount: {\n      get: () => activeCount,\n    },\n    pendingCount: {\n      get: () => queue.size,\n    },\n    clearQueue: {\n      value() {\n        queue.clear();\n        notifyIdleIfNeeded();\n      },\n    },\n    concurrency: {\n      get: () => concurrency,\n\n      set(newConcurrency: number) {\n        validateConcurrency(newConcurrency);\n        concurrency = newConcurrency;\n\n        queueMicrotask(() => {\n          while (activeCount < concurrency && queue.size > 0) {\n            resumeNext();\n          }\n        });\n      },\n    },\n    map: {\n      async value<T, R>(\n        array: T[],\n        fn: (value: T, index: number) => Promise<R>\n      ): Promise<R[]> {\n        const promises = array.map((value, index) => this(fn, value, index));\n        return Promise.all(promises);\n      },\n    },\n    onIdle: {\n      /**\n       * Resolves when `activeCount === 0` and the queue is empty.\n       * Use this to wait for completion without holding a list of Promises.\n       */\n      value(): Promise<void> {\n        if (activeCount === 0 && queue.size === 0) return Promise.resolve();\n        return new Promise<void>((resolve) => idleWaiters.push(resolve));\n      },\n    },\n  });\n\n  return generator;\n};\n\nconst validateConcurrency = (concurrency: number): void => {\n  if (\n    !(\n      (Number.isInteger(concurrency) ||\n        concurrency === Number.POSITIVE_INFINITY) &&\n      concurrency > 0\n    )\n  ) {\n    throw new TypeError('Expected `concurrency` to be a number from 1 and up');\n  }\n};\n"],"mappings":";;;AAKA,IAAM,OAAN,MAAc;CACZ;CACA;CAEA,YAAY,OAAU;AACpB,OAAK,QAAQ;;;AAIjB,IAAa,QAAb,MAAsB;CACpB;CACA;CACA;CAEA,cAAc;AACZ,OAAK,OAAO;;CAGd,QAAQ,OAAgB;EACtB,MAAM,OAAO,IAAI,KAAK,MAAM;AAE5B,MAAI,MAAKA,MAAO;AACd,SAAKC,KAAO,OAAO;AACnB,SAAKA,OAAQ;SACR;AACL,SAAKD,OAAQ;AACb,SAAKC,OAAQ;;AAGf,QAAKC;;CAGP,UAAyB;EACvB,MAAM,UAAU,MAAKF;AACrB,MAAI,CAAC,QACH;AAGF,QAAKA,OAAQ,QAAQ;AACrB,QAAKE;AACL,SAAO,QAAQ;;CAGjB,OAAsB;AACpB,MAAI,CAAC,MAAKF,KACR;AAGF,SAAO,MAAKA,KAAM;;CAMpB,QAAc;AACZ,QAAKA,OAAQ;AACb,QAAKC,OAAQ;AACb,QAAKC,OAAQ;;CAGf,IAAI,OAAe;AACjB,SAAO,MAAKA;;CAGd,EAAE,OAAO,YAAyC;EAChD,IAAI,UAAU,MAAKF;AAEnB,SAAO,SAAS;AACd,SAAM,QAAQ;AACd,aAAU,QAAQ;;;CAItB,CAAC,QAAiD;AAChD,SAAO,MAAKA,KACV,OAAM,KAAK,SAAS;;;AAK1B,MAAa,UAAU,gBAAwB;AAC7C,qBAAoB,YAAY;CAEhC,MAAM,QAAQ,IAAI,OAAmB;CACrC,IAAI,cAAc;CAElB,MAAM,cAAiC,EAAE;CACzC,MAAM,2BAAiC;AACrC,MAAI,gBAAgB,KAAK,MAAM,SAAS,EACtC,QAAO,YAAY,OAAQ,aAAY,KAAK,IAAI;;CAIpD,MAAM,mBAAyB;AAE7B,MAAI,cAAc,eAAe,MAAM,OAAO,GAAG;AAC/C;AACA,SAAM,SAAS,IAAI;;;CAIvB,MAAM,aAAmB;AACvB;AACA,cAAY;;CAGd,MAAM,MAAM,OACV,IACA,SACA,eACkB;EAElB,MAAM,UAAU,YAAY,GAAG,GAAG,WAAW,GAAG;AAGhD,UAAQ,OAAO;AAKf,MAAI;AACF,SAAM;UACA;AAGR,QAAM;;CAGR,MAAM,WACJ,IACA,SACA,eACS;AAGT,MAAI,SAAe,oBAAoB;AACrC,SAAM,QAAQ,gBAAgB;IAC9B,CAAC,KAAK,IAAI,KAAK,QAAW,IAAI,SAAS,WAAW,CAAC;AAGrD,MAAI,cAAc,YAChB,aAAY;;CAIhB,MAAM,aACJ,IACA,GAAG,eAEH,IAAI,SAAc,YAAY;AAC5B,UAAQ,IAAI,SAAS,WAAW;GAChC;AAEJ,QAAO,iBAAiB,WAAW;EACjC,aAAa,EACX,WAAW,aACZ;EACD,cAAc,EACZ,WAAW,MAAM,MAClB;EACD,YAAY,EACV,QAAQ;AACN,SAAM,OAAO;AACb,uBAAoB;KAEvB;EACD,aAAa;GACX,WAAW;GAEX,IAAI,gBAAwB;AAC1B,wBAAoB,eAAe;AACnC,kBAAc;AAEd,yBAAqB;AACnB,YAAO,cAAc,eAAe,MAAM,OAAO,EAC/C,aAAY;MAEd;;GAEL;EACD,KAAK,EACH,MAAM,MACJ,OACA,IACc;GACd,MAAM,WAAW,MAAM,KAAK,OAAO,UAAU,KAAK,IAAI,OAAO,MAAM,CAAC;AACpE,UAAO,QAAQ,IAAI,SAAS;KAE/B;EACD,QAAQ;;;;;AAKN,QAAuB;AACrB,OAAI,gBAAgB,KAAK,MAAM,SAAS,EAAG,QAAO,QAAQ,SAAS;AACnE,UAAO,IAAI,SAAe,YAAY,YAAY,KAAK,QAAQ,CAAC;KAEnE;EACF,CAAC;AAEF,QAAO;;AAGT,MAAM,uBAAuB,gBAA8B;AACzD,KACE,GACG,OAAO,UAAU,YAAY,IAC5B,gBAAgB,OAAO,sBACzB,cAAc,GAGhB,OAAM,IAAI,UAAU,sDAAsD"}

package/dist/cjs/utils/parallelize.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_pLimit = require('./pLimit.cjs');
+
+//#region src/utils/parallelize.ts
+const parallelize = async (items, callback = async (item) => item, parallelLimit = 10) => {
+	const limit = require_utils_pLimit.pLimit(parallelLimit);
+	return Promise.all(items.map((item) => limit(() => callback(item))));
+};
+
+//#endregion
+exports.parallelize = parallelize;
+//# sourceMappingURL=parallelize.cjs.map

package/dist/cjs/utils/parallelize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelize.cjs","names":["pLimit"],"sources":["../../../src/utils/parallelize.ts"],"sourcesContent":["import { pLimit } from './pLimit';\n\nexport const parallelize = async <T, R>(\n  items: T[],\n  callback: (item: T) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  parallelLimit: number = 10\n): Promise<R[]> => {\n  const limit = pLimit(parallelLimit);\n  return Promise.all(items.map((item) => limit(() => callback(item))));\n};\n"],"mappings":";;;;AAEA,MAAa,cAAc,OACzB,OACA,WAAoC,OAAO,SACzC,MACF,gBAAwB,OACP;CACjB,MAAM,QAAQA,4BAAO,cAAc;AACnC,QAAO,QAAQ,IAAI,MAAM,KAAK,SAAS,YAAY,SAAS,KAAK,CAAC,CAAC,CAAC"}

package/dist/cjs/utils/parallelizeGlobal.cjs

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_pLimit = require('./pLimit.cjs');
+
+//#region src/utils/parallelizeGlobal.ts
+let _globalLimiter = null;
+/** Get (and optionally configure) the single, shared limiter. */
+const getGlobalLimiter = (concurrency) => {
+	if (!_globalLimiter) _globalLimiter = require_utils_pLimit.pLimit(concurrency ?? 10);
+	else if (typeof concurrency === "number") _globalLimiter.concurrency = concurrency;
+	return _globalLimiter;
+};
+let _taskLimiter = null;
+/** Limits how many *tasks* run concurrently (independent from AI calls). */
+const getTaskLimiter = (concurrency) => {
+	if (!_taskLimiter) _taskLimiter = require_utils_pLimit.pLimit(concurrency ?? 5);
+	else if (typeof concurrency === "number") _taskLimiter.concurrency = concurrency;
+	return _taskLimiter;
+};
+const parallelizeGlobal = async (items, callback = async (item) => item, options) => {
+	const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);
+	const run = options?.wrapInLimiter ?? true ? (fn) => limiter(fn) : (fn) => fn();
+	const promises = items.map((item, index) => run(() => callback(item, index)));
+	return Promise.all(promises);
+};
+
+//#endregion
+exports.getGlobalLimiter = getGlobalLimiter;
+exports.getTaskLimiter = getTaskLimiter;
+exports.parallelizeGlobal = parallelizeGlobal;
+//# sourceMappingURL=parallelizeGlobal.cjs.map

package/dist/cjs/utils/parallelizeGlobal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelizeGlobal.cjs","names":["pLimit"],"sources":["../../../src/utils/parallelizeGlobal.ts"],"sourcesContent":["// === keep your Queue, Node, pLimit, validateConcurrency exactly as-is ===\n\nimport { pLimit } from './pLimit';\n\n// --- NEW: single, shared limiter for the whole process ---\nlet _globalLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Get (and optionally configure) the single, shared limiter. */\nexport const getGlobalLimiter = (concurrency?: number) => {\n  if (!_globalLimiter) {\n    _globalLimiter = pLimit(concurrency ?? 10);\n  } else if (typeof concurrency === 'number') {\n    (_globalLimiter as any).concurrency = concurrency;\n  }\n  return _globalLimiter!;\n};\n\n// --- NEW: task limiter for gating task starts ---\nlet _taskLimiter: ReturnType<typeof pLimit> | null = null;\n\n/** Limits how many *tasks* run concurrently (independent from AI calls). */\nexport const getTaskLimiter = (concurrency?: number) => {\n  if (!_taskLimiter) {\n    _taskLimiter = pLimit(concurrency ?? 5);\n  } else if (typeof concurrency === 'number') {\n    (_taskLimiter as any).concurrency = concurrency;\n  }\n  return _taskLimiter!;\n};\n\n// --- REPLACE your existing `parallelize` with this version ---\nexport const parallelizeGlobal = async <T, R>(\n  items: T[],\n  callback: (item: T, index: number) => Promise<R> = async (item) =>\n    item as unknown as Promise<R>,\n  options?: {\n    /** Share a single limiter across the app. If omitted, uses global limiter. */\n    limiter?: ReturnType<typeof pLimit>;\n    /** If provided and no limiter is passed, configure the global limiter. */\n    concurrency?: number;\n    /**\n     * Whether to wrap *each* callback run in the limiter.\n     * - For orchestration (outer loops): set `false` (don't burn limiter slots).\n     * - For atomic work (AI calls, writes): leave `true` (default).\n     */\n    wrapInLimiter?: boolean;\n  }\n): Promise<R[]> => {\n  const limiter = options?.limiter ?? getGlobalLimiter(options?.concurrency);\n  const wrap = options?.wrapInLimiter ?? true;\n\n  const run = wrap\n    ? <U>(fn: () => Promise<U>) => limiter(fn)\n    : <U>(fn: () => Promise<U>) => fn();\n\n  const promises = items.map((item, index) => run(() => callback(item, index)));\n  return Promise.all(promises);\n};\n"],"mappings":";;;;AAKA,IAAI,iBAAmD;;AAGvD,MAAa,oBAAoB,gBAAyB;AACxD,KAAI,CAAC,eACH,kBAAiBA,4BAAO,eAAe,GAAG;UACjC,OAAO,gBAAgB,SAChC,CAAC,eAAuB,cAAc;AAExC,QAAO;;AAIT,IAAI,eAAiD;;AAGrD,MAAa,kBAAkB,gBAAyB;AACtD,KAAI,CAAC,aACH,gBAAeA,4BAAO,eAAe,EAAE;UAC9B,OAAO,gBAAgB,SAChC,CAAC,aAAqB,cAAc;AAEtC,QAAO;;AAIT,MAAa,oBAAoB,OAC/B,OACA,WAAmD,OAAO,SACxD,MACF,YAYiB;CACjB,MAAM,UAAU,SAAS,WAAW,iBAAiB,SAAS,YAAY;CAG1E,MAAM,MAFO,SAAS,iBAAiB,QAG/B,OAAyB,QAAQ,GAAG,IACpC,OAAyB,IAAI;CAErC,MAAM,WAAW,MAAM,KAAK,MAAM,UAAU,UAAU,SAAS,MAAM,MAAM,CAAC,CAAC;AAC7E,QAAO,QAAQ,IAAI,SAAS"}

package/dist/cjs/utils/readDictionariesFromDisk.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+
+//#region src/utils/readDictionariesFromDisk.ts
+/**
+* Reads all JSON dictionary files from a directory, keyed by filename.
+* Uses readFileSync instead of require() to avoid require.cache memory leak.
+*/
+const readDictionariesFromDisk = (directory) => {
+	const dictionaries = {};
+	if ((0, node_fs.existsSync)(directory)) {
+		const files = (0, node_fs.readdirSync)(directory).filter((file) => file.endsWith(".json"));
+		for (const file of files) {
+			const key = (0, node_path.basename)(file, (0, node_path.extname)(file));
+			dictionaries[key] = JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(directory, file), "utf-8"));
+		}
+	}
+	return dictionaries;
+};
+
+//#endregion
+exports.readDictionariesFromDisk = readDictionariesFromDisk;
+//# sourceMappingURL=readDictionariesFromDisk.cjs.map

package/dist/cjs/utils/readDictionariesFromDisk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"readDictionariesFromDisk.cjs","names":[],"sources":["../../../src/utils/readDictionariesFromDisk.ts"],"sourcesContent":["import { existsSync, readdirSync, readFileSync } from 'node:fs';\nimport { basename, extname, join } from 'node:path';\n\n/**\n * Reads all JSON dictionary files from a directory, keyed by filename.\n * Uses readFileSync instead of require() to avoid require.cache memory leak.\n */\nexport const readDictionariesFromDisk = <T = Record<string, any>>(\n  directory: string\n): T => {\n  const dictionaries: Record<string, any> = {};\n\n  if (existsSync(directory)) {\n    const files = readdirSync(directory).filter((file) =>\n      file.endsWith('.json')\n    );\n\n    for (const file of files) {\n      const key = basename(file, extname(file));\n      dictionaries[key] = JSON.parse(\n        readFileSync(join(directory, file), 'utf-8')\n      );\n    }\n  }\n\n  return dictionaries as T;\n};\n"],"mappings":";;;;;;;;;;AAOA,MAAa,4BACX,cACM;CACN,MAAM,eAAoC,EAAE;AAE5C,6BAAe,UAAU,EAAE;EACzB,MAAM,iCAAoB,UAAU,CAAC,QAAQ,SAC3C,KAAK,SAAS,QAAQ,CACvB;AAED,OAAK,MAAM,QAAQ,OAAO;GACxB,MAAM,8BAAe,6BAAc,KAAK,CAAC;AACzC,gBAAa,OAAO,KAAK,oDACL,WAAW,KAAK,EAAE,QAAQ,CAC7C;;;AAIL,QAAO"}

package/dist/cjs/utils/reduceObjectFormat.cjs

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/reduceObjectFormat.ts
+/**
+* Reduce an object to only the shape provided by a format object.
+* Values are always taken from the source object; the format is used only for structure.
+*
+* Examples:
+* reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }
+* reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }
+*/
+const reduceObjectFormat = (source, format) => {
+	if (Array.isArray(format)) {
+		const sourceArray = Array.isArray(source) ? source : [];
+		return format.map((formatItem, index) => reduceObjectFormat(sourceArray[index], formatItem));
+	}
+	if (typeof format === "object" && format !== null) {
+		const result = {};
+		const sourceObject = typeof source === "object" && source !== null && !Array.isArray(source) ? source : {};
+		for (const key of Object.keys(format)) {
+			const nextSource = sourceObject[key];
+			const nextFormat = format[key];
+			result[key] = reduceObjectFormat(nextSource, nextFormat);
+		}
+		return result;
+	}
+	return source;
+};
+/**
+* Returns the subset of source whose keys are NOT present in the format object.
+* Inverse of reduceObjectFormat.
+*
+* Null values in source are always included as explicit fallback markers
+* (they signal "use default locale" at render time).
+*
+* Examples:
+* excludeObjectFormat({ a: 1, b: 2 }, { b: 0 }) => { a: 1 }
+* excludeObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { y: 2 } }
+* excludeObjectFormat({ a: null, b: 2 }, { b: 0 }) => { a: null }
+*/
+const excludeObjectFormat = (source, format) => {
+	if (source === null) return null;
+	if (format === void 0 || format === null) return source;
+	if (typeof source === "object" && !Array.isArray(source) && typeof format === "object" && !Array.isArray(format)) {
+		const result = {};
+		let hasContent = false;
+		for (const key of Object.keys(source)) {
+			const excluded = excludeObjectFormat(source[key], format[key]);
+			if (excluded !== void 0) {
+				result[key] = excluded;
+				hasContent = true;
+			}
+		}
+		return hasContent ? result : void 0;
+	}
+	if (Array.isArray(source)) {
+		const formatArr = Array.isArray(format) ? format : [];
+		const result = [];
+		for (let i = 0; i < source.length; i++) {
+			const excluded = excludeObjectFormat(source[i], formatArr[i]);
+			if (excluded !== void 0) result.push(excluded);
+		}
+		return result.length > 0 ? result : void 0;
+	}
+};
+
+//#endregion
+exports.excludeObjectFormat = excludeObjectFormat;
+exports.reduceObjectFormat = reduceObjectFormat;
+//# sourceMappingURL=reduceObjectFormat.cjs.map

package/dist/cjs/utils/reduceObjectFormat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceObjectFormat.cjs","names":[],"sources":["../../../src/utils/reduceObjectFormat.ts"],"sourcesContent":["export type Primitive = string | number | boolean | null | undefined;\n\nexport type Recursive =\n  | Primitive\n  | { [key: string]: Recursive }\n  | Array<Recursive>;\n\n/**\n * Reduce an object to only the shape provided by a format object.\n * Values are always taken from the source object; the format is used only for structure.\n *\n * Examples:\n * reduceObjectFormat({ a: 1, b: 2 }, { a: 0 }) => { a: 1 }\n * reduceObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { x: 1 } }\n */\nexport const reduceObjectFormat = (\n  source: Recursive,\n  format: Recursive\n): Recursive => {\n  // If the format is an array, reduce each element by its counterpart in source\n  if (Array.isArray(format)) {\n    const sourceArray = Array.isArray(source) ? source : [];\n    return format.map((formatItem, index) =>\n      reduceObjectFormat(sourceArray[index], formatItem)\n    );\n  }\n\n  // If the format is an object (and not null), pick matching keys and recurse\n  if (typeof format === 'object' && format !== null) {\n    const result: Record<string, Recursive> = {};\n    const sourceObject =\n      typeof source === 'object' && source !== null && !Array.isArray(source)\n        ? (source as Record<string, Recursive>)\n        : ({} as Record<string, Recursive>);\n\n    for (const key of Object.keys(format)) {\n      const nextSource = sourceObject[key];\n      const nextFormat = (format as Record<string, Recursive>)[key];\n      result[key] = reduceObjectFormat(nextSource, nextFormat);\n    }\n    return result;\n  }\n\n  // For primitives in the format, simply return the source value (can be undefined)\n  return source as Primitive;\n};\n\n/**\n * Returns the subset of source whose keys are NOT present in the format object.\n * Inverse of reduceObjectFormat.\n *\n * Null values in source are always included as explicit fallback markers\n * (they signal \"use default locale\" at render time).\n *\n * Examples:\n * excludeObjectFormat({ a: 1, b: 2 }, { b: 0 }) => { a: 1 }\n * excludeObjectFormat({ a: { x: 1, y: 2 } }, { a: { x: 0 } }) => { a: { y: 2 } }\n * excludeObjectFormat({ a: null, b: 2 }, { b: 0 }) => { a: null }\n */\nexport const excludeObjectFormat = (\n  source: Recursive,\n  format: Recursive\n): Recursive | undefined => {\n  // null in source = explicit fallback marker → always include\n  if (source === null) return null;\n\n  // No format means nothing is translated yet → include all source\n  if (format === undefined || format === null) return source;\n\n  // Both plain objects → recurse key-by-key\n  if (\n    typeof source === 'object' &&\n    !Array.isArray(source) &&\n    typeof format === 'object' &&\n    !Array.isArray(format)\n  ) {\n    const result: Record<string, Recursive> = {};\n    let hasContent = false;\n\n    for (const key of Object.keys(source as Record<string, Recursive>)) {\n      const excluded = excludeObjectFormat(\n        (source as Record<string, Recursive>)[key],\n        (format as Record<string, Recursive>)[key]\n      );\n      if (excluded !== undefined) {\n        result[key] = excluded;\n        hasContent = true;\n      }\n    }\n\n    return hasContent ? result : undefined;\n  }\n\n  // Arrays → recurse by index\n  if (Array.isArray(source)) {\n    const formatArr = Array.isArray(format) ? format : [];\n    const result: Recursive[] = [];\n\n    for (let i = 0; i < source.length; i++) {\n      const excluded = excludeObjectFormat(source[i], formatArr[i]);\n      if (excluded !== undefined) {\n        result.push(excluded);\n      }\n    }\n\n    return result.length > 0 ? result : undefined;\n  }\n\n  // Primitive in source and format has a value → already translated → exclude\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;AAeA,MAAa,sBACX,QACA,WACc;AAEd,KAAI,MAAM,QAAQ,OAAO,EAAE;EACzB,MAAM,cAAc,MAAM,QAAQ,OAAO,GAAG,SAAS,EAAE;AACvD,SAAO,OAAO,KAAK,YAAY,UAC7B,mBAAmB,YAAY,QAAQ,WAAW,CACnD;;AAIH,KAAI,OAAO,WAAW,YAAY,WAAW,MAAM;EACjD,MAAM,SAAoC,EAAE;EAC5C,MAAM,eACJ,OAAO,WAAW,YAAY,WAAW,QAAQ,CAAC,MAAM,QAAQ,OAAO,GAClE,SACA,EAAE;AAET,OAAK,MAAM,OAAO,OAAO,KAAK,OAAO,EAAE;GACrC,MAAM,aAAa,aAAa;GAChC,MAAM,aAAc,OAAqC;AACzD,UAAO,OAAO,mBAAmB,YAAY,WAAW;;AAE1D,SAAO;;AAIT,QAAO;;;;;;;;;;;;;;AAeT,MAAa,uBACX,QACA,WAC0B;AAE1B,KAAI,WAAW,KAAM,QAAO;AAG5B,KAAI,WAAW,UAAa,WAAW,KAAM,QAAO;AAGpD,KACE,OAAO,WAAW,YAClB,CAAC,MAAM,QAAQ,OAAO,IACtB,OAAO,WAAW,YAClB,CAAC,MAAM,QAAQ,OAAO,EACtB;EACA,MAAM,SAAoC,EAAE;EAC5C,IAAI,aAAa;AAEjB,OAAK,MAAM,OAAO,OAAO,KAAK,OAAoC,EAAE;GAClE,MAAM,WAAW,oBACd,OAAqC,MACrC,OAAqC,KACvC;AACD,OAAI,aAAa,QAAW;AAC1B,WAAO,OAAO;AACd,iBAAa;;;AAIjB,SAAO,aAAa,SAAS;;AAI/B,KAAI,MAAM,QAAQ,OAAO,EAAE;EACzB,MAAM,YAAY,MAAM,QAAQ,OAAO,GAAG,SAAS,EAAE;EACrD,MAAM,SAAsB,EAAE;AAE9B,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;GACtC,MAAM,WAAW,oBAAoB,OAAO,IAAI,UAAU,GAAG;AAC7D,OAAI,aAAa,OACf,QAAO,KAAK,SAAS;;AAIzB,SAAO,OAAO,SAAS,IAAI,SAAS"}

package/dist/cjs/utils/resolveObjectPromises.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/resolveObjectPromises.ts
+/**
+* A more "unified" approach where each type (function, array, object, primitive)
+* is handled inside the main recursive body.
+*/
+const resolveObjectPromises = async (entry) => {
+	if (entry && typeof entry.then === "function") return resolveObjectPromises(await entry);
+	if (typeof entry === "function") return resolveObjectPromises(entry());
+	if (Array.isArray(entry)) return Promise.all(entry.map(async (item) => resolveObjectPromises(item)));
+	if (entry && typeof entry === "object") {
+		const result = {};
+		for (const key of Object.keys(entry)) result[key] = await resolveObjectPromises(entry[key]);
+		return result;
+	}
+	return entry;
+};
+
+//#endregion
+exports.resolveObjectPromises = resolveObjectPromises;
+//# sourceMappingURL=resolveObjectPromises.cjs.map

package/dist/cjs/utils/resolveObjectPromises.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveObjectPromises.cjs","names":[],"sources":["../../../src/utils/resolveObjectPromises.ts"],"sourcesContent":["/**\n * A more \"unified\" approach where each type (function, array, object, primitive)\n * is handled inside the main recursive body.\n */\nexport const resolveObjectPromises = async <T = unknown>(\n  entry: any\n): Promise<T> => {\n  // Check if entry is a Promise (Thenable)\n  if (entry && typeof entry.then === 'function') {\n    const awaited = await entry;\n    return resolveObjectPromises(awaited);\n  }\n\n  // If entry is a function, invoke it and process the result\n  if (typeof entry === 'function') {\n    const result = entry();\n    return resolveObjectPromises(result);\n  }\n\n  if (Array.isArray(entry)) {\n    return Promise.all(\n      entry.map(async (item) => resolveObjectPromises(item))\n    ) as unknown as T;\n  }\n\n  // Handle plain objects (but not arrays)\n  if (entry && typeof entry === 'object') {\n    // Arrays are handled in the `Array.isArray` branch above, so we know `entry` is a plain object here.\n\n    const result: Record<string, any> = {};\n\n    // Iterate over keys **sequentially** to make sure the insertion order of the\n    // resulting object matches the original key order. Using `Promise.all` here\n    // could lead to out-of-order insertions when asynchronous resolutions\n    // finish at different times.\n    for (const key of Object.keys(entry)) {\n      result[key] = await resolveObjectPromises(entry[key]);\n    }\n\n    return result as T;\n  }\n\n  return entry as T;\n};\n"],"mappings":";;;;;;;AAIA,MAAa,wBAAwB,OACnC,UACe;AAEf,KAAI,SAAS,OAAO,MAAM,SAAS,WAEjC,QAAO,sBAAsB,MADP,MACe;AAIvC,KAAI,OAAO,UAAU,WAEnB,QAAO,sBADQ,OACoB,CAAC;AAGtC,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,QAAQ,IACb,MAAM,IAAI,OAAO,SAAS,sBAAsB,KAAK,CAAC,CACvD;AAIH,KAAI,SAAS,OAAO,UAAU,UAAU;EAGtC,MAAM,SAA8B,EAAE;AAMtC,OAAK,MAAM,OAAO,OAAO,KAAK,MAAM,CAClC,QAAO,OAAO,MAAM,sBAAsB,MAAM,KAAK;AAGvD,SAAO;;AAGT,QAAO"}

package/dist/cjs/utils/resolveRelativePath.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_path = require("node:path");
+
+//#region src/utils/resolveRelativePath.ts
+const resolveRelativePath = (path, sourcePath, baseDir) => {
+	if ((0, node_path.isAbsolute)(path)) {
+		const normalizedResult = (0, node_path.normalize)(path);
+		const normalizedBaseDir = (0, node_path.normalize)(baseDir);
+		if (path.startsWith("/") && !normalizedResult.startsWith(normalizedBaseDir)) {
+			const relativeToBase = (0, node_path.resolve)(baseDir, path.substring(1));
+			if (!path.startsWith("/usr/") && !path.startsWith("/etc/") && !path.startsWith("/var/") && !path.startsWith("/home/") && !path.startsWith("/Users/") && !path.startsWith("/tmp/") && !path.startsWith("/private/") && !path.startsWith("/opt/")) return relativeToBase;
+		}
+		return normalizedResult;
+	}
+	if (path.startsWith("./") || path.startsWith("../")) return (0, node_path.resolve)((0, node_path.dirname)(sourcePath), path);
+	return (0, node_path.resolve)(baseDir, path);
+};
+
+//#endregion
+exports.resolveRelativePath = resolveRelativePath;
+//# sourceMappingURL=resolveRelativePath.cjs.map

package/dist/cjs/utils/resolveRelativePath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveRelativePath.cjs","names":[],"sources":["../../../src/utils/resolveRelativePath.ts"],"sourcesContent":["import { dirname, isAbsolute, normalize, resolve } from 'node:path';\n\nexport const resolveRelativePath = (\n  path: string,\n  sourcePath: string,\n  baseDir: string\n) => {\n  // Handle absolute paths\n  if (isAbsolute(path)) {\n    const normalizedResult = normalize(path);\n    const normalizedBaseDir = normalize(baseDir);\n\n    // Check if it's relative to baseDir (starts with /)\n    // but not a system path (like /usr/local)\n    if (\n      path.startsWith('/') &&\n      !normalizedResult.startsWith(normalizedBaseDir)\n    ) {\n      // Try to resolve it relative to baseDir first\n      const relativeToBase = resolve(baseDir, path.substring(1));\n\n      // If the path doesn't exist in common system directories, treat as relative to baseDir\n      if (\n        !path.startsWith('/usr/') &&\n        !path.startsWith('/etc/') &&\n        !path.startsWith('/var/') &&\n        !path.startsWith('/home/') &&\n        !path.startsWith('/Users/') &&\n        !path.startsWith('/tmp/') &&\n        !path.startsWith('/private/') &&\n        !path.startsWith('/opt/')\n      ) {\n        return relativeToBase;\n      }\n    }\n\n    // It's a true system absolute path\n    return normalizedResult;\n  }\n\n  // Handle relative paths (starting with ./ or ../)\n  if (path.startsWith('./') || path.startsWith('../')) {\n    const fileDir = dirname(sourcePath);\n    return resolve(fileDir, path);\n  }\n\n  // Default case: treat as relative to baseDir\n  return resolve(baseDir, path);\n};\n"],"mappings":";;;;;AAEA,MAAa,uBACX,MACA,YACA,YACG;AAEH,+BAAe,KAAK,EAAE;EACpB,MAAM,4CAA6B,KAAK;EACxC,MAAM,6CAA8B,QAAQ;AAI5C,MACE,KAAK,WAAW,IAAI,IACpB,CAAC,iBAAiB,WAAW,kBAAkB,EAC/C;GAEA,MAAM,wCAAyB,SAAS,KAAK,UAAU,EAAE,CAAC;AAG1D,OACE,CAAC,KAAK,WAAW,QAAQ,IACzB,CAAC,KAAK,WAAW,QAAQ,IACzB,CAAC,KAAK,WAAW,QAAQ,IACzB,CAAC,KAAK,WAAW,SAAS,IAC1B,CAAC,KAAK,WAAW,UAAU,IAC3B,CAAC,KAAK,WAAW,QAAQ,IACzB,CAAC,KAAK,WAAW,YAAY,IAC7B,CAAC,KAAK,WAAW,QAAQ,CAEzB,QAAO;;AAKX,SAAO;;AAIT,KAAI,KAAK,WAAW,KAAK,IAAI,KAAK,WAAW,MAAM,CAEjD,sDADwB,WACF,EAAE,KAAK;AAI/B,+BAAe,SAAS,KAAK"}

package/dist/cjs/utils/runOnce.cjs

@@ -0,0 +1,96 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _intlayer_core_package_json = require("@intlayer/core/package.json");
+_intlayer_core_package_json = require_runtime.__toESM(_intlayer_core_package_json);
+
+//#region src/utils/runOnce.ts
+const DEFAULT_RUN_ONCE_OPTIONS = { cacheTimeoutMs: 60 * 1e3 };
+const writeSentinelFile = async (sentinelFilePath, currentTimestamp) => {
+	const data = {
+		version: _intlayer_core_package_json.default.version,
+		timestamp: currentTimestamp
+	};
+	try {
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(sentinelFilePath), { recursive: true });
+		await (0, node_fs_promises.writeFile)(sentinelFilePath, JSON.stringify(data), { flag: "wx" });
+	} catch (err) {
+		if (err.code === "EEXIST") return;
+		if (err.code === "ENOENT") try {
+			await (0, node_fs_promises.mkdir)((0, node_path.dirname)(sentinelFilePath), { recursive: true });
+			await (0, node_fs_promises.writeFile)(sentinelFilePath, JSON.stringify(data), { flag: "wx" });
+			return;
+		} catch (retryErr) {
+			if (retryErr.code === "EEXIST") return;
+		}
+		throw err;
+	}
+};
+/**
+* Ensures a callback function runs only once within a specified time window across multiple processes.
+* Uses a sentinel file to coordinate execution and prevent duplicate work.
+*
+* @param sentinelFilePath - Path to the sentinel file used for coordination
+* @param callback - The function to execute (should be async)
+* @param options - The options for the runOnce function
+*
+* @example
+* ```typescript
+* await runPrepareIntlayerOnce(
+*   '/tmp/intlayer-sentinel',
+*   async () => {
+*     // Your initialization logic here
+*     await prepareIntlayer();
+*   },
+*   30 * 1000 // 30 seconds cache
+* );
+* ```
+*
+* @throws {Error} When there are unexpected filesystem errors
+*/
+const runOnce = async (sentinelFilePath, callback, options) => {
+	const { onIsCached, cacheTimeoutMs, forceRun } = {
+		...DEFAULT_RUN_ONCE_OPTIONS,
+		...options ?? {}
+	};
+	const currentTimestamp = Date.now();
+	try {
+		const sentinelAge = currentTimestamp - (await (0, node_fs_promises.stat)(sentinelFilePath)).mtime.getTime();
+		let shouldRebuild = Boolean(forceRun) || sentinelAge > cacheTimeoutMs;
+		if (!shouldRebuild) try {
+			const raw = await (0, node_fs_promises.readFile)(sentinelFilePath, "utf8");
+			let cachedVersion;
+			try {
+				cachedVersion = JSON.parse(raw).version;
+			} catch {
+				cachedVersion = void 0;
+			}
+			if (!cachedVersion || cachedVersion !== _intlayer_core_package_json.default.version) shouldRebuild = true;
+		} catch {
+			shouldRebuild = true;
+		}
+		if (shouldRebuild) try {
+			await (0, node_fs_promises.unlink)(sentinelFilePath);
+		} catch {}
+		else {
+			await onIsCached?.();
+			return;
+		}
+	} catch (err) {
+		if (err.code === "ENOENT") {} else throw err;
+	}
+	await writeSentinelFile(sentinelFilePath, currentTimestamp);
+	try {
+		await callback();
+		await writeSentinelFile(sentinelFilePath, currentTimestamp);
+	} catch {
+		try {
+			await (0, node_fs_promises.unlink)(sentinelFilePath);
+		} catch {}
+	}
+};
+
+//#endregion
+exports.runOnce = runOnce;
+//# sourceMappingURL=runOnce.cjs.map

package/dist/cjs/utils/runOnce.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runOnce.cjs","names":["packageJson"],"sources":["../../../src/utils/runOnce.ts"],"sourcesContent":["import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport packageJson from '@intlayer/core/package.json' with { type: 'json' };\n\ntype RunOnceOptions = {\n  /**\n   * The function to execute when the sentinel is not found or is older than the cache timeout.\n   */\n  onIsCached?: () => void | Promise<void>;\n  /**\n   * The time window in milliseconds during which the sentinel is considered valid.\n   *\n   * @default 60000 = 1 minute\n   */\n  cacheTimeoutMs?: number;\n  /**\n   * If true, the callback will always run. If undefined, the callback will run only if the sentinel is older than the cache timeout.\n   *\n   * @default false\n   */\n  forceRun?: boolean;\n};\n\nconst DEFAULT_RUN_ONCE_OPTIONS = {\n  cacheTimeoutMs: 60 * 1000, // 1 minute in milliseconds,\n} satisfies RunOnceOptions;\n\ntype SentinelData = {\n  version: string;\n  timestamp: number;\n};\n\nconst writeSentinelFile = async (\n  sentinelFilePath: string,\n  currentTimestamp: number\n) => {\n  // O_EXCL ensures only the *first* process can create the file\n  const data: SentinelData = {\n    version: packageJson.version,\n    timestamp: currentTimestamp,\n  };\n\n  try {\n    // Ensure the directory exists before writing the file\n    await mkdir(dirname(sentinelFilePath), { recursive: true });\n\n    await writeFile(sentinelFilePath, JSON.stringify(data), { flag: 'wx' });\n  } catch (err: any) {\n    if (err.code === 'EEXIST') {\n      // Another process already created it → we're done\n      return;\n    }\n    // Optimization: If ENOENT occurs on write despite mkdir (race condition with external deletion), retry once.\n    if (err.code === 'ENOENT') {\n      try {\n        await mkdir(dirname(sentinelFilePath), { recursive: true });\n        await writeFile(sentinelFilePath, JSON.stringify(data), { flag: 'wx' });\n        return;\n      } catch (retryErr: any) {\n        if (retryErr.code === 'EEXIST') return;\n      }\n    }\n    throw err; // unexpected FS error\n  }\n};\n\n/**\n * Ensures a callback function runs only once within a specified time window across multiple processes.\n * Uses a sentinel file to coordinate execution and prevent duplicate work.\n *\n * @param sentinelFilePath - Path to the sentinel file used for coordination\n * @param callback - The function to execute (should be async)\n * @param options - The options for the runOnce function\n *\n * @example\n * ```typescript\n * await runPrepareIntlayerOnce(\n *   '/tmp/intlayer-sentinel',\n *   async () => {\n *     // Your initialization logic here\n *     await prepareIntlayer();\n *   },\n *   30 * 1000 // 30 seconds cache\n * );\n * ```\n *\n * @throws {Error} When there are unexpected filesystem errors\n */\nexport const runOnce = async (\n  sentinelFilePath: string,\n  callback: () => void | Promise<void>,\n  options?: RunOnceOptions\n) => {\n  const { onIsCached, cacheTimeoutMs, forceRun } = {\n    ...DEFAULT_RUN_ONCE_OPTIONS,\n    ...(options ?? {}),\n  };\n  const currentTimestamp = Date.now();\n\n  try {\n    // Check if sentinel file exists and get its stats\n    const sentinelStats = await stat(sentinelFilePath);\n    const sentinelAge = currentTimestamp - sentinelStats.mtime.getTime();\n\n    // Determine if we should rebuild based on cache age, force flag, or version mismatch\n    let shouldRebuild = Boolean(forceRun) || sentinelAge > cacheTimeoutMs!;\n\n    if (!shouldRebuild) {\n      try {\n        const raw = await readFile(sentinelFilePath, 'utf8');\n        let cachedVersion: string | undefined;\n        try {\n          const parsed = JSON.parse(raw) as Partial<SentinelData>;\n          cachedVersion = parsed.version;\n        } catch {\n          // Legacy format (timestamp only). Force a rebuild once to write versioned sentinel.\n          cachedVersion = undefined;\n        }\n\n        if (!cachedVersion || cachedVersion !== packageJson.version) {\n          shouldRebuild = true;\n        }\n      } catch {\n        // If we cannot read the file, err on the safe side and rebuild\n        shouldRebuild = true;\n      }\n    }\n\n    if (shouldRebuild) {\n      try {\n        await unlink(sentinelFilePath);\n      } catch {}\n      // Fall through to create new sentinel and rebuild\n    } else {\n      await onIsCached?.();\n      // Sentinel is recent and versions match, no need to rebuild\n      return;\n    }\n  } catch (err: any) {\n    if (err.code === 'ENOENT') {\n      // File doesn't exist, continue to create it\n    } else {\n      throw err; // unexpected FS error\n    }\n  }\n\n  // Write sentinel file before to block parallel processes\n  // Added await here\n  await writeSentinelFile(sentinelFilePath, currentTimestamp);\n\n  try {\n    await callback();\n\n    // Write sentinel file after to ensure the first one has not been removed with cleanOutputDir\n    // Added await here\n    await writeSentinelFile(sentinelFilePath, currentTimestamp);\n  } catch {\n    try {\n      await unlink(sentinelFilePath); // Remove sentinel file if an error occurs\n    } catch {}\n  }\n};\n"],"mappings":";;;;;;;;AAuBA,MAAM,2BAA2B,EAC/B,gBAAgB,KAAK,KACtB;AAOD,MAAM,oBAAoB,OACxB,kBACA,qBACG;CAEH,MAAM,OAAqB;EACzB,SAASA,oCAAY;EACrB,WAAW;EACZ;AAED,KAAI;AAEF,2DAAoB,iBAAiB,EAAE,EAAE,WAAW,MAAM,CAAC;AAE3D,wCAAgB,kBAAkB,KAAK,UAAU,KAAK,EAAE,EAAE,MAAM,MAAM,CAAC;UAChE,KAAU;AACjB,MAAI,IAAI,SAAS,SAEf;AAGF,MAAI,IAAI,SAAS,SACf,KAAI;AACF,4DAAoB,iBAAiB,EAAE,EAAE,WAAW,MAAM,CAAC;AAC3D,yCAAgB,kBAAkB,KAAK,UAAU,KAAK,EAAE,EAAE,MAAM,MAAM,CAAC;AACvE;WACO,UAAe;AACtB,OAAI,SAAS,SAAS,SAAU;;AAGpC,QAAM;;;;;;;;;;;;;;;;;;;;;;;;;AA0BV,MAAa,UAAU,OACrB,kBACA,UACA,YACG;CACH,MAAM,EAAE,YAAY,gBAAgB,aAAa;EAC/C,GAAG;EACH,GAAI,WAAW,EAAE;EAClB;CACD,MAAM,mBAAmB,KAAK,KAAK;AAEnC,KAAI;EAGF,MAAM,cAAc,oBAAmB,iCADN,iBAAiB,EACG,MAAM,SAAS;EAGpE,IAAI,gBAAgB,QAAQ,SAAS,IAAI,cAAc;AAEvD,MAAI,CAAC,cACH,KAAI;GACF,MAAM,MAAM,qCAAe,kBAAkB,OAAO;GACpD,IAAI;AACJ,OAAI;AAEF,oBADe,KAAK,MAAM,IACJ,CAAC;WACjB;AAEN,oBAAgB;;AAGlB,OAAI,CAAC,iBAAiB,kBAAkBA,oCAAY,QAClD,iBAAgB;UAEZ;AAEN,mBAAgB;;AAIpB,MAAI,cACF,KAAI;AACF,sCAAa,iBAAiB;UACxB;OAEH;AACL,SAAM,cAAc;AAEpB;;UAEK,KAAU;AACjB,MAAI,IAAI,SAAS,UAAU,OAGzB,OAAM;;AAMV,OAAM,kBAAkB,kBAAkB,iBAAiB;AAE3D,KAAI;AACF,QAAM,UAAU;AAIhB,QAAM,kBAAkB,kBAAkB,iBAAiB;SACrD;AACN,MAAI;AACF,sCAAa,iBAAiB;UACxB"}