@intlayer/engine 9.0.0-canary.12

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

@@ -0,0 +1 @@
+{"version":3,"file":"wmic.mjs","names":["os"],"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,QAAQ;EALE;EAAW;EAAO;EAKhB,EAAE;EAHhB,aAAa;EACb,0BAA0B;EAEH,GAAG,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,MAAMA,KAAG,IAAI;GAElC,MAAM,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/esm/utils/sortAlphabetically.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/sortAlphabetically.ts
+const sortAlphabetically = (a, b) => a.localeCompare(b);
+
+//#endregion
+export { sortAlphabetically };
+//# sourceMappingURL=sortAlphabetically.mjs.map

package/dist/esm/utils/sortAlphabetically.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortAlphabetically.mjs","names":[],"sources":["../../../src/utils/sortAlphabetically.ts"],"sourcesContent":["export const sortAlphabetically = (a: string, b: string) => a.localeCompare(b);\n"],"mappings":";AAAA,MAAa,sBAAsB,GAAW,MAAc,EAAE,cAAc,EAAE"}

package/dist/esm/utils/splitTextByLine.mjs

@@ -0,0 +1,10 @@
+//#region src/utils/splitTextByLine.ts
+const splitTextByLines = (text) => {
+	const splittedText = text.match(/[^\n]*\n|[^\n]*$/g) ?? [];
+	if (splittedText.length > 0 && splittedText.at(-1) === "") splittedText.pop();
+	return splittedText;
+};
+
+//#endregion
+export { splitTextByLines };
+//# sourceMappingURL=splitTextByLine.mjs.map

package/dist/esm/utils/splitTextByLine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitTextByLine.mjs","names":[],"sources":["../../../src/utils/splitTextByLine.ts"],"sourcesContent":["export const splitTextByLines = (text: string): string[] => {\n  const splittedText = text.match(/[^\\n]*\\n|[^\\n]*$/g) ?? [];\n\n  if (splittedText.length > 0 && splittedText.at(-1) === '') {\n    splittedText.pop();\n  }\n\n  return splittedText;\n};\n"],"mappings":";AAAA,MAAa,oBAAoB,SAA2B;CAC1D,MAAM,eAAe,KAAK,MAAM,oBAAoB,IAAI,EAAE;AAE1D,KAAI,aAAa,SAAS,KAAK,aAAa,GAAG,GAAG,KAAK,GACrD,cAAa,KAAK;AAGpB,QAAO"}

package/dist/esm/utils/verifyIdenticObjectFormat.mjs

@@ -0,0 +1,64 @@
+//#region src/utils/verifyIdenticObjectFormat.ts
+/**
+* Verifies that two objects have identical structure (same keys, array lengths, and types)
+* but not necessarily the same values.
+* Useful for validating translations maintain the same format as the original.
+*
+* @param object - The object to verify
+* @param expectedFormat - The expected format to compare against
+* @param path - Current path in the object tree (for error messages)
+* @returns true if structures match, throws error with details if they don't
+*/
+const verifyIdenticObjectFormat = (object, expectedFormat, path = "root") => {
+	if (expectedFormat === null || expectedFormat === void 0) {
+		if (expectedFormat !== object) return {
+			isIdentic: false,
+			error: `Type mismatch at ${path}: expected ${expectedFormat === null ? "null" : "undefined"}, got ${object === null ? "null" : typeof object}`
+		};
+		return { isIdentic: true };
+	}
+	if ((object === null || object === void 0) && typeof expectedFormat !== "object" && !Array.isArray(expectedFormat)) return { isIdentic: true };
+	const expectedType = Array.isArray(expectedFormat) ? "array" : typeof expectedFormat;
+	const objectType = Array.isArray(object) ? "array" : typeof object;
+	if (expectedType !== objectType) return {
+		isIdentic: false,
+		error: `Type mismatch at ${path}: expected ${expectedType}, got ${objectType}`
+	};
+	if (Array.isArray(expectedFormat) && Array.isArray(object)) {
+		if (expectedFormat.length !== object.length) return {
+			isIdentic: false,
+			error: `Array length mismatch at ${path}: expected ${expectedFormat.length} elements, got ${object.length}`
+		};
+		for (let i = 0; i < expectedFormat.length; i++) {
+			const result = verifyIdenticObjectFormat(object[i], expectedFormat[i], `${path}[${i}]`);
+			if (!result.isIdentic) return result;
+		}
+		return { isIdentic: true };
+	}
+	if (typeof expectedFormat === "object" && typeof object === "object" && expectedFormat !== null && object !== null) {
+		const expectedKeys = Object.keys(expectedFormat);
+		const objectKeys = Object.keys(object);
+		if (expectedKeys.length !== objectKeys.length) return {
+			isIdentic: false,
+			error: `Object keys count mismatch at ${path}: expected ${expectedKeys.length} keys, got ${objectKeys.length}`
+		};
+		for (const key of expectedKeys) if (!objectKeys.includes(key)) return {
+			isIdentic: false,
+			error: `Missing key at ${path}: expected key "${key}" not found`
+		};
+		for (const key of objectKeys) if (!expectedKeys.includes(key)) return {
+			isIdentic: false,
+			error: `Unexpected key at ${path}: key "${key}" was found but not expected`
+		};
+		for (const key of expectedKeys) {
+			const result = verifyIdenticObjectFormat(object[key], expectedFormat[key], `${path}.${key}`);
+			if (!result.isIdentic) return result;
+		}
+		return { isIdentic: true };
+	}
+	return { isIdentic: true };
+};
+
+//#endregion
+export { verifyIdenticObjectFormat };
+//# sourceMappingURL=verifyIdenticObjectFormat.mjs.map

package/dist/esm/utils/verifyIdenticObjectFormat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyIdenticObjectFormat.mjs","names":[],"sources":["../../../src/utils/verifyIdenticObjectFormat.ts"],"sourcesContent":["type FlatType = string | number | boolean | object | null | undefined;\n\ntype RecursiveType =\n  | FlatType\n  | { [key: string]: RecursiveType }\n  | Array<RecursiveType>;\n\ntype VerifyIdenticObjectFormatResult = {\n  isIdentic: boolean;\n  error?: string;\n};\n\n/**\n * Verifies that two objects have identical structure (same keys, array lengths, and types)\n * but not necessarily the same values.\n * Useful for validating translations maintain the same format as the original.\n *\n * @param object - The object to verify\n * @param expectedFormat - The expected format to compare against\n * @param path - Current path in the object tree (for error messages)\n * @returns true if structures match, throws error with details if they don't\n */\nexport const verifyIdenticObjectFormat = (\n  object: RecursiveType,\n  expectedFormat: RecursiveType,\n  path: string = 'root'\n): VerifyIdenticObjectFormatResult => {\n  // Check if both are null or undefined\n  if (expectedFormat === null || expectedFormat === undefined) {\n    if (expectedFormat !== object) {\n      return {\n        isIdentic: false,\n        error: `Type mismatch at ${path}: expected ${expectedFormat === null ? 'null' : 'undefined'}, got ${object === null ? 'null' : typeof object}`,\n      };\n    }\n    return {\n      isIdentic: true,\n    };\n  }\n\n  // Allow null/undefined returns from AI for any expected primitive type\n  // (AI may return null for content it cannot translate)\n  if (\n    (object === null || object === undefined) &&\n    typeof expectedFormat !== 'object' &&\n    !Array.isArray(expectedFormat)\n  ) {\n    return { isIdentic: true };\n  }\n\n  // Get the type of both values\n  const expectedType = Array.isArray(expectedFormat)\n    ? 'array'\n    : typeof expectedFormat;\n  const objectType = Array.isArray(object) ? 'array' : typeof object;\n\n  // Check if types match\n  if (expectedType !== objectType) {\n    return {\n      isIdentic: false,\n      error: `Type mismatch at ${path}: expected ${expectedType}, got ${objectType}`,\n    };\n  }\n\n  // Handle arrays\n  if (Array.isArray(expectedFormat) && Array.isArray(object)) {\n    if (expectedFormat.length !== object.length) {\n      return {\n        isIdentic: false,\n        error: `Array length mismatch at ${path}: expected ${expectedFormat.length} elements, got ${object.length}`,\n      };\n    }\n\n    // Recursively check each element\n    for (let i = 0; i < expectedFormat.length; i++) {\n      const result = verifyIdenticObjectFormat(\n        object[i],\n        expectedFormat[i],\n        `${path}[${i}]`\n      );\n      if (!result.isIdentic) {\n        return result;\n      }\n    }\n\n    return {\n      isIdentic: true,\n    };\n  }\n\n  // Handle objects (excluding null and arrays)\n  if (\n    typeof expectedFormat === 'object' &&\n    typeof object === 'object' &&\n    expectedFormat !== null &&\n    object !== null\n  ) {\n    const expectedKeys = Object.keys(expectedFormat);\n    const objectKeys = Object.keys(object);\n\n    // Check if number of keys match\n    if (expectedKeys.length !== objectKeys.length) {\n      return {\n        isIdentic: false,\n        error: `Object keys count mismatch at ${path}: expected ${expectedKeys.length} keys, got ${objectKeys.length}`,\n      };\n    }\n\n    // Check if each expected key is present in the object\n    for (const key of expectedKeys) {\n      if (!objectKeys.includes(key)) {\n        return {\n          isIdentic: false,\n          error: `Missing key at ${path}: expected key \"${key}\" not found`,\n        };\n      }\n    }\n\n    // Check if there are any unexpected keys in the object\n    for (const key of objectKeys) {\n      if (!expectedKeys.includes(key)) {\n        return {\n          isIdentic: false,\n          error: `Unexpected key at ${path}: key \"${key}\" was found but not expected`,\n        };\n      }\n    }\n\n    // Recursively check each property\n    for (const key of expectedKeys) {\n      const result = verifyIdenticObjectFormat(\n        (object as Record<string, RecursiveType>)[key],\n        (expectedFormat as Record<string, RecursiveType>)[key],\n        `${path}.${key}`\n      );\n      if (!result.isIdentic) {\n        return result;\n      }\n    }\n\n    return {\n      isIdentic: true,\n    };\n  }\n\n  // For primitive types (string, number, boolean), just verify they're the same type\n  // We don't check the actual values as per requirements\n  return {\n    isIdentic: true,\n  };\n};\n"],"mappings":";;;;;;;;;;;AAsBA,MAAa,6BACX,QACA,gBACA,OAAe,WACqB;AAEpC,KAAI,mBAAmB,QAAQ,mBAAmB,QAAW;AAC3D,MAAI,mBAAmB,OACrB,QAAO;GACL,WAAW;GACX,OAAO,oBAAoB,KAAK,aAAa,mBAAmB,OAAO,SAAS,YAAY,QAAQ,WAAW,OAAO,SAAS,OAAO;GACvI;AAEH,SAAO,EACL,WAAW,MACZ;;AAKH,MACG,WAAW,QAAQ,WAAW,WAC/B,OAAO,mBAAmB,YAC1B,CAAC,MAAM,QAAQ,eAAe,CAE9B,QAAO,EAAE,WAAW,MAAM;CAI5B,MAAM,eAAe,MAAM,QAAQ,eAAe,GAC9C,UACA,OAAO;CACX,MAAM,aAAa,MAAM,QAAQ,OAAO,GAAG,UAAU,OAAO;AAG5D,KAAI,iBAAiB,WACnB,QAAO;EACL,WAAW;EACX,OAAO,oBAAoB,KAAK,aAAa,aAAa,QAAQ;EACnE;AAIH,KAAI,MAAM,QAAQ,eAAe,IAAI,MAAM,QAAQ,OAAO,EAAE;AAC1D,MAAI,eAAe,WAAW,OAAO,OACnC,QAAO;GACL,WAAW;GACX,OAAO,4BAA4B,KAAK,aAAa,eAAe,OAAO,iBAAiB,OAAO;GACpG;AAIH,OAAK,IAAI,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;GAC9C,MAAM,SAAS,0BACb,OAAO,IACP,eAAe,IACf,GAAG,KAAK,GAAG,EAAE,GACd;AACD,OAAI,CAAC,OAAO,UACV,QAAO;;AAIX,SAAO,EACL,WAAW,MACZ;;AAIH,KACE,OAAO,mBAAmB,YAC1B,OAAO,WAAW,YAClB,mBAAmB,QACnB,WAAW,MACX;EACA,MAAM,eAAe,OAAO,KAAK,eAAe;EAChD,MAAM,aAAa,OAAO,KAAK,OAAO;AAGtC,MAAI,aAAa,WAAW,WAAW,OACrC,QAAO;GACL,WAAW;GACX,OAAO,iCAAiC,KAAK,aAAa,aAAa,OAAO,aAAa,WAAW;GACvG;AAIH,OAAK,MAAM,OAAO,aAChB,KAAI,CAAC,WAAW,SAAS,IAAI,CAC3B,QAAO;GACL,WAAW;GACX,OAAO,kBAAkB,KAAK,kBAAkB,IAAI;GACrD;AAKL,OAAK,MAAM,OAAO,WAChB,KAAI,CAAC,aAAa,SAAS,IAAI,CAC7B,QAAO;GACL,WAAW;GACX,OAAO,qBAAqB,KAAK,SAAS,IAAI;GAC/C;AAKL,OAAK,MAAM,OAAO,cAAc;GAC9B,MAAM,SAAS,0BACZ,OAAyC,MACzC,eAAiD,MAClD,GAAG,KAAK,GAAG,MACZ;AACD,OAAI,CAAC,OAAO,UACV,QAAO;;AAIX,SAAO,EACL,WAAW,MACZ;;AAKH,QAAO,EACL,WAAW,MACZ"}

package/dist/esm/watcher.mjs

@@ -0,0 +1,226 @@
+import { formatPath } from "./utils/formatter.mjs";
+import { handleContentDeclarationFileChange } from "./handleContentDeclarationFileChange.mjs";
+import { handleContentDeclarationFileMoved } from "./handleContentDeclarationFileMoved.mjs";
+import { handleAdditionalContentDeclarationFile } from "./handleAdditionalContentDeclarationFile.mjs";
+import { handleUnlinkedContentDeclarationFile } from "./handleUnlinkedContentDeclarationFile.mjs";
+import { prepareIntlayer } from "./prepareIntlayer.mjs";
+import { writeContentDeclaration } from "./writeContentDeclaration/writeContentDeclaration.mjs";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+import { colorize, getAppLogger } from "@intlayer/config/logger";
+import { getConfiguration, getConfigurationAndFilePath } from "@intlayer/config/node";
+import { existsSync, watch as watch$1 } from "node:fs";
+import { clearAllCache, clearDiskCacheMemory, clearModuleCache, normalizePath } from "@intlayer/config/utils";
+import * as ANSIColor from "@intlayer/config/colors";
+import { pathToFileURL } from "node:url";
+
+//#region src/watcher.ts
+const pendingUnlinks = /* @__PURE__ */ new Map();
+const taskQueue = [];
+let isProcessing = false;
+const processQueue = async () => {
+	if (isProcessing) return;
+	isProcessing = true;
+	while (taskQueue.length > 0) {
+		const task = taskQueue.shift();
+		try {
+			await task();
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	isProcessing = false;
+};
+const processEvent = (task) => {
+	taskQueue.push(task);
+	processQueue();
+};
+const STABILITY_THRESHOLD = 1e3;
+const createStabilityDebounce = () => {
+	const pending = /* @__PURE__ */ new Map();
+	return (path, handler) => {
+		const existing = pending.get(path);
+		if (existing) clearTimeout(existing);
+		pending.set(path, setTimeout(() => {
+			pending.delete(path);
+			handler();
+		}, STABILITY_THRESHOLD));
+	};
+};
+const watch = async (options) => {
+	const { subscribe } = await import("@parcel/watcher");
+	const configResult = getConfigurationAndFilePath(options?.configOptions);
+	const configurationFilePath = configResult.configurationFilePath;
+	let configuration = options?.configuration ?? configResult.configuration;
+	const appLogger = getAppLogger(configuration);
+	const { watch: isWatchMode, fileExtensions, contentDir, excludedPath } = configuration.content;
+	if (!configuration.content.watch) return;
+	appLogger("Watching Intlayer content declarations");
+	if (configuration.build.optimize === true) appLogger([
+		`Build optimization is forced to ${colorize("true", ANSIColor.GREY)}, but watching is enabled too.`,
+		"It may lead to dev mode performance degradation as well as import errors.",
+		"Its recommended to keep the",
+		colorize("`build.optimized`", ANSIColor.BLUE),
+		"option",
+		colorize("undefined", ANSIColor.GREY),
+		"to get the best dev mode experience"
+	], { level: "warn" });
+	const excludedSegments = excludedPath.map((segment) => segment.replace(/^\*\*\//, "").replace(/\/\*\*$/, ""));
+	const normalizedConfigPath = configurationFilePath ? normalizePath(configurationFilePath) : null;
+	const { mainDir, baseDir } = configuration.system;
+	const normalizedMainDir = normalizePath(mainDir);
+	const normalizedIntlayerDir = normalizePath(dirname(mainDir));
+	const subscriptions = [];
+	const scheduleStable = createStabilityDebounce();
+	if (existsSync(mainDir)) {
+		const mainDirSub = await subscribe(normalizedMainDir, (err, events) => {
+			if (err || isProcessing) return;
+			for (const event of events) {
+				const rel = normalizePath(event.path).slice(normalizedMainDir.length + 1);
+				if (!rel || rel.includes("/")) continue;
+				if (rel.endsWith(".tmp")) continue;
+				if (event.type === "update") processEvent(async () => {
+					clearModuleCache(event.path);
+					try {
+						await import(`${pathToFileURL(event.path).href}?update=${Date.now()}`);
+					} catch {
+						appLogger(`Entry point ${basename(event.path)} failed to load, running clean rebuild...`, { level: "warn" });
+						await prepareIntlayer(configuration, {
+							clean: true,
+							forceRun: true
+						});
+					}
+				});
+				else if (event.type === "delete") processEvent(async () => {
+					appLogger([
+						"Entry point",
+						formatPath(basename(event.path)),
+						"was removed, running clean rebuild..."
+					], { level: "warn" });
+					await prepareIntlayer(configuration, {
+						clean: true,
+						forceRun: true
+					});
+				});
+			}
+		});
+		subscriptions.push(mainDirSub);
+	}
+	const intlayerDirName = basename(normalizedIntlayerDir);
+	const fsDirWatcher = watch$1(baseDir, { persistent: isWatchMode }, (eventType, filename) => {
+		if (isProcessing || !filename) return;
+		if (filename !== intlayerDirName) return;
+		if (normalizePath(resolve(baseDir, filename)) !== normalizedIntlayerDir) return;
+		if (eventType === "rename" && !existsSync(normalizedIntlayerDir)) {
+			appLogger([formatPath(".intlayer"), "directory removed, running clean rebuild..."]);
+			processEvent(() => prepareIntlayer(configuration, {
+				clean: true,
+				forceRun: true
+			}));
+		}
+	});
+	subscriptions.push({ unsubscribe: async () => {
+		fsDirWatcher.close();
+	} });
+	const ignorePatterns = excludedSegments.map((s) => `**/${s}/**`);
+	const contentDirs = contentDir.map((dir) => normalizePath(dir)).filter(existsSync);
+	const dirsToWatch = new Set(contentDirs);
+	if (normalizedConfigPath) dirsToWatch.add(normalizePath(dirname(normalizedConfigPath)));
+	const contentHandler = (err, events) => {
+		if (err) {
+			appLogger(`Watcher error: ${err}`, { level: "error" });
+			appLogger("Restarting watcher");
+			prepareIntlayer(configuration);
+			return;
+		}
+		for (const event of events) {
+			const filePath = event.path;
+			const path = normalizePath(filePath);
+			const isConfigFile = normalizedConfigPath && path === normalizedConfigPath;
+			if (!isConfigFile) {
+				if (!contentDirs.some((d) => path.startsWith(`${d}/`) || path === d)) continue;
+				if (excludedSegments.some((segment) => path.includes(`/${segment}`))) continue;
+				if (!fileExtensions.some((extension) => path.endsWith(extension))) continue;
+			}
+			if (event.type === "create") {
+				const fileName = basename(filePath);
+				let isMove = false;
+				let matchedOldPath;
+				for (const [oldPath] of pendingUnlinks) if (basename(oldPath) === fileName) {
+					matchedOldPath = oldPath;
+					break;
+				}
+				if (!matchedOldPath && pendingUnlinks.size === 1) matchedOldPath = pendingUnlinks.keys().next().value;
+				if (matchedOldPath) {
+					const pending = pendingUnlinks.get(matchedOldPath);
+					if (pending) {
+						clearTimeout(pending.timer);
+						pendingUnlinks.delete(matchedOldPath);
+					}
+					isMove = true;
+					appLogger(`File moved from ${matchedOldPath} to ${filePath}`);
+				}
+				if (isMove && matchedOldPath) processEvent(async () => {
+					await handleContentDeclarationFileMoved(matchedOldPath, filePath, configuration);
+				});
+				else scheduleStable(path, () => {
+					processEvent(async () => {
+						if (await readFile(filePath, "utf-8") === "") {
+							const extensionPattern = fileExtensions.map((ext) => ext.replace(/\./g, "\\.")).join("|");
+							await writeContentDeclaration({
+								key: fileName.replace(new RegExp(`(${extensionPattern})$`), ""),
+								content: {},
+								filePath
+							}, configuration);
+						}
+						await handleAdditionalContentDeclarationFile(filePath, configuration);
+					});
+				});
+			} else if (event.type === "update") scheduleStable(path, () => {
+				processEvent(async () => {
+					if (isConfigFile) {
+						appLogger("Configuration file changed, repreparing Intlayer");
+						clearModuleCache(filePath);
+						clearAllCache();
+						const { configuration: newConfiguration } = getConfigurationAndFilePath(options?.configOptions);
+						configuration = options?.configuration ?? newConfiguration;
+						await prepareIntlayer(configuration, { clean: false });
+					} else {
+						clearModuleCache(filePath);
+						clearAllCache();
+						clearDiskCacheMemory();
+						await handleContentDeclarationFileChange(filePath, configuration);
+					}
+				});
+			});
+			else if (event.type === "delete") {
+				const timer = setTimeout(async () => {
+					pendingUnlinks.delete(filePath);
+					processEvent(async () => handleUnlinkedContentDeclarationFile(filePath, configuration));
+				}, 200);
+				pendingUnlinks.set(filePath, {
+					timer,
+					oldPath: filePath
+				});
+			}
+		}
+	};
+	for (const dir of dirsToWatch) {
+		const sub = await subscribe(dir, contentHandler, { ignore: ignorePatterns });
+		subscriptions.push(sub);
+	}
+	return subscriptions;
+};
+const buildAndWatchIntlayer = async (options) => {
+	const { skipPrepare, ...rest } = options ?? {};
+	const configuration = options?.configuration ?? getConfiguration(options?.configOptions);
+	if (!skipPrepare) await prepareIntlayer(configuration, { forceRun: true });
+	if (options?.persistent) await watch({
+		...rest,
+		configuration
+	});
+};
+
+//#endregion
+export { buildAndWatchIntlayer, watch };
+//# sourceMappingURL=watcher.mjs.map

package/dist/esm/watcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.mjs","names":["fsWatch"],"sources":["../../src/watcher.ts"],"sourcesContent":["import { existsSync, watch as fsWatch } from 'node:fs';\nimport { readFile } from 'node:fs/promises';\nimport { basename, dirname, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport * as ANSIColor from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport {\n  type GetConfigurationOptions,\n  getConfiguration,\n  getConfigurationAndFilePath,\n} from '@intlayer/config/node';\nimport {\n  clearAllCache,\n  clearDiskCacheMemory,\n  clearModuleCache,\n  normalizePath,\n} from '@intlayer/config/utils';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { handleAdditionalContentDeclarationFile } from './handleAdditionalContentDeclarationFile';\nimport { handleContentDeclarationFileChange } from './handleContentDeclarationFileChange';\nimport { handleContentDeclarationFileMoved } from './handleContentDeclarationFileMoved';\nimport { handleUnlinkedContentDeclarationFile } from './handleUnlinkedContentDeclarationFile';\nimport { prepareIntlayer } from './prepareIntlayer';\nimport { formatPath } from './utils';\nimport { writeContentDeclaration } from './writeContentDeclaration';\n\n// Map to track files that were recently unlinked: oldPath -> { timer, timestamp }\nconst pendingUnlinks = new Map<\n  string,\n  { timer: NodeJS.Timeout; oldPath: string }\n>();\n\n// Array-based sequential task queue — no Promise chain accumulation, no race conditions\nconst taskQueue: (() => Promise<void>)[] = [];\nlet isProcessing = false;\n\nconst processQueue = async () => {\n  if (isProcessing) return;\n  isProcessing = true;\n  while (taskQueue.length > 0) {\n    const task = taskQueue.shift()!;\n    try {\n      await task();\n    } catch (error) {\n      console.error(error);\n    }\n  }\n  isProcessing = false;\n};\n\nconst processEvent = (task: () => Promise<void>) => {\n  taskQueue.push(task);\n  processQueue();\n};\n\ntype WatchOptions = {\n  configuration?: IntlayerConfig;\n  configOptions?: GetConfigurationOptions;\n  skipPrepare?: boolean;\n  persistent?: boolean;\n};\n\n// awaitWriteFinish equivalent: debounce per path until the file is stable\nconst STABILITY_THRESHOLD = 1000;\n\nconst createStabilityDebounce = () => {\n  const pending = new Map<string, NodeJS.Timeout>();\n  return (path: string, handler: () => void) => {\n    const existing = pending.get(path);\n    if (existing) clearTimeout(existing);\n    pending.set(\n      path,\n      setTimeout(() => {\n        pending.delete(path);\n        handler();\n      }, STABILITY_THRESHOLD)\n    );\n  };\n};\n\n// Initialize @parcel/watcher (non-persistent until subscribed)\nexport const watch = async (options?: WatchOptions) => {\n  const { subscribe } = await import('@parcel/watcher');\n\n  const configResult = getConfigurationAndFilePath(options?.configOptions);\n  const configurationFilePath = configResult.configurationFilePath;\n  let configuration: IntlayerConfig =\n    options?.configuration ?? configResult.configuration;\n  const appLogger = getAppLogger(configuration);\n\n  const {\n    watch: isWatchMode,\n    fileExtensions,\n    contentDir,\n    excludedPath,\n  } = configuration.content;\n\n  if (!configuration.content.watch) return;\n\n  appLogger('Watching Intlayer content declarations');\n\n  if (configuration.build.optimize === true) {\n    appLogger(\n      [\n        `Build optimization is forced to ${colorize('true', ANSIColor.GREY)}, but watching is enabled too.`,\n        'It may lead to dev mode performance degradation as well as import errors.',\n        'Its recommended to keep the',\n        colorize('`build.optimized`', ANSIColor.BLUE),\n        'option',\n        colorize('undefined', ANSIColor.GREY),\n        'to get the best dev mode experience',\n      ],\n      {\n        level: 'warn',\n      }\n    );\n  }\n\n  // Strip glob markers from excludedPath entries to get plain segments (e.g. 'node_modules')\n  const excludedSegments = excludedPath.map((segment) =>\n    segment.replace(/^\\*\\*\\//, '').replace(/\\/\\*\\*$/, '')\n  );\n\n  const normalizedConfigPath = configurationFilePath\n    ? normalizePath(configurationFilePath)\n    : null;\n\n  const { mainDir, baseDir } = configuration.system;\n  const normalizedMainDir = normalizePath(mainDir);\n  const normalizedIntlayerDir = normalizePath(dirname(mainDir));\n\n  const subscriptions: { unsubscribe: () => Promise<void> }[] = [];\n\n  const scheduleStable = createStabilityDebounce();\n\n  // ── mainDir watcher (depth 0) ──────────────────────────────────────────────\n  // Detects broken or missing entry-point files inside .intlayer/main\n  if (existsSync(mainDir)) {\n    const mainDirSub = await subscribe(normalizedMainDir, (err, events) => {\n      if (err || isProcessing) return;\n\n      for (const event of events) {\n        const eventPath = normalizePath(event.path);\n        // depth-0 filter: only files directly inside mainDir\n        const rel = eventPath.slice(normalizedMainDir.length + 1);\n        if (!rel || rel.includes('/')) continue;\n        // Temp files written by the bundler (write-then-rename) are build-internal;\n        // their deletion must not trigger a clean rebuild.\n        if (rel.endsWith('.tmp')) continue;\n\n        if (event.type === 'update') {\n          processEvent(async () => {\n            clearModuleCache(event.path);\n            try {\n              const fileUrl = pathToFileURL(event.path).href;\n              await import(`${fileUrl}?update=${Date.now()}`);\n            } catch {\n              appLogger(\n                `Entry point ${basename(event.path)} failed to load, running clean rebuild...`,\n                { level: 'warn' }\n              );\n              await prepareIntlayer(configuration, {\n                clean: true,\n                forceRun: true,\n              });\n            }\n          });\n        } else if (event.type === 'delete') {\n          processEvent(async () => {\n            appLogger(\n              [\n                'Entry point',\n                formatPath(basename(event.path)),\n                'was removed, running clean rebuild...',\n              ],\n              { level: 'warn' }\n            );\n            await prepareIntlayer(configuration, {\n              clean: true,\n              forceRun: true,\n            });\n          });\n        }\n      }\n    });\n    subscriptions.push(mainDirSub);\n  }\n\n  // ── baseDir watcher (depth 0) — detect .intlayer directory removal ─────────\n  // Native fs.watch is non-recursive and ideal for single-directory depth-0 detection.\n  const intlayerDirName = basename(normalizedIntlayerDir);\n  const fsDirWatcher = fsWatch(\n    baseDir,\n    { persistent: isWatchMode },\n    (eventType, filename) => {\n      if (isProcessing || !filename) return;\n      if (filename !== intlayerDirName) return;\n\n      const fullPath = normalizePath(resolve(baseDir, filename));\n      if (fullPath !== normalizedIntlayerDir) return;\n\n      if (eventType === 'rename' && !existsSync(normalizedIntlayerDir)) {\n        appLogger([\n          formatPath('.intlayer'),\n          'directory removed, running clean rebuild...',\n        ]);\n        processEvent(() =>\n          prepareIntlayer(configuration, { clean: true, forceRun: true })\n        );\n      }\n    }\n  );\n  subscriptions.push({\n    unsubscribe: async () => {\n      fsDirWatcher.close();\n    },\n  });\n\n  // ── main content watcher ───────────────────────────────────────────────────\n  // Ignore patterns for @parcel/watcher (micromatch globs)\n  const ignorePatterns = excludedSegments.map((s) => `**/${s}/**`);\n\n  const contentDirs = contentDir\n    .map((dir) => normalizePath(dir))\n    .filter(existsSync);\n\n  // Collect unique directories to subscribe to (dirs only, not file paths)\n  const dirsToWatch = new Set<string>(contentDirs);\n  if (normalizedConfigPath) {\n    dirsToWatch.add(normalizePath(dirname(normalizedConfigPath)));\n  }\n\n  const contentHandler = (\n    err: Error | null,\n    events: Array<{ type: string; path: string }>\n  ) => {\n    if (err) {\n      appLogger(`Watcher error: ${err}`, { level: 'error' });\n      appLogger('Restarting watcher');\n      prepareIntlayer(configuration);\n      return;\n    }\n\n    for (const event of events) {\n      const filePath = event.path;\n      const path = normalizePath(filePath);\n\n      const isConfigFile =\n        normalizedConfigPath && path === normalizedConfigPath;\n\n      if (!isConfigFile) {\n        // Must originate from a watched content directory\n        const isInContentDir = contentDirs.some(\n          (d) => path.startsWith(`${d}/`) || path === d\n        );\n        if (!isInContentDir) continue;\n\n        if (excludedSegments.some((segment) => path.includes(`/${segment}`)))\n          continue;\n\n        if (!fileExtensions.some((extension) => path.endsWith(extension)))\n          continue;\n      }\n\n      if (event.type === 'create') {\n        const fileName = basename(filePath);\n\n        // Move detection must happen synchronously before any debounce\n        let isMove = false;\n        let matchedOldPath: string | undefined;\n\n        for (const [oldPath] of pendingUnlinks) {\n          if (basename(oldPath) === fileName) {\n            matchedOldPath = oldPath;\n            break;\n          }\n        }\n\n        if (!matchedOldPath && pendingUnlinks.size === 1) {\n          matchedOldPath = pendingUnlinks.keys().next().value;\n        }\n\n        if (matchedOldPath) {\n          const pending = pendingUnlinks.get(matchedOldPath);\n          if (pending) {\n            clearTimeout(pending.timer);\n            pendingUnlinks.delete(matchedOldPath);\n          }\n          isMove = true;\n          appLogger(`File moved from ${matchedOldPath} to ${filePath}`);\n        }\n\n        if (isMove && matchedOldPath) {\n          processEvent(async () => {\n            await handleContentDeclarationFileMoved(\n              matchedOldPath!,\n              filePath,\n              configuration\n            );\n          });\n        } else {\n          // Debounce: wait for write to finish before reading the file\n          scheduleStable(path, () => {\n            processEvent(async () => {\n              const fileContent = await readFile(filePath, 'utf-8');\n              const isEmpty = fileContent === '';\n\n              if (isEmpty) {\n                const extensionPattern = fileExtensions\n                  .map((ext) => ext.replace(/\\./g, '\\\\.'))\n                  .join('|');\n                const name = fileName.replace(\n                  new RegExp(`(${extensionPattern})$`),\n                  ''\n                );\n\n                await writeContentDeclaration(\n                  { key: name, content: {}, filePath },\n                  configuration\n                );\n              }\n\n              await handleAdditionalContentDeclarationFile(\n                filePath,\n                configuration\n              );\n            });\n          });\n        }\n      } else if (event.type === 'update') {\n        scheduleStable(path, () => {\n          processEvent(async () => {\n            if (isConfigFile) {\n              appLogger('Configuration file changed, repreparing Intlayer');\n\n              clearModuleCache(filePath);\n              clearAllCache();\n\n              const { configuration: newConfiguration } =\n                getConfigurationAndFilePath(options?.configOptions);\n\n              configuration = options?.configuration ?? newConfiguration;\n\n              await prepareIntlayer(configuration, { clean: false });\n            } else {\n              // Clear module cache for the changed file to avoid stale require() results\n              clearModuleCache(filePath);\n              // Evict in-memory caches so loadContentDeclaration picks up fresh content\n              clearAllCache();\n              clearDiskCacheMemory();\n              await handleContentDeclarationFileChange(filePath, configuration);\n            }\n          });\n        });\n      } else if (event.type === 'delete') {\n        // Delay unlink processing to see if an 'add' event occurs (indicating a move)\n        const timer = setTimeout(async () => {\n          // If timer fires, the file was genuinely removed\n          pendingUnlinks.delete(filePath);\n          processEvent(async () =>\n            handleUnlinkedContentDeclarationFile(filePath, configuration)\n          );\n        }, 200); // 200ms window to catch the 'create' event\n\n        pendingUnlinks.set(filePath, { timer, oldPath: filePath });\n      }\n    }\n  };\n\n  for (const dir of dirsToWatch) {\n    const sub = await subscribe(dir, contentHandler, {\n      ignore: ignorePatterns,\n    });\n\n    subscriptions.push(sub);\n  }\n\n  return subscriptions;\n};\n\nexport const buildAndWatchIntlayer = async (options?: WatchOptions) => {\n  const { skipPrepare, ...rest } = options ?? {};\n  const configuration =\n    options?.configuration ?? getConfiguration(options?.configOptions);\n\n  if (!skipPrepare) {\n    await prepareIntlayer(configuration, { forceRun: true });\n  }\n\n  // Only enter watch mode when the caller explicitly opts in via `persistent`.\n  // `configuration.content.watch` is the dev-mode signal consumed by bundler\n  // plugins (e.g. vite-intlayer's `configureServer`); it must not coerce\n  // `intlayer build` (which passes `persistent: false`) into a persistent\n  // watcher, since that prevents the build command from ever exiting.\n  if (options?.persistent) {\n    await watch({ ...rest, configuration });\n  }\n};\n"],"mappings":"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"}

package/dist/esm/writeConfiguration/generateConfigurationContent.mjs

@@ -0,0 +1,33 @@
+//#region src/writeConfiguration/generateConfigurationContent.ts
+const generateConfigurationContent = (configuration, format) => {
+	const { internationalization, routing, editor, log, system, content, ai, dictionary, build, compiler } = configuration;
+	let fileContent = "";
+	fileContent += `const internationalization = ${JSON.stringify(internationalization, null, 2)};\n`;
+	fileContent += `const routing = ${JSON.stringify(routing, null, 2)};\n`;
+	fileContent += `const editor = ${JSON.stringify(editor, null, 2)};\n`;
+	fileContent += `const log = ${JSON.stringify(log, null, 2)};\n`;
+	fileContent += `const system = ${JSON.stringify(system, null, 2)};\n`;
+	fileContent += `const content = ${JSON.stringify(content, null, 2)};\n`;
+	fileContent += `const ai = ${JSON.stringify(ai, null, 2)};\n`;
+	fileContent += `const dictionary = ${JSON.stringify(dictionary, null, 2)};\n`;
+	fileContent += `const build = ${JSON.stringify(build, null, 2)};\n`;
+	fileContent += `const compiler = ${JSON.stringify(compiler, null, 2)};\n`;
+	if (format === "esm") fileContent += `\nexport { internationalization, routing, editor, log, system, content, ai, dictionary, build, compiler };\n`;
+	else {
+		fileContent += `\nmodule.exports.internationalization = internationalization;\n`;
+		fileContent += `module.exports.routing = routing;\n`;
+		fileContent += `module.exports.editor = editor;\n`;
+		fileContent += `module.exports.log = log;\n`;
+		fileContent += `module.exports.system = system;\n`;
+		fileContent += `module.exports.content = content;\n`;
+		fileContent += `module.exports.ai = ai;\n`;
+		fileContent += `module.exports.dictionary = dictionary;\n`;
+		fileContent += `module.exports.build = build;\n`;
+		fileContent += `module.exports.compiler = compiler;\n`;
+	}
+	return fileContent;
+};
+
+//#endregion
+export { generateConfigurationContent };
+//# sourceMappingURL=generateConfigurationContent.mjs.map

package/dist/esm/writeConfiguration/generateConfigurationContent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateConfigurationContent.mjs","names":[],"sources":["../../../src/writeConfiguration/generateConfigurationContent.ts"],"sourcesContent":["import type { IntlayerConfig } from '@intlayer/types/config';\n\nexport const generateConfigurationContent = (\n  configuration: IntlayerConfig,\n  format: 'cjs' | 'esm'\n): string => {\n  const {\n    internationalization,\n    routing,\n    editor,\n    log,\n    system,\n    content,\n    ai,\n    dictionary,\n    build,\n    compiler,\n  } = configuration;\n\n  let fileContent = '';\n\n  fileContent += `const internationalization = ${JSON.stringify(internationalization, null, 2)};\\n`;\n  fileContent += `const routing = ${JSON.stringify(routing, null, 2)};\\n`;\n  fileContent += `const editor = ${JSON.stringify(editor, null, 2)};\\n`;\n  fileContent += `const log = ${JSON.stringify(log, null, 2)};\\n`;\n  fileContent += `const system = ${JSON.stringify(system, null, 2)};\\n`;\n  fileContent += `const content = ${JSON.stringify(content, null, 2)};\\n`;\n  fileContent += `const ai = ${JSON.stringify(ai, null, 2)};\\n`;\n  fileContent += `const dictionary = ${JSON.stringify(dictionary, null, 2)};\\n`;\n  fileContent += `const build = ${JSON.stringify(build, null, 2)};\\n`;\n  fileContent += `const compiler = ${JSON.stringify(compiler, null, 2)};\\n`;\n\n  if (format === 'esm') {\n    fileContent += `\\nexport { internationalization, routing, editor, log, system, content, ai, dictionary, build, compiler };\\n`;\n  } else {\n    fileContent += `\\nmodule.exports.internationalization = internationalization;\\n`;\n    fileContent += `module.exports.routing = routing;\\n`;\n    fileContent += `module.exports.editor = editor;\\n`;\n    fileContent += `module.exports.log = log;\\n`;\n    fileContent += `module.exports.system = system;\\n`;\n    fileContent += `module.exports.content = content;\\n`;\n    fileContent += `module.exports.ai = ai;\\n`;\n    fileContent += `module.exports.dictionary = dictionary;\\n`;\n    fileContent += `module.exports.build = build;\\n`;\n    fileContent += `module.exports.compiler = compiler;\\n`;\n  }\n\n  return fileContent;\n};\n"],"mappings":";AAEA,MAAa,gCACX,eACA,WACW;CACX,MAAM,EACJ,sBACA,SACA,QACA,KACA,QACA,SACA,IACA,YACA,OACA,aACE;CAEJ,IAAI,cAAc;AAElB,gBAAe,gCAAgC,KAAK,UAAU,sBAAsB,MAAM,EAAE,CAAC;AAC7F,gBAAe,mBAAmB,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC;AACnE,gBAAe,kBAAkB,KAAK,UAAU,QAAQ,MAAM,EAAE,CAAC;AACjE,gBAAe,eAAe,KAAK,UAAU,KAAK,MAAM,EAAE,CAAC;AAC3D,gBAAe,kBAAkB,KAAK,UAAU,QAAQ,MAAM,EAAE,CAAC;AACjE,gBAAe,mBAAmB,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC;AACnE,gBAAe,cAAc,KAAK,UAAU,IAAI,MAAM,EAAE,CAAC;AACzD,gBAAe,sBAAsB,KAAK,UAAU,YAAY,MAAM,EAAE,CAAC;AACzE,gBAAe,iBAAiB,KAAK,UAAU,OAAO,MAAM,EAAE,CAAC;AAC/D,gBAAe,oBAAoB,KAAK,UAAU,UAAU,MAAM,EAAE,CAAC;AAErE,KAAI,WAAW,MACb,gBAAe;MACV;AACL,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;AACf,iBAAe;;AAGjB,QAAO"}

package/dist/esm/writeConfiguration/index.mjs

@@ -0,0 +1,22 @@
+import { writeFileIfChanged } from "../writeFileIfChanged.mjs";
+import { generateConfigurationContent } from "./generateConfigurationContent.mjs";
+import { mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+//#region src/writeConfiguration/index.ts
+const isCachedConfigurationUpToDate = async (configuration) => {
+	try {
+		return await readFile(join(configuration.system.configDir, "configuration.mjs"), "utf8") === generateConfigurationContent(configuration, "esm");
+	} catch {
+		return null;
+	}
+};
+const writeConfiguration = async (configuration) => {
+	const { configDir } = configuration.system;
+	await mkdir(configDir, { recursive: true });
+	await Promise.all([writeFileIfChanged(join(configDir, "configuration.mjs"), generateConfigurationContent(configuration, "esm")), writeFileIfChanged(join(configDir, "configuration.cjs"), generateConfigurationContent(configuration, "cjs"))]);
+};
+
+//#endregion
+export { isCachedConfigurationUpToDate, writeConfiguration };
+//# sourceMappingURL=index.mjs.map

package/dist/esm/writeConfiguration/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/writeConfiguration/index.ts"],"sourcesContent":["import { mkdir, readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { IntlayerConfig } from '@intlayer/types/config';\nimport { writeFileIfChanged } from '../writeFileIfChanged';\nimport { generateConfigurationContent } from './generateConfigurationContent';\n\nexport const isCachedConfigurationUpToDate = async (\n  configuration: IntlayerConfig\n): Promise<boolean | null> => {\n  try {\n    const mjsPath = join(configuration.system.configDir, 'configuration.mjs');\n    const existingContent = await readFile(mjsPath, 'utf8');\n    const expectedContent = generateConfigurationContent(configuration, 'esm');\n    return existingContent === expectedContent;\n  } catch {\n    return null; // Can crash if file doesn't exist yet or config is not defined\n  }\n};\n\nexport const writeConfiguration = async (configuration: IntlayerConfig) => {\n  const { configDir } = configuration.system;\n\n  await mkdir(configDir, { recursive: true });\n\n  await Promise.all([\n    writeFileIfChanged(\n      join(configDir, 'configuration.mjs'),\n      generateConfigurationContent(configuration, 'esm')\n    ),\n    writeFileIfChanged(\n      join(configDir, 'configuration.cjs'),\n      generateConfigurationContent(configuration, 'cjs')\n    ),\n  ]);\n};\n"],"mappings":";;;;;;AAMA,MAAa,gCAAgC,OAC3C,kBAC4B;AAC5B,KAAI;AAIF,SAAO,MAFuB,SADd,KAAK,cAAc,OAAO,WAAW,oBACP,EAAE,OAAO,KAC/B,6BAA6B,eAAe,MAC1B;SACpC;AACN,SAAO;;;AAIX,MAAa,qBAAqB,OAAO,kBAAkC;CACzE,MAAM,EAAE,cAAc,cAAc;AAEpC,OAAM,MAAM,WAAW,EAAE,WAAW,MAAM,CAAC;AAE3C,OAAM,QAAQ,IAAI,CAChB,mBACE,KAAK,WAAW,oBAAoB,EACpC,6BAA6B,eAAe,MAAM,CACnD,EACD,mBACE,KAAK,WAAW,oBAAoB,EACpC,6BAA6B,eAAe,MAAM,CACnD,CACF,CAAC"}

package/dist/esm/writeContentDeclaration/detectExportedComponentName.mjs

@@ -0,0 +1,27 @@
+//#region src/writeContentDeclaration/detectExportedComponentName.ts
+/**
+* Attempt to detect an exported React component name in the file text.
+* Looks for patterns like:
+*   - export const MyComponent = ...
+*   - export function MyComponent(...)
+*   - export default function MyComponent(...)
+*/
+const detectExportedComponentName = (fileText) => {
+	const defaultEsmFnRegex = /export\s+default\s+function\s+(\w+)/;
+	const defaultEsmVarRegex = /export\s+default\s+(\w+)/;
+	const cjsDefaultRegex = /module\.exports\s*=\s*(\w+)/;
+	const cjsDefaultVarRegex = /exports\.default\s*=\s*(\w+)/;
+	const namedExportRegex = /export\s+(?:const|function)\s+(\w+)/g;
+	const defaultEsmFnMatch = fileText.match(defaultEsmFnRegex);
+	if (defaultEsmFnMatch) return defaultEsmFnMatch[1];
+	const defaultEsmVarMatch = fileText.match(defaultEsmVarRegex);
+	if (defaultEsmVarMatch) return defaultEsmVarMatch[1];
+	const cjsDefaultMatch = fileText.match(cjsDefaultRegex) || fileText.match(cjsDefaultVarRegex);
+	if (cjsDefaultMatch) return cjsDefaultMatch[1];
+	for (const match of fileText.matchAll(namedExportRegex)) if (/^[A-Z]/.test(match[1])) return match[1];
+	return null;
+};
+
+//#endregion
+export { detectExportedComponentName };
+//# sourceMappingURL=detectExportedComponentName.mjs.map

package/dist/esm/writeContentDeclaration/detectExportedComponentName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectExportedComponentName.mjs","names":[],"sources":["../../../src/writeContentDeclaration/detectExportedComponentName.ts"],"sourcesContent":["/**\n * Attempt to detect an exported React component name in the file text.\n * Looks for patterns like:\n *   - export const MyComponent = ...\n *   - export function MyComponent(...)\n *   - export default function MyComponent(...)\n */\nexport const detectExportedComponentName = (\n  fileText: string\n): string | null => {\n  // Added regexes for default ESM, default CJS, and named exports\n  const defaultEsmFnRegex = /export\\s+default\\s+function\\s+(\\w+)/;\n  const defaultEsmVarRegex = /export\\s+default\\s+(\\w+)/;\n  const cjsDefaultRegex = /module\\.exports\\s*=\\s*(\\w+)/;\n  const cjsDefaultVarRegex = /exports\\.default\\s*=\\s*(\\w+)/;\n  const namedExportRegex = /export\\s+(?:const|function)\\s+(\\w+)/g;\n\n  // Check for default ESM function or variable\n  const defaultEsmFnMatch = fileText.match(defaultEsmFnRegex);\n  if (defaultEsmFnMatch) {\n    return defaultEsmFnMatch[1];\n  }\n\n  const defaultEsmVarMatch = fileText.match(defaultEsmVarRegex);\n  if (defaultEsmVarMatch) {\n    return defaultEsmVarMatch[1];\n  }\n\n  // Check for default CJS\n  const cjsDefaultMatch =\n    fileText.match(cjsDefaultRegex) || fileText.match(cjsDefaultVarRegex);\n\n  if (cjsDefaultMatch) return cjsDefaultMatch[1];\n\n  // Otherwise, look for capitalized named exports\n  for (const match of fileText.matchAll(namedExportRegex)) {\n    if (/^[A-Z]/.test(match[1])) return match[1];\n  }\n\n  // If we can’t find it, return null\n  return null;\n};\n"],"mappings":";;;;;;;;AAOA,MAAa,+BACX,aACkB;CAElB,MAAM,oBAAoB;CAC1B,MAAM,qBAAqB;CAC3B,MAAM,kBAAkB;CACxB,MAAM,qBAAqB;CAC3B,MAAM,mBAAmB;CAGzB,MAAM,oBAAoB,SAAS,MAAM,kBAAkB;AAC3D,KAAI,kBACF,QAAO,kBAAkB;CAG3B,MAAM,qBAAqB,SAAS,MAAM,mBAAmB;AAC7D,KAAI,mBACF,QAAO,mBAAmB;CAI5B,MAAM,kBACJ,SAAS,MAAM,gBAAgB,IAAI,SAAS,MAAM,mBAAmB;AAEvE,KAAI,gBAAiB,QAAO,gBAAgB;AAG5C,MAAK,MAAM,SAAS,SAAS,SAAS,iBAAiB,CACrD,KAAI,SAAS,KAAK,MAAM,GAAG,CAAE,QAAO,MAAM;AAI5C,QAAO"}

package/dist/esm/writeContentDeclaration/index.mjs

@@ -0,0 +1,6 @@
+import { detectExportedComponentName } from "./detectExportedComponentName.mjs";
+import { transformJSFile } from "./transformJSFile.mjs";
+import { writeJSFile } from "./writeJSFile.mjs";
+import { writeContentDeclaration } from "./writeContentDeclaration.mjs";
+
+export { detectExportedComponentName, transformJSFile, writeContentDeclaration, writeJSFile };

package/dist/esm/writeContentDeclaration/processContentDeclarationContent.mjs

@@ -0,0 +1,92 @@
+import { dirname, join } from "node:path";
+import { colorizePath, x } from "@intlayer/config/logger";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { deepTransformNode } from "@intlayer/core/interpreter";
+import * as NodeTypes from "@intlayer/types/nodeType";
+
+//#region src/writeContentDeclaration/processContentDeclarationContent.ts
+/**
+* Write file plugin
+*/
+const writeFilePlugin = {
+	id: "write-file-plugin",
+	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeTypes.FILE,
+	transform: (node) => {
+		const fileContent = node.content;
+		const filePath = node.fixedPath;
+		if (typeof fileContent !== "string") throw new Error("File content must be a string");
+		if (typeof filePath !== "string") throw new Error("File path must be a string");
+		try {
+			const absoluteFilePath = join(process.cwd(), filePath);
+			const fileDirectory = dirname(absoluteFilePath);
+			if (!existsSync(fileDirectory)) mkdirSync(fileDirectory, { recursive: true });
+			writeFileSync(absoluteFilePath, fileContent);
+		} catch (error) {
+			throw new Error(`${x} Error writing file to ${colorizePath(filePath)}: ${error}`);
+		}
+		return {
+			nodeType: NodeTypes.FILE,
+			[NodeTypes.FILE]: node[NodeTypes.FILE]
+		};
+	}
+};
+/**
+* Markdown file plugin
+*/
+const markdownFilePlugin = {
+	id: "markdown-file-plugin",
+	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeTypes.MARKDOWN,
+	transform: (node, props, deepTransformNode) => {
+		return {
+			nodeType: NodeTypes.MARKDOWN,
+			[NodeTypes.MARKDOWN]: deepTransformNode(node[NodeTypes.MARKDOWN], props)
+		};
+	}
+};
+/**
+* Insertion file plugin
+*/
+const insertionFilePlugin = {
+	id: "insertion-file-plugin",
+	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeTypes.INSERTION,
+	transform: (node, props, deepTransformNode) => {
+		return {
+			nodeType: NodeTypes.INSERTION,
+			[NodeTypes.INSERTION]: deepTransformNode(node[NodeTypes.INSERTION], props)
+		};
+	}
+};
+/**
+* HTML file plugin
+*/
+const htmlFilePlugin = {
+	id: "html-file-plugin",
+	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeTypes.HTML,
+	transform: (node, props, deepTransformNode) => {
+		return {
+			nodeType: NodeTypes.HTML,
+			[NodeTypes.HTML]: deepTransformNode(node[NodeTypes.HTML], props)
+		};
+	}
+};
+/**
+* Process content declaration content
+*
+* It filter node that are autogenerated by intlayer to do not rewrite them in the content declaration file.
+*
+* And write external sources as file content if necessary.
+*/
+const processContentDeclarationContent = async (dictionary) => deepTransformNode(dictionary, {
+	dictionaryKey: dictionary.key,
+	keyPath: [],
+	plugins: [
+		writeFilePlugin,
+		markdownFilePlugin,
+		insertionFilePlugin,
+		htmlFilePlugin
+	]
+});
+
+//#endregion
+export { processContentDeclarationContent };
+//# sourceMappingURL=processContentDeclarationContent.mjs.map

package/dist/esm/writeContentDeclaration/processContentDeclarationContent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"processContentDeclarationContent.mjs","names":[],"sources":["../../../src/writeContentDeclaration/processContentDeclarationContent.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { colorizePath, x } from '@intlayer/config/logger';\nimport { deepTransformNode, type Plugins } from '@intlayer/core/interpreter';\nimport type {\n  FileContent,\n  FileContentConstructor,\n  HTMLContent,\n  HTMLContentConstructor,\n  InsertionContent,\n  InsertionContentConstructor,\n  MarkdownContent,\n  MarkdownContentConstructor,\n} from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport * as NodeTypes from '@intlayer/types/nodeType';\n\n/**\n * Write file plugin\n */\n\nconst writeFilePlugin: Plugins = {\n  id: 'write-file-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeTypes.FILE,\n  transform: (node: FileContent) => {\n    const fileContent = node.content;\n    const filePath = node.fixedPath;\n\n    if (typeof fileContent !== 'string') {\n      throw new Error('File content must be a string');\n    }\n\n    if (typeof filePath !== 'string') {\n      throw new Error('File path must be a string');\n    }\n\n    // Write the file to the file system\n    try {\n      const absoluteFilePath = join(process.cwd(), filePath);\n\n      // Create the file directory if it doesn't exist\n      const fileDirectory = dirname(absoluteFilePath);\n\n      if (!existsSync(fileDirectory)) {\n        mkdirSync(fileDirectory, { recursive: true });\n      }\n\n      // Write the file\n      writeFileSync(absoluteFilePath, fileContent);\n    } catch (error) {\n      throw new Error(\n        `${x} Error writing file to ${colorizePath(filePath)}: ${error}`\n      );\n    }\n\n    const transformedFileContent: FileContentConstructor = {\n      nodeType: NodeTypes.FILE,\n      [NodeTypes.FILE]: node[NodeTypes.FILE],\n    };\n\n    return transformedFileContent;\n  },\n};\n\n/**\n * Markdown file plugin\n */\n\nconst markdownFilePlugin: Plugins = {\n  id: 'markdown-file-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeTypes.MARKDOWN,\n  transform: (node: MarkdownContent, props, deepTransformNode) => {\n    const simplifiedMarkdownNode: MarkdownContentConstructor = {\n      nodeType: NodeTypes.MARKDOWN,\n      [NodeTypes.MARKDOWN]: deepTransformNode(node[NodeTypes.MARKDOWN], props),\n    };\n\n    return simplifiedMarkdownNode;\n  },\n};\n\n/**\n * Insertion file plugin\n */\n\nconst insertionFilePlugin: Plugins = {\n  id: 'insertion-file-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeTypes.INSERTION,\n  transform: (node: InsertionContent, props, deepTransformNode) => {\n    const simplifiedInsertionNode: InsertionContentConstructor = {\n      nodeType: NodeTypes.INSERTION,\n      [NodeTypes.INSERTION]: deepTransformNode(\n        node[NodeTypes.INSERTION],\n        props\n      ),\n    };\n\n    return simplifiedInsertionNode;\n  },\n};\n\n/**\n * HTML file plugin\n */\n\nconst htmlFilePlugin: Plugins = {\n  id: 'html-file-plugin',\n  canHandle: (node) =>\n    typeof node === 'object' && node?.nodeType === NodeTypes.HTML,\n  transform: (node: HTMLContent, props, deepTransformNode) => {\n    const simplifiedHTMLNode: HTMLContentConstructor = {\n      nodeType: NodeTypes.HTML,\n      [NodeTypes.HTML]: deepTransformNode(node[NodeTypes.HTML], props),\n    };\n\n    return simplifiedHTMLNode;\n  },\n};\n\n/**\n * Process content declaration content\n *\n * It filter node that are autogenerated by intlayer to do not rewrite them in the content declaration file.\n *\n * And write external sources as file content if necessary.\n */\nexport const processContentDeclarationContent = async (\n  dictionary: Dictionary\n) =>\n  deepTransformNode(dictionary, {\n    dictionaryKey: dictionary.key,\n    keyPath: [],\n    plugins: [\n      writeFilePlugin,\n      markdownFilePlugin,\n      insertionFilePlugin,\n      htmlFilePlugin,\n    ],\n  });\n"],"mappings":";;;;;;;;;;AAqBA,MAAM,kBAA2B;CAC/B,IAAI;CACJ,YAAY,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,UAAU;CAC3D,YAAY,SAAsB;EAChC,MAAM,cAAc,KAAK;EACzB,MAAM,WAAW,KAAK;AAEtB,MAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MAAM,gCAAgC;AAGlD,MAAI,OAAO,aAAa,SACtB,OAAM,IAAI,MAAM,6BAA6B;AAI/C,MAAI;GACF,MAAM,mBAAmB,KAAK,QAAQ,KAAK,EAAE,SAAS;GAGtD,MAAM,gBAAgB,QAAQ,iBAAiB;AAE/C,OAAI,CAAC,WAAW,cAAc,CAC5B,WAAU,eAAe,EAAE,WAAW,MAAM,CAAC;AAI/C,iBAAc,kBAAkB,YAAY;WACrC,OAAO;AACd,SAAM,IAAI,MACR,GAAG,EAAE,yBAAyB,aAAa,SAAS,CAAC,IAAI,QAC1D;;AAQH,SAAO;GAJL,UAAU,UAAU;IACnB,UAAU,OAAO,KAAK,UAAU;GAGN;;CAEhC;;;;AAMD,MAAM,qBAA8B;CAClC,IAAI;CACJ,YAAY,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,UAAU;CAC3D,YAAY,MAAuB,OAAO,sBAAsB;AAM9D,SAAO;GAJL,UAAU,UAAU;IACnB,UAAU,WAAW,kBAAkB,KAAK,UAAU,WAAW,MAAM;GAG7C;;CAEhC;;;;AAMD,MAAM,sBAA+B;CACnC,IAAI;CACJ,YAAY,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,UAAU;CAC3D,YAAY,MAAwB,OAAO,sBAAsB;AAS/D,SAAO;GAPL,UAAU,UAAU;IACnB,UAAU,YAAY,kBACrB,KAAK,UAAU,YACf,MACD;GAG2B;;CAEjC;;;;AAMD,MAAM,iBAA0B;CAC9B,IAAI;CACJ,YAAY,SACV,OAAO,SAAS,YAAY,MAAM,aAAa,UAAU;CAC3D,YAAY,MAAmB,OAAO,sBAAsB;AAM1D,SAAO;GAJL,UAAU,UAAU;IACnB,UAAU,OAAO,kBAAkB,KAAK,UAAU,OAAO,MAAM;GAGzC;;CAE5B;;;;;;;;AASD,MAAa,mCAAmC,OAC9C,eAEA,kBAAkB,YAAY;CAC5B,eAAe,WAAW;CAC1B,SAAS,EAAE;CACX,SAAS;EACP;EACA;EACA;EACA;EACD;CACF,CAAC"}