@intlayer/engine 9.0.0-canary.12

package/dist/esm/init/utils/astImports.mjs

@@ -0,0 +1,51 @@
+import * as recast from "recast";
+
+//#region src/init/utils/astImports.ts
+const { builders: b } = recast.types;
+/**
+* Index just past the leading directives (e.g. `'use client'`) and import
+* declarations — the safe insertion point for a new import.
+*/
+const firstInsertIndex = (ast) => {
+	const body = ast.program.body;
+	let index = 0;
+	while (index < body.length && (body[index].type === "ExpressionStatement" && body[index].expression?.type === "StringLiteral" || body[index].type === "ImportDeclaration")) index++;
+	return index;
+};
+/**
+* Whether `name` is already bound at module scope — by any import (under that
+* local name, regardless of source) or by a top-level
+* `const`/`let`/`var`/`function`/`class` declaration.
+*
+* Used to avoid redeclaring an identifier the file already provides (e.g. a
+* `defaultLocale` re-exported from a local `i18n` module), which would otherwise
+* produce an `Identifier '…' has already been declared` parse error.
+*/
+const isModuleScopeBinding = (ast, name) => ast.program.body.some((statement) => {
+	const node = (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") && statement.declaration ? statement.declaration : statement;
+	if (node.type === "ImportDeclaration") return node.specifiers.some((spec) => spec.local?.name === name);
+	if (node.type === "VariableDeclaration") return node.declarations.some((decl) => decl.id?.type === "Identifier" && decl.id.name === name);
+	if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") return node.id?.name === name;
+	return false;
+});
+/**
+* Ensures `import { importName } from source`, merging into an existing import
+* from the same source. No-ops when `importName` is already bound at module
+* scope (imported from another source or declared locally), reusing that binding
+* instead of redeclaring it.
+*
+* Shared across every framework adapter so injected identifiers never collide
+* with bindings the user's file already provides.
+*/
+const ensureNamedImport = (ast, importName, source) => {
+	if (isModuleScopeBinding(ast, importName)) return;
+	for (const statement of ast.program.body) if (statement.type === "ImportDeclaration" && statement.source.value === source) {
+		if (!statement.specifiers.some((spec) => spec.type === "ImportSpecifier" && spec.imported?.name === importName)) statement.specifiers.push(b.importSpecifier(b.identifier(importName)));
+		return;
+	}
+	ast.program.body.splice(firstInsertIndex(ast), 0, b.importDeclaration([b.importSpecifier(b.identifier(importName))], b.stringLiteral(source)));
+};
+
+//#endregion
+export { ensureNamedImport, firstInsertIndex, isModuleScopeBinding };
+//# sourceMappingURL=astImports.mjs.map

package/dist/esm/init/utils/astImports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"astImports.mjs","names":[],"sources":["../../../../src/init/utils/astImports.ts"],"sourcesContent":["import * as recast from 'recast';\n\nconst { builders: b } = recast.types;\n\n/**\n * Index just past the leading directives (e.g. `'use client'`) and import\n * declarations — the safe insertion point for a new import.\n */\nexport const firstInsertIndex = (ast: any): number => {\n  const body = ast.program.body;\n  let index = 0;\n  while (\n    index < body.length &&\n    ((body[index].type === 'ExpressionStatement' &&\n      body[index].expression?.type === 'StringLiteral') ||\n      body[index].type === 'ImportDeclaration')\n  ) {\n    index++;\n  }\n  return index;\n};\n\n/**\n * Whether `name` is already bound at module scope — by any import (under that\n * local name, regardless of source) or by a top-level\n * `const`/`let`/`var`/`function`/`class` declaration.\n *\n * Used to avoid redeclaring an identifier the file already provides (e.g. a\n * `defaultLocale` re-exported from a local `i18n` module), which would otherwise\n * produce an `Identifier '…' has already been declared` parse error.\n */\nexport const isModuleScopeBinding = (ast: any, name: string): boolean =>\n  ast.program.body.some((statement: any) => {\n    // `export const x = …` / `export function x` / `export default class x`\n    const node =\n      (statement.type === 'ExportNamedDeclaration' ||\n        statement.type === 'ExportDefaultDeclaration') &&\n      statement.declaration\n        ? statement.declaration\n        : statement;\n\n    if (node.type === 'ImportDeclaration') {\n      return node.specifiers.some((spec: any) => spec.local?.name === name);\n    }\n    if (node.type === 'VariableDeclaration') {\n      return node.declarations.some(\n        (decl: any) => decl.id?.type === 'Identifier' && decl.id.name === name\n      );\n    }\n    if (\n      node.type === 'FunctionDeclaration' ||\n      node.type === 'ClassDeclaration'\n    ) {\n      return node.id?.name === name;\n    }\n    return false;\n  });\n\n/**\n * Ensures `import { importName } from source`, merging into an existing import\n * from the same source. No-ops when `importName` is already bound at module\n * scope (imported from another source or declared locally), reusing that binding\n * instead of redeclaring it.\n *\n * Shared across every framework adapter so injected identifiers never collide\n * with bindings the user's file already provides.\n */\nexport const ensureNamedImport = (\n  ast: any,\n  importName: string,\n  source: string\n): void => {\n  if (isModuleScopeBinding(ast, importName)) return;\n\n  for (const statement of ast.program.body) {\n    if (\n      statement.type === 'ImportDeclaration' &&\n      statement.source.value === source\n    ) {\n      const hasSpecifier = statement.specifiers.some(\n        (spec: any) =>\n          spec.type === 'ImportSpecifier' && spec.imported?.name === importName\n      );\n      if (!hasSpecifier) {\n        statement.specifiers.push(b.importSpecifier(b.identifier(importName)));\n      }\n      return;\n    }\n  }\n\n  ast.program.body.splice(\n    firstInsertIndex(ast),\n    0,\n    b.importDeclaration(\n      [b.importSpecifier(b.identifier(importName))],\n      b.stringLiteral(source)\n    )\n  );\n};\n"],"mappings":";;;AAEA,MAAM,EAAE,UAAU,MAAM,OAAO;;;;;AAM/B,MAAa,oBAAoB,QAAqB;CACpD,MAAM,OAAO,IAAI,QAAQ;CACzB,IAAI,QAAQ;AACZ,QACE,QAAQ,KAAK,WACX,KAAK,OAAO,SAAS,yBACrB,KAAK,OAAO,YAAY,SAAS,mBACjC,KAAK,OAAO,SAAS,qBAEvB;AAEF,QAAO;;;;;;;;;;;AAYT,MAAa,wBAAwB,KAAU,SAC7C,IAAI,QAAQ,KAAK,MAAM,cAAmB;CAExC,MAAM,QACH,UAAU,SAAS,4BAClB,UAAU,SAAS,+BACrB,UAAU,cACN,UAAU,cACV;AAEN,KAAI,KAAK,SAAS,oBAChB,QAAO,KAAK,WAAW,MAAM,SAAc,KAAK,OAAO,SAAS,KAAK;AAEvE,KAAI,KAAK,SAAS,sBAChB,QAAO,KAAK,aAAa,MACtB,SAAc,KAAK,IAAI,SAAS,gBAAgB,KAAK,GAAG,SAAS,KACnE;AAEH,KACE,KAAK,SAAS,yBACd,KAAK,SAAS,mBAEd,QAAO,KAAK,IAAI,SAAS;AAE3B,QAAO;EACP;;;;;;;;;;AAWJ,MAAa,qBACX,KACA,YACA,WACS;AACT,KAAI,qBAAqB,KAAK,WAAW,CAAE;AAE3C,MAAK,MAAM,aAAa,IAAI,QAAQ,KAClC,KACE,UAAU,SAAS,uBACnB,UAAU,OAAO,UAAU,QAC3B;AAKA,MAAI,CAJiB,UAAU,WAAW,MACvC,SACC,KAAK,SAAS,qBAAqB,KAAK,UAAU,SAAS,WAE9C,CACf,WAAU,WAAW,KAAK,EAAE,gBAAgB,EAAE,WAAW,WAAW,CAAC,CAAC;AAExE;;AAIJ,KAAI,QAAQ,KAAK,OACf,iBAAiB,IAAI,EACrB,GACA,EAAE,kBACA,CAAC,EAAE,gBAAgB,EAAE,WAAW,WAAW,CAAC,CAAC,EAC7C,EAAE,cAAc,OAAO,CACxB,CACF"}

package/dist/esm/init/utils/configManipulation.mjs

@@ -0,0 +1,499 @@
+import { __require } from "../../_virtual/_rolldown/runtime.mjs";
+import { isModuleScopeBinding } from "./astImports.mjs";
+import * as recast from "recast";
+
+//#region src/init/utils/configManipulation.ts
+const { builders: b, namedTypes: n } = recast.types;
+/** Narrows an arbitrary recast node to an object expression. */
+const isObjectExpression = (node) => Boolean(node) && (node.type === "ObjectExpression" || n.ObjectExpression.check(node));
+/**
+* Finds a property by key name on an object expression, creating it with the
+* provided default value node when it is absent. Returns the property node so
+* callers can read or mutate its value while preserving any attached comments.
+*/
+const ensureObjectProperty = (objExpr, key, defaultValueNode) => {
+	let property = objExpr.properties.find((prop) => {
+		if (!prop?.key) return false;
+		return (prop.key.name ?? prop.key.value) === key;
+	});
+	if (!property) {
+		property = b.property("init", b.identifier(key), defaultValueNode);
+		objExpr.properties.push(property);
+	}
+	return property;
+};
+/**
+* Sets (or replaces) a property's value on an object expression. When the
+* property already exists only its value node is swapped, which keeps the
+* leading documentation comment in place.
+*/
+const setObjectPropertyValue = (objExpr, key, valueNode) => {
+	const property = objExpr.properties.find((prop) => {
+		if (!prop?.key) return false;
+		return (prop.key.name ?? prop.key.value) === key;
+	});
+	if (property) {
+		property.value = valueNode;
+		return;
+	}
+	objExpr.properties.push(b.property("init", b.identifier(key), valueNode));
+};
+/**
+* Adds a `process.env.<envVar>` reference property to an object expression when
+* the property is not already present. Existing values are left untouched.
+*/
+const addEnvReferenceProperty = (objExpr, key, envVar) => {
+	if (objExpr.properties.some((prop) => {
+		if (!prop?.key) return false;
+		return (prop.key.name ?? prop.key.value) === key;
+	})) return;
+	objExpr.properties.push(b.property("init", b.identifier(key), b.memberExpression(b.memberExpression(b.identifier("process"), b.identifier("env")), b.identifier(envVar))));
+};
+/**
+* Sets `routing.mode` in an Intlayer configuration file to the requested
+* strategy. Idempotent: re-running with the same mode produces identical
+* output. Supports `.ts`, `.mjs`, `.js` and `.cjs` configs; JSON configs are
+* handled with a scoped string replacement since they cannot be parsed by the
+* TypeScript recast parser.
+*/
+const setIntlayerConfigRoutingMode = (content, extension, mode) => {
+	if (extension === "json") return content.replace(/("mode"\s*:\s*)"(?:prefix-no-default|prefix-all|no-prefix|search-params)"/, `$1"${mode}"`);
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	genericRecastVisit(ast, (objExpr) => {
+		if (!isObjectExpression(objExpr)) return;
+		const routingProperty = ensureObjectProperty(objExpr, "routing", b.objectExpression([]));
+		if (!isObjectExpression(routingProperty.value)) return;
+		setObjectPropertyValue(routingProperty.value, "mode", b.stringLiteral(mode));
+	});
+	return recast.print(ast).code;
+};
+/**
+* Enables the Intlayer visual editor in a configuration file: sets
+* `editor.enabled` to `true` and wires `clientId` / `clientSecret` to the
+* `INTLAYER_CLIENT_ID` / `INTLAYER_CLIENT_SECRET` environment variables.
+* Idempotent and non-destructive — existing `clientId` / `clientSecret` values
+* are preserved. Only `.ts`, `.mjs`, `.js` and `.cjs` configs are supported
+* (JSON cannot reference `process.env`).
+*/
+const enableIntlayerEditorConfig = (content) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	genericRecastVisit(ast, (objExpr) => {
+		if (!isObjectExpression(objExpr)) return;
+		const editorProperty = ensureObjectProperty(objExpr, "editor", b.objectExpression([]));
+		if (!isObjectExpression(editorProperty.value)) return;
+		const editorObject = editorProperty.value;
+		setObjectPropertyValue(editorObject, "enabled", b.booleanLiteral(true));
+		addEnvReferenceProperty(editorObject, "clientId", "INTLAYER_CLIENT_ID");
+		addEnvReferenceProperty(editorObject, "clientSecret", "INTLAYER_CLIENT_SECRET");
+	});
+	return recast.print(ast).code;
+};
+const injectImport = (ast, isCJS, importName, source) => {
+	if (!isCJS && isModuleScopeBinding(ast, importName)) return;
+	if (ast.program.body.some((stmt) => {
+		if (isCJS) return n.VariableDeclaration.check(stmt) && stmt.declarations.some((decl) => n.VariableDeclarator.check(decl) && n.CallExpression.check(decl.init) && n.Identifier.check(decl.init.callee) && decl.init.callee.name === "require" && n.StringLiteral.check(decl.init.arguments[0]) && decl.init.arguments[0].value === source);
+		return n.ImportDeclaration.check(stmt) && (stmt.source.value === source || stmt.specifiers?.some((spec) => n.ImportSpecifier.check(spec) && spec.imported.name === importName || n.ImportDefaultSpecifier.check(spec) && spec.local?.name === importName));
+	})) return;
+	const declaration = isCJS ? b.variableDeclaration("const", [b.variableDeclarator(b.identifier(`{ ${importName} }`), b.callExpression(b.identifier("require"), [b.stringLiteral(source)]))]) : b.importDeclaration([b.importSpecifier(b.identifier(importName))], b.stringLiteral(source));
+	ast.program.body.unshift(declaration);
+};
+const updatePluginArray = (objExpr, propertyName, pluginName) => {
+	if (!objExpr || objExpr.type !== "ObjectExpression" && !n.ObjectExpression.check(objExpr)) return;
+	let prop = objExpr.properties.find((p) => {
+		if (!p?.key) return false;
+		return (p.key.name || p.key.value) === propertyName;
+	});
+	if (!prop) {
+		prop = b.property("init", b.identifier(propertyName), b.arrayExpression([]));
+		objExpr.properties.push(prop);
+	}
+	const arrayValue = prop.value;
+	if (arrayValue && (arrayValue.type === "ArrayExpression" || n.ArrayExpression.check(arrayValue))) {
+		if (!arrayValue.elements.some((el) => {
+			const callee = el?.callee;
+			if (!callee) return false;
+			const name = callee.name || callee.id?.name;
+			return name === pluginName || name === "il";
+		})) arrayValue.elements.push(b.callExpression(b.identifier(pluginName), []));
+	}
+};
+const genericRecastVisit = (ast, updateConfigObject, callNames = ["defineConfig"]) => {
+	/**
+	* Resolves an identifier reference (e.g. `export default config` /
+	* `module.exports = config`) back to the object expression it was declared
+	* with, then runs the updater on it.
+	*/
+	const resolveIdentifierConfig = (name) => {
+		ast.program.body.forEach((stmt) => {
+			if (n.VariableDeclaration.check(stmt)) stmt.declarations.forEach((vdecl) => {
+				if (n.VariableDeclarator.check(vdecl) && n.Identifier.check(vdecl.id) && vdecl.id.name === name && n.ObjectExpression.check(vdecl.init)) updateConfigObject(vdecl.init);
+			});
+		});
+	};
+	recast.visit(ast, {
+		visitExportDefaultDeclaration(path) {
+			const decl = path.node.declaration;
+			if (n.ObjectExpression.check(decl)) updateConfigObject(decl);
+			else if (n.CallExpression.check(decl) && n.Identifier.check(decl.callee) && callNames.includes(decl.callee.name)) {
+				if (n.ObjectExpression.check(decl.arguments[0])) updateConfigObject(decl.arguments[0]);
+			} else if (n.Identifier.check(decl)) resolveIdentifierConfig(decl.name);
+			return false;
+		},
+		visitAssignmentExpression(path) {
+			const { left, right } = path.node;
+			if (n.MemberExpression.check(left) && recast.print(left).code === "module.exports") {
+				if (n.ObjectExpression.check(right)) updateConfigObject(right);
+				else if (n.CallExpression.check(right) && n.Identifier.check(right.callee) && callNames.includes(right.callee.name)) {
+					if (n.ObjectExpression.check(right.arguments[0])) updateConfigObject(right.arguments[0]);
+				} else if (n.Identifier.check(right)) resolveIdentifierConfig(right.name);
+			}
+			return false;
+		}
+	});
+};
+const updateViteConfig = (content, extension) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	injectImport(ast, extension === "cjs" || content.includes("module.exports") && !content.includes("import "), "intlayer", "vite-intlayer");
+	genericRecastVisit(ast, (obj) => updatePluginArray(obj, "plugins", "intlayer"));
+	return recast.print(ast).code;
+};
+const updateAstroConfig = (content, extension) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	injectImport(ast, extension === "cjs" || content.includes("module.exports") && !content.includes("import "), "intlayer", "astro-intlayer");
+	genericRecastVisit(ast, (obj) => updatePluginArray(obj, "integrations", "intlayer"));
+	return recast.print(ast).code;
+};
+const updateNextConfig = (content, extension) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	injectImport(ast, extension === "cjs" || content.includes("module.exports"), "withIntlayer", "next-intlayer/server");
+	recast.visit(ast, {
+		visitExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (n.Expression.check(declaration) && !(n.CallExpression.check(declaration) && n.Identifier.check(declaration.callee) && declaration.callee.name === "withIntlayer")) path.get("declaration").replace(b.callExpression(b.identifier("withIntlayer"), [declaration]));
+			return false;
+		},
+		visitAssignmentExpression(path) {
+			const { left, right } = path.node;
+			if (n.MemberExpression.check(left) && recast.print(left).code === "module.exports" && !(n.CallExpression.check(right) && n.Identifier.check(right.callee) && right.callee.name === "withIntlayer")) path.get("right").replace(b.callExpression(b.identifier("withIntlayer"), [right]));
+			return false;
+		}
+	});
+	return recast.print(ast).code;
+};
+/**
+* Returns true when the expression looks like an Immediately Invoked Function
+* Expression (e.g. `(async () => { ... })()`). Such custom async exports cannot
+* be safely wrapped with the synchronous Metro helper, so they are skipped.
+*/
+const isImmediatelyInvokedFunction = (node) => n.CallExpression.check(node) && (n.ArrowFunctionExpression.check(node.callee) || n.FunctionExpression.check(node.callee));
+/**
+* Wraps a React Native Metro config's exported value with
+* `configMetroIntlayerSync` from `react-native-intlayer/metro`, injecting the
+* import. The synchronous helper is used because it wraps a plain config object
+* and needs no IIFE, making it safe to inject into existing configs without
+* restructuring them.
+*
+* Non-destructive: returns the content unchanged when the export is already
+* wrapped, when the Intlayer Metro plugin is already present, or when the export
+* is a custom async IIFE that cannot be wrapped synchronously. Callers should
+* compare the result with the input to detect the skipped case.
+*/
+const updateMetroConfig = (content, extension) => {
+	if (content.includes("react-native-intlayer")) return content;
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	const isCJSFile = extension === "cjs" || content.includes("module.exports") && !content.includes("import ");
+	const wrapperName = "configMetroIntlayerSync";
+	const isWrappable = (node) => n.Expression.check(node) && !isImmediatelyInvokedFunction(node) && !(n.CallExpression.check(node) && n.Identifier.check(node.callee) && node.callee.name === wrapperName);
+	let wrapped = false;
+	recast.visit(ast, {
+		visitExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (isWrappable(declaration)) {
+				path.get("declaration").replace(b.callExpression(b.identifier(wrapperName), [declaration]));
+				wrapped = true;
+			}
+			return false;
+		},
+		visitAssignmentExpression(path) {
+			const { left, right } = path.node;
+			if (n.MemberExpression.check(left) && recast.print(left).code === "module.exports" && isWrappable(right)) {
+				path.get("right").replace(b.callExpression(b.identifier(wrapperName), [right]));
+				wrapped = true;
+			}
+			return false;
+		}
+	});
+	if (!wrapped) return content;
+	injectImport(ast, isCJSFile, wrapperName, "react-native-intlayer/metro");
+	return recast.print(ast).code;
+};
+/**
+* Builds the contents of a fresh `metro.config.js` wired with the Intlayer
+* Metro plugin. Uses the async `configMetroIntlayer` helper (which can build
+* dictionaries on server start) and picks the default-config source based on
+* whether the project is an Expo app.
+*/
+const getMetroConfigTemplate = (isExpo) => {
+	return `const { getDefaultConfig } = require("${isExpo ? "expo/metro-config" : "@react-native/metro-config"}");
+const { configMetroIntlayer } = require("react-native-intlayer/metro");
+
+module.exports = (async () => {
+  const defaultConfig = getDefaultConfig(__dirname);
+
+  return await configMetroIntlayer(defaultConfig);
+})();
+`;
+};
+const updateNuxtConfig = (content) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	const updateConfigObject = (objExpr) => {
+		if (!objExpr || objExpr.type !== "ObjectExpression" && !n.ObjectExpression.check(objExpr)) return;
+		let modulesProp = objExpr.properties.find((p) => {
+			if (!p?.key) return false;
+			return (p.key.name || p.key.value) === "modules";
+		});
+		if (!modulesProp) {
+			modulesProp = b.property("init", b.identifier("modules"), b.arrayExpression([]));
+			objExpr.properties.push(modulesProp);
+		}
+		const modulesValue = modulesProp.value;
+		if (modulesValue && (modulesValue.type === "ArrayExpression" || n.ArrayExpression.check(modulesValue))) {
+			if (!modulesValue.elements.some((el) => {
+				if (n.StringLiteral.check(el) || el.type === "StringLiteral" || el.type === "Literal") return (el.value || el.extra?.rawValue) === "nuxt-intlayer";
+				return false;
+			})) modulesValue.elements.push(b.stringLiteral("nuxt-intlayer"));
+		}
+	};
+	genericRecastVisit(ast, updateConfigObject, ["defineNuxtConfig"]);
+	return recast.print(ast).code;
+};
+/**
+* Updates a Vite config for vue-i18n compat: injects `vueI18nVitePlugin` from
+* `@intlayer/vue-i18n/plugin` into the plugins array.
+*/
+const updateViteConfigForVueI18n = (content, extension) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	injectImport(ast, extension === "cjs" || content.includes("module.exports") && !content.includes("import "), "vueI18nVitePlugin", "@intlayer/vue-i18n/plugin");
+	genericRecastVisit(ast, (obj) => updatePluginArray(obj, "plugins", "vueI18nVitePlugin"));
+	return recast.print(ast).code;
+};
+/**
+* Generic vite config updater for any compat plugin that uses alias injection.
+* Injects the named import from `pluginPackageSource` and appends the plugin
+* call to the `plugins` array.
+*/
+const updateViteConfigForCompatPlugin = (content, extension, pluginConfig) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	injectImport(ast, extension === "cjs" || content.includes("module.exports") && !content.includes("import "), pluginConfig.pluginFunctionName, pluginConfig.pluginPackageSource);
+	genericRecastVisit(ast, (obj) => updatePluginArray(obj, "plugins", pluginConfig.pluginFunctionName));
+	return recast.print(ast).code;
+};
+/**
+* Rewrites the module source of an existing named import in a vite config,
+* keeping the imported binding and its call site untouched. Used when a compat
+* plugin is a drop-in replacement for an i18n library's own vite plugin — e.g.
+* lingui: `import { lingui } from "@lingui/vite-plugin"` becomes
+* `import { lingui } from "@intlayer/lingui/plugin"`, leaving `lingui()` in the
+* `plugins` array as-is. Returns the content unchanged when no matching import
+* is found.
+*/
+const replaceViteConfigPluginImportSource = (content, importName, fromPackageSource, toPackageSource) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	let changed = false;
+	recast.visit(ast, { visitImportDeclaration(path) {
+		const { source, specifiers } = path.node;
+		const importsBinding = (specifiers ?? []).some((specifier) => n.ImportSpecifier.check(specifier) && specifier.imported.name === importName);
+		if (n.StringLiteral.check(source) && source.value === fromPackageSource && importsBinding) {
+			source.value = toPackageSource;
+			changed = true;
+		}
+		return false;
+	} });
+	if (!changed) return content;
+	return recast.print(ast).code;
+};
+/**
+* Generic Next.js config wrapper for compat plugins. Injects the import and
+* wraps the default export / `module.exports` with a HOC call.
+*/
+const wrapNextConfigWithHoc = (content, extension, hocFunctionName, pluginPackageSource) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	injectImport(ast, extension === "cjs" || content.includes("module.exports"), hocFunctionName, pluginPackageSource);
+	recast.visit(ast, {
+		visitExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (n.Expression.check(declaration) && !(n.CallExpression.check(declaration) && n.Identifier.check(declaration.callee) && declaration.callee.name === hocFunctionName)) path.get("declaration").replace(b.callExpression(b.identifier(hocFunctionName), [declaration]));
+			return false;
+		},
+		visitAssignmentExpression(path) {
+			const { left, right } = path.node;
+			if (n.MemberExpression.check(left) && recast.print(left).code === "module.exports" && !(n.CallExpression.check(right) && n.Identifier.check(right.callee) && right.callee.name === hocFunctionName)) path.get("right").replace(b.callExpression(b.identifier(hocFunctionName), [right]));
+			return false;
+		}
+	});
+	return recast.print(ast).code;
+};
+/**
+* Updates a Next.js config for next-translate compat: wraps the default export
+* with `withNextTranslate` from `@intlayer/next-translate/plugin`.
+*/
+const updateNextConfigForNextTranslate = (content, extension) => wrapNextConfigWithHoc(content, extension, "withNextTranslate", "@intlayer/next-translate/plugin");
+/**
+* Updates a Nuxt config for nuxtjs-i18n compat: adds `@intlayer/nuxtjs-i18n`
+* to the `modules` array.
+*/
+const updateNuxtConfigForNuxtjsI18n = (content) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	const updateConfigObject = (objExpr) => {
+		if (!objExpr || objExpr.type !== "ObjectExpression" && !n.ObjectExpression.check(objExpr)) return;
+		let modulesProp = objExpr.properties.find((p) => {
+			if (!p?.key) return false;
+			return (p.key.name || p.key.value) === "modules";
+		});
+		if (!modulesProp) {
+			modulesProp = b.property("init", b.identifier("modules"), b.arrayExpression([]));
+			objExpr.properties.push(modulesProp);
+		}
+		const modulesValue = modulesProp.value;
+		if (modulesValue && (modulesValue.type === "ArrayExpression" || n.ArrayExpression.check(modulesValue))) {
+			if (!modulesValue.elements.some((el) => {
+				if (n.StringLiteral.check(el) || el.type === "StringLiteral" || el.type === "Literal") return (el.value ?? el.extra?.rawValue) === "@intlayer/nuxtjs-i18n";
+				return false;
+			})) modulesValue.elements.push(b.stringLiteral("@intlayer/nuxtjs-i18n"));
+		}
+	};
+	genericRecastVisit(ast, updateConfigObject, ["defineNuxtConfig"]);
+	return recast.print(ast).code;
+};
+/**
+* Updates a Next.js config for next-i18next compat: wraps the default export
+* with `withI18next` from `@intlayer/next-i18next/plugin`.
+*/
+const updateNextConfigForNextI18next = (content, extension) => wrapNextConfigWithHoc(content, extension, "withI18next", "@intlayer/next-i18next/plugin");
+/**
+* Updates a Next.js config for next-intl compat: replaces any existing
+* `next-intl/plugin` import source with `@intlayer/next-intl/plugin`, or
+* injects `createNextIntlPlugin` with a factory-call wrapper when no such
+* import is present.
+*/
+const updateNextConfigForNextIntl = (content, extension) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	const isCJSFile = extension === "cjs" || content.includes("module.exports");
+	let replacedExistingSource = false;
+	recast.visit(ast, { visitImportDeclaration(path) {
+		if (path.node.source.value === "next-intl/plugin") {
+			path.node.source = b.stringLiteral("@intlayer/next-intl/plugin");
+			replacedExistingSource = true;
+		}
+		return false;
+	} });
+	if (replacedExistingSource) return recast.print(ast).code;
+	if (ast.program.body.some((stmt) => {
+		if (!n.ImportDeclaration.check(stmt)) return false;
+		return (stmt.specifiers ?? []).some((spec) => n.ImportSpecifier.check(spec) && spec.imported.name === "createNextIntlPlugin" || n.ImportDefaultSpecifier.check(spec) && spec.local?.name === "createNextIntlPlugin");
+	})) return recast.print(ast).code;
+	injectImport(ast, isCJSFile, "createNextIntlPlugin", "@intlayer/next-intl/plugin");
+	const lastImportIndex = ast.program.body.reduce((lastIndex, stmt, index) => {
+		if (n.ImportDeclaration.check(stmt)) return index;
+		return lastIndex;
+	}, -1);
+	const factoryCallDeclaration = b.variableDeclaration("const", [b.variableDeclarator(b.identifier("_withNextIntlayer"), b.callExpression(b.identifier("createNextIntlPlugin"), []))]);
+	ast.program.body.splice(lastImportIndex + 1, 0, factoryCallDeclaration);
+	recast.visit(ast, {
+		visitExportDefaultDeclaration(path) {
+			const declaration = path.node.declaration;
+			if (n.Expression.check(declaration) && !(n.CallExpression.check(declaration) && n.Identifier.check(declaration.callee) && declaration.callee.name === "_withNextIntlayer")) path.get("declaration").replace(b.callExpression(b.identifier("_withNextIntlayer"), [declaration]));
+			return false;
+		},
+		visitAssignmentExpression(path) {
+			const { left, right } = path.node;
+			if (n.MemberExpression.check(left) && recast.print(left).code === "module.exports" && !(n.CallExpression.check(right) && n.Identifier.check(right.callee) && right.callee.name === "_withNextIntlayer")) path.get("right").replace(b.callExpression(b.identifier("_withNextIntlayer"), [right]));
+			return false;
+		}
+	});
+	return recast.print(ast).code;
+};
+/** Resolves the sync plugin (function + package) for a compat sync config. */
+const getSyncPluginInfo = (syncConfig) => syncConfig.plugin === "po" ? {
+	functionName: "syncPO",
+	packageSource: "@intlayer/sync-po-plugin"
+} : {
+	functionName: "syncJSON",
+	packageSource: "@intlayer/sync-json-plugin"
+};
+/**
+* Parses a `syncJSON({ ... })` / `syncPO({ ... })` call expression from a source
+* snippet so it can be injected into a config AST without manually constructing
+* template-literal nodes via builders.
+*
+* The destructuring parameters adapt to whether the source template uses the
+* `key` placeholder (nested pattern) or only `locale` (flat pattern).
+*/
+const buildSyncCallNode = (syncConfig) => {
+	const { functionName } = getSyncPluginInfo(syncConfig);
+	const paramDestructuring = !syncConfig.sourceTemplate.includes("${key}") ? "{ locale }" : syncConfig.format === "icu" || syncConfig.plugin === "po" ? "{ key, locale }" : "{ locale, key }";
+	const formatProperty = syncConfig.plugin === "po" ? "" : `format: '${syncConfig.format}', `;
+	const splitKeysProperty = syncConfig.splitKeys ? ", splitKeys: true" : "";
+	const snippet = `${functionName}({ ${formatProperty}source: (${paramDestructuring}) => \`${syncConfig.sourceTemplate}\`${splitKeysProperty} })`;
+	return recast.parse(snippet, { parser: __require("recast/parsers/typescript") }).program.body[0].expression;
+};
+/**
+* Injects or ensures `dictionary: { format: '<value>' }` exists in an object
+* expression.  Leaves any pre-existing `dictionary` properties untouched —
+* only the `format` sub-property is added when absent.
+*/
+const injectDictionaryFormat = (objExpr, format) => {
+	if (!objExpr || objExpr.type !== "ObjectExpression" && !n.ObjectExpression.check(objExpr)) return;
+	let dictionaryProp = objExpr.properties.find((prop) => {
+		if (!prop?.key) return false;
+		return (prop.key.name ?? prop.key.value) === "dictionary";
+	});
+	if (!dictionaryProp) {
+		dictionaryProp = b.property("init", b.identifier("dictionary"), b.objectExpression([]));
+		objExpr.properties.push(dictionaryProp);
+	}
+	const dictionaryObj = dictionaryProp.value;
+	if (!dictionaryObj || dictionaryObj.type !== "ObjectExpression" && !n.ObjectExpression.check(dictionaryObj)) return;
+	if (!dictionaryObj.properties.some((prop) => {
+		if (!prop?.key) return false;
+		return (prop.key.name ?? prop.key.value) === "format";
+	})) dictionaryObj.properties.push(b.property("init", b.identifier("format"), b.stringLiteral(format)));
+};
+/**
+* Injects the sync plugin import (`syncJSON` / `syncPO`) and a configured
+* `syncJSON(...)` / `syncPO(...)` call into the plugins array of an intlayer
+* config file. Idempotent: skips when the plugin call is already present.
+*/
+const updateIntlayerConfigWithSyncPlugin = (content, extension, syncConfig) => {
+	const ast = recast.parse(content, { parser: __require("recast/parsers/typescript") });
+	const isCJSFile = extension === "cjs" || content.includes("module.exports");
+	const { functionName, packageSource } = getSyncPluginInfo(syncConfig);
+	injectImport(ast, isCJSFile, functionName, packageSource);
+	const callNode = buildSyncCallNode(syncConfig);
+	const dictionaryFormat = syncConfig.plugin === "po" ? "po" : syncConfig.format;
+	genericRecastVisit(ast, (objExpr) => {
+		if (!objExpr || objExpr.type !== "ObjectExpression" && !n.ObjectExpression.check(objExpr)) return;
+		injectDictionaryFormat(objExpr, dictionaryFormat);
+		let pluginsProp = objExpr.properties.find((prop) => {
+			if (!prop?.key) return false;
+			return (prop.key.name ?? prop.key.value) === "plugins";
+		});
+		if (!pluginsProp) {
+			pluginsProp = b.property("init", b.identifier("plugins"), b.arrayExpression([]));
+			objExpr.properties.push(pluginsProp);
+		}
+		const arrayValue = pluginsProp.value;
+		if (arrayValue && (arrayValue.type === "ArrayExpression" || n.ArrayExpression.check(arrayValue))) {
+			if (!arrayValue.elements.some((element) => {
+				const callee = element?.callee;
+				if (!callee) return false;
+				return (callee.name ?? callee.id?.name) === functionName;
+			})) arrayValue.elements.push(callNode);
+		}
+	});
+	return recast.print(ast).code;
+};
+
+//#endregion
+export { enableIntlayerEditorConfig, getMetroConfigTemplate, replaceViteConfigPluginImportSource, setIntlayerConfigRoutingMode, updateAstroConfig, updateIntlayerConfigWithSyncPlugin, updateMetroConfig, updateNextConfig, updateNextConfigForNextI18next, updateNextConfigForNextIntl, updateNextConfigForNextTranslate, updateNuxtConfig, updateNuxtConfigForNuxtjsI18n, updateViteConfig, updateViteConfigForCompatPlugin, updateViteConfigForVueI18n };
+//# sourceMappingURL=configManipulation.mjs.map