@intlayer/engine 9.0.0-canary.12

package/dist/cjs/init/index.cjs

@@ -0,0 +1,521 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_init_utils_configManipulation = require('./utils/configManipulation.cjs');
+const require_init_utils_fileSystem = require('./utils/fileSystem.cjs');
+const require_init_cms = require('./cms.cjs');
+const require_initConfig_index = require('../initConfig/index.cjs');
+const require_init_frameworkSetup_index = require('./frameworkSetup/index.cjs');
+const require_init_utils_githubActions = require('./utils/githubActions.cjs');
+const require_init_utils_jsonParser = require('./utils/jsonParser.cjs');
+const require_init_utils_packageManager = require('./utils/packageManager.cjs');
+const require_init_utils_nextCompilerBabel = require('./utils/nextCompilerBabel.cjs');
+const require_init_utils_tsConfig = require('./utils/tsConfig.cjs');
+let node_path = require("node:path");
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_node = require("@intlayer/config/node");
+let _intlayer_config_utils = require("@intlayer/config/utils");
+let _intlayer_config_colors = require("@intlayer/config/colors");
+_intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
+
+//#region src/init/index.ts
+/**
+* Documentation URL Constants
+*/
+const DocumentationRouter = {
+	NextJS: "https://intlayer.org/doc/environment/nextjs.md",
+	NextJS_15: "https://intlayer.org/doc/environment/nextjs/15.md",
+	NextJS_14: "https://intlayer.org/doc/environment/nextjs/14.md",
+	CRA: "https://intlayer.org/doc/environment/create-react-app.md",
+	Astro: "https://intlayer.org/doc/environment/astro.md",
+	ViteAndReact: "https://intlayer.org/doc/environment/vite-and-react.md",
+	ViteAndReact_ReactRouterV7: "https://intlayer.org/doc/environment/vite-and-react/react-router-v7.md",
+	ViteAndReact_ReactRouterV7_FSRoutes: "https://intlayer.org/doc/environment/vite-and-react/react-router-v7-fs-routes.md",
+	ViteAndVue: "https://intlayer.org/doc/environment/vite-and-vue.md",
+	ViteAndSolid: "https://intlayer.org/doc/environment/vite-and-solid.md",
+	ViteAndSvelte: "https://intlayer.org/doc/environment/vite-and-svelte.md",
+	ViteAndPreact: "https://intlayer.org/doc/environment/vite-and-preact.md",
+	TanStackRouter: "https://intlayer.org/doc/environment/tanstack.md",
+	NuxtAndVue: "https://intlayer.org/doc/environment/nuxt-and-vue.md",
+	Angular: "https://intlayer.org/doc/environment/angular.md",
+	SvelteKit: "https://intlayer.org/doc/environment/sveltekit.md",
+	ReactNativeAndExpo: "https://intlayer.org/doc/environment/react-native-and-expo.md",
+	Lynx: "https://intlayer.org/doc/environment/lynx-and-react.md",
+	Express: "https://intlayer.org/doc/environment/express.md",
+	NestJS: "https://intlayer.org/doc/environment/nestjs.md",
+	Fastify: "https://intlayer.org/doc/environment/fastify.md",
+	Default: "https://intlayer.org/doc/get-started",
+	LSP: "https://intlayer.org/doc/lsp.md",
+	NextIntl: "https://intlayer.org/blog/intlayer-with-next-intl.md",
+	ReactI18Next: "https://intlayer.org/blog/intlayer-with-react-i18next.md",
+	ReactIntl: "https://intlayer.org/blog/intlayer-with-react-intl.md",
+	NextI18Next: "https://intlayer.org/blog/intlayer-with-next-i18next.md",
+	VueI18n: "https://intlayer.org/blog/intlayer-with-vue-i18n.md"
+};
+/**
+* Helper: Detects the environment and returns the doc URL
+*/
+const getDocumentationUrl = (packageJson) => {
+	const deps = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	};
+	/**
+	* Helper to check if a version string matches a specific major version
+	* Matches: "15", "^15.0.0", "~15.2", "15.0.0-beta"
+	*/
+	const isVersion = (versionString, major) => {
+		if (!versionString || typeof versionString !== "string") return false;
+		return new RegExp(`^[\\^~]?${major}(?:\\.|$)`).test(versionString);
+	};
+	if (deps["@lynx-js/react"] || deps["@lynx-js/core"]) return DocumentationRouter.Lynx;
+	if (deps["react-native"] || deps.expo) return DocumentationRouter.ReactNativeAndExpo;
+	if (deps.next) {
+		const version = deps.next;
+		if (isVersion(version, 14)) return DocumentationRouter.NextJS_14;
+		if (isVersion(version, 15)) return DocumentationRouter.NextJS_15;
+		return DocumentationRouter.NextJS;
+	}
+	if (deps.nuxt) return DocumentationRouter.NuxtAndVue;
+	if (deps.astro) return DocumentationRouter.Astro;
+	if (deps["@sveltejs/kit"]) return DocumentationRouter.SvelteKit;
+	if (deps["@tanstack/react-router"]) return DocumentationRouter.TanStackRouter;
+	const reactRouterVersion = deps["react-router"];
+	if (reactRouterVersion && typeof reactRouterVersion === "string") {
+		if (deps["@react-router/fs-routes"]) return DocumentationRouter.ViteAndReact_ReactRouterV7_FSRoutes;
+		if (isVersion(reactRouterVersion, 7)) return DocumentationRouter.ViteAndReact_ReactRouterV7;
+	}
+	if (deps.vite) {
+		if (deps.vue) return DocumentationRouter.ViteAndVue;
+		if (deps["solid-js"]) return DocumentationRouter.ViteAndSolid;
+		if (deps.svelte) return DocumentationRouter.ViteAndSvelte;
+		if (deps.preact) return DocumentationRouter.ViteAndPreact;
+		return DocumentationRouter.ViteAndReact;
+	}
+	if (deps["react-scripts"]) return DocumentationRouter.CRA;
+	if (deps["@angular/core"]) return DocumentationRouter.Angular;
+	if (deps["@nestjs/core"]) return DocumentationRouter.NestJS;
+	if (deps.express) return DocumentationRouter.Express;
+	if (deps.fastify) return DocumentationRouter.Fastify;
+	if (deps["next-intl"]) return DocumentationRouter.NextIntl;
+	if (deps["react-i18next"] || deps.i18next) return DocumentationRouter.ReactI18Next;
+	if (deps["react-intl"]) return DocumentationRouter.ReactIntl;
+	if (deps["next-i18next"]) return DocumentationRouter.NextI18Next;
+	if (deps["vue-i18n"]) return DocumentationRouter.VueI18n;
+	return DocumentationRouter.Default;
+};
+/**
+* MAIN LOGIC
+*/
+const initIntlayer = async (rootDir, options) => {
+	(0, _intlayer_config_logger.logger)((0, _intlayer_config_logger.colorize)("Checking Intlayer configuration...", _intlayer_config_colors.CYAN));
+	const packageJsonPath = "package.json";
+	if (!await require_init_utils_fileSystem.exists(rootDir, packageJsonPath)) {
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} No ${(0, _intlayer_config_logger.colorizePath)("package.json")} found. Please run this script from the project root.`, { level: "error" });
+		process.exit(1);
+	}
+	const packageJsonContent = await require_init_utils_fileSystem.readFileFromRoot(rootDir, packageJsonPath);
+	let packageJson;
+	try {
+		packageJson = JSON.parse(packageJsonContent);
+	} catch {
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not parse ${(0, _intlayer_config_logger.colorizePath)("package.json")}.`, { level: "error" });
+		process.exit(1);
+	}
+	const guideUrl = getDocumentationUrl(packageJson);
+	const allDeps = {
+		...packageJson.dependencies ?? {},
+		...packageJson.devDependencies ?? {}
+	};
+	const effectiveAllDeps = {
+		...allDeps,
+		...options?.hintDependencies ?? {}
+	};
+	const packageManager = require_init_utils_packageManager.detectPackageManager(rootDir);
+	const linguiPresent = Boolean(effectiveAllDeps["@lingui/core"] || effectiveAllDeps["@lingui/react"] || effectiveAllDeps["@intlayer/lingui"]);
+	const linguiCatalog = linguiPresent ? await require_init_utils_fileSystem.detectLinguiCatalogPattern(rootDir) : null;
+	const hintLinguiJson = Boolean(options?.hintDependencies?.["__lingui_json__"]);
+	const { packagesToInstall, devPackagesToInstall, compatSyncConfig, compatVitePluginConfig } = require_init_utils_packageManager.detectMissingIntlayerPackages(effectiveAllDeps, { linguiCatalogFormat: linguiCatalog?.format ?? (linguiPresent ? hintLinguiJson ? "json" : "po" : null) });
+	if (!options?.noInstallPackages) {
+		const withVersion = (packages) => options?.upgradeToVersion ? packages.map((pkg) => `${pkg}@${options.upgradeToVersion}`) : packages;
+		if (packagesToInstall.length > 0) {
+			(0, _intlayer_config_logger.logger)((0, _intlayer_config_logger.colorize)("Installing missing Intlayer dependencies...", _intlayer_config_colors.CYAN));
+			try {
+				require_init_utils_packageManager.installPackages(rootDir, withVersion(packagesToInstall), packageManager);
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Installed: ${packagesToInstall.map((pkg) => (0, _intlayer_config_logger.colorize)(pkg, _intlayer_config_colors.MAGENTA)).join(", ")}`);
+			} catch {
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Failed to install packages. Please install manually: ${packagesToInstall.join(" ")}`, { level: "warn" });
+			}
+		}
+		if (devPackagesToInstall.length > 0) {
+			(0, _intlayer_config_logger.logger)((0, _intlayer_config_logger.colorize)("Installing missing Intlayer dev dependencies...", _intlayer_config_colors.CYAN));
+			try {
+				require_init_utils_packageManager.installPackages(rootDir, withVersion(devPackagesToInstall), packageManager, true);
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Installed: ${devPackagesToInstall.map((pkg) => (0, _intlayer_config_logger.colorize)(pkg, _intlayer_config_colors.MAGENTA)).join(", ")}`);
+			} catch {
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Failed to install dev packages. Please install manually: ${devPackagesToInstall.join(" ")}`, { level: "warn" });
+			}
+		}
+		if (options?.upgradeToVersion) {
+			const outdatedDependencies = require_init_utils_packageManager.detectOutdatedIntlayerPackages(rootDir, packageJson.dependencies ?? {}, options.upgradeToVersion);
+			const outdatedDevDependencies = require_init_utils_packageManager.detectOutdatedIntlayerPackages(rootDir, packageJson.devDependencies ?? {}, options.upgradeToVersion);
+			const allOutdated = [...outdatedDependencies, ...outdatedDevDependencies];
+			if (allOutdated.length > 0) {
+				(0, _intlayer_config_logger.logger)((0, _intlayer_config_logger.colorize)(`Upgrading outdated Intlayer dependencies to ${options.upgradeToVersion}...`, _intlayer_config_colors.CYAN));
+				try {
+					require_init_utils_packageManager.upgradePackages(rootDir, outdatedDependencies, packageManager, options.upgradeToVersion);
+					require_init_utils_packageManager.upgradePackages(rootDir, outdatedDevDependencies, packageManager, options.upgradeToVersion, true);
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Upgraded: ${allOutdated.map((pkg) => (0, _intlayer_config_logger.colorize)(pkg, _intlayer_config_colors.MAGENTA)).join(", ")}`);
+				} catch {
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Failed to upgrade packages. Please upgrade manually: ${allOutdated.join(" ")}`, { level: "warn" });
+				}
+			} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Intlayer dependencies are up to date`);
+		}
+	}
+	const gitignorePath = ".gitignore";
+	if (!options?.noGitignore && await require_init_utils_fileSystem.exists(rootDir, gitignorePath)) {
+		const gitignoreContent = await require_init_utils_fileSystem.readFileFromRoot(rootDir, gitignorePath);
+		if (!gitignoreContent.includes("intlayer")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, gitignorePath, `${gitignoreContent}\n# Intlayer\n.intlayer\n`);
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Added ${(0, _intlayer_config_logger.colorizePath)(".intlayer")} to ${(0, _intlayer_config_logger.colorizePath)(gitignorePath)}`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(gitignorePath)} already includes .intlayer`);
+	}
+	if (!options?.noGithubActions) {
+		const workflows = require_init_utils_githubActions.getGithubWorkflows(packageManager);
+		for (const workflow of workflows) {
+			if (await require_init_utils_fileSystem.exists(rootDir, workflow.filePath)) {
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(workflow.filePath)} already exists`);
+				continue;
+			}
+			try {
+				await require_init_utils_fileSystem.ensureDirectory(rootDir, (0, node_path.join)(".github", "workflows"));
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, workflow.filePath, workflow.content);
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Added GitHub Actions workflow ${(0, _intlayer_config_logger.colorizePath)(workflow.filePath)}`);
+			} catch {
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not create ${(0, _intlayer_config_logger.colorizePath)(workflow.filePath)}. You may need to add it manually.`, { level: "warn" });
+			}
+		}
+	}
+	const vscodeDir = ".vscode";
+	const extensionsJsonPath = (0, node_path.join)(vscodeDir, "extensions.json");
+	const extensionId = "intlayer.intlayer-vs-code-extension";
+	if (!options?.noVscodeExtension) try {
+		let extensionsConfig = { recommendations: [] };
+		if (await require_init_utils_fileSystem.exists(rootDir, extensionsJsonPath)) extensionsConfig = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, extensionsJsonPath));
+		else await require_init_utils_fileSystem.ensureDirectory(rootDir, vscodeDir);
+		if (!extensionsConfig.recommendations) extensionsConfig.recommendations = [];
+		if (!extensionsConfig.recommendations.includes(extensionId)) {
+			extensionsConfig.recommendations.push(extensionId);
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, extensionsJsonPath, JSON.stringify(extensionsConfig, null, 2));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Added ${(0, _intlayer_config_logger.colorize)(extensionId, _intlayer_config_colors.MAGENTA)} to ${(0, _intlayer_config_logger.colorizePath)(extensionsJsonPath)}`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(extensionsJsonPath)} already includes ${(0, _intlayer_config_logger.colorize)(extensionId, _intlayer_config_colors.MAGENTA)}`);
+	} catch {
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not update ${(0, _intlayer_config_logger.colorizePath)(extensionsJsonPath)}. You may need to add ${(0, _intlayer_config_logger.colorize)(extensionId, _intlayer_config_colors.MAGENTA)} manually.`, { level: "warn" });
+	}
+	const settingsJsonPath = (0, node_path.join)(vscodeDir, "settings.json");
+	if (!options?.noLsp) try {
+		let settingsConfig = {};
+		if (await require_init_utils_fileSystem.exists(rootDir, settingsJsonPath)) settingsConfig = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, settingsJsonPath));
+		else await require_init_utils_fileSystem.ensureDirectory(rootDir, vscodeDir);
+		let settingsUpdated = false;
+		if (!settingsConfig["intlayer.languageServer.command"]) {
+			settingsConfig["intlayer.languageServer.command"] = "npx";
+			settingsUpdated = true;
+		}
+		if (!settingsConfig["intlayer.languageServer.args"]) {
+			settingsConfig["intlayer.languageServer.args"] = ["@intlayer/lsp"];
+			settingsUpdated = true;
+		}
+		if (settingsUpdated) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, settingsJsonPath, JSON.stringify(settingsConfig, null, 2));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(settingsJsonPath)} with LSP configuration`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(settingsJsonPath)} already includes LSP configuration`);
+	} catch {
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not update ${(0, _intlayer_config_logger.colorizePath)(settingsJsonPath)}. You may need to add the LSP settings manually.`, { level: "warn" });
+	}
+	const tsConfigFiles = await require_init_utils_tsConfig.findTsConfigFiles(rootDir);
+	let hasTsConfig = false;
+	for (const fileName of tsConfigFiles) if (await require_init_utils_fileSystem.exists(rootDir, fileName)) {
+		hasTsConfig = true;
+		try {
+			const config = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, fileName));
+			const typeDefinition = "./.intlayer/**/*.ts";
+			let updated = false;
+			if (!config.include) {} else if (Array.isArray(config.include) && !config.include.some((pattern) => pattern.includes(".intlayer"))) {
+				config.include.push(typeDefinition);
+				updated = true;
+			} else if (config.include.includes(typeDefinition)) (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(fileName)} already includes intlayer types`);
+			if (updated) {
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, fileName, JSON.stringify(config, null, 2));
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(fileName)} to include intlayer types`);
+			}
+		} catch {
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not parse or update ${(0, _intlayer_config_logger.colorizePath)(fileName)}. You may need to add ${(0, _intlayer_config_logger.colorizePath)(".intlayer/types/**/*.ts")} manually.`, { level: "warn" });
+		}
+	}
+	const format = hasTsConfig ? "intlayer.config.ts" : "intlayer.config.mjs";
+	const detectedPattern = await require_init_utils_fileSystem.detectJsonLocalePattern(rootDir);
+	await require_initConfig_index.initConfig(format, rootDir, detectedPattern?.locales);
+	if (compatSyncConfig) {
+		const nextIntlMessagesPattern = allDeps["next-intl"] || allDeps["@intlayer/next-intl"] || allDeps["use-intl"] || allDeps["@intlayer/use-intl"] ? await require_init_utils_fileSystem.detectNextIntlMessagesPattern(rootDir) : null;
+		const sourceTemplate = linguiCatalog?.template ?? nextIntlMessagesPattern?.template ?? detectedPattern?.template;
+		const resolvedSyncConfig = {
+			...compatSyncConfig,
+			...sourceTemplate ? { sourceTemplate } : {}
+		};
+		const syncPluginPackage = resolvedSyncConfig.plugin === "po" ? "@intlayer/sync-po-plugin" : "@intlayer/sync-json-plugin";
+		const syncPluginName = resolvedSyncConfig.plugin === "po" ? "syncPO" : "syncJSON";
+		if (resolvedSyncConfig.splitKeys && resolvedSyncConfig.sourceTemplate.includes("${key}")) resolvedSyncConfig.splitKeys = false;
+		for (const configFile of [
+			"intlayer.config.ts",
+			"intlayer.config.mjs",
+			"intlayer.config.js",
+			"intlayer.config.cjs"
+		]) if (await require_init_utils_fileSystem.exists(rootDir, configFile)) {
+			const configContent = await require_init_utils_fileSystem.readFileFromRoot(rootDir, configFile);
+			if (!configContent.includes(syncPluginPackage)) {
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, configFile, require_init_utils_configManipulation.updateIntlayerConfigWithSyncPlugin(configContent, configFile.split(".").pop(), resolvedSyncConfig));
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(configFile)} with ${syncPluginName} compat plugin`);
+			} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(configFile)} already includes ${syncPluginName} plugin`);
+			break;
+		}
+	}
+	if (options?.routingMode) await require_init_cms.setRoutingModeInConfig(rootDir, options.routingMode);
+	let hasAliasConfiguration = false;
+	for (const file of [
+		"vite.config.ts",
+		"vite.config.js",
+		"vite.config.mjs"
+	]) if (await require_init_utils_fileSystem.exists(rootDir, file)) {
+		hasAliasConfiguration = true;
+		const content = await require_init_utils_fileSystem.readFileFromRoot(rootDir, file);
+		const extension = file.split(".").pop();
+		if (compatVitePluginConfig) {
+			const { replacesVitePlugin } = compatVitePluginConfig;
+			if (content.includes(compatVitePluginConfig.pluginPackageSource)) (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(file)} already includes ${compatVitePluginConfig.pluginPackageSource}`);
+			else if (replacesVitePlugin && content.includes(replacesVitePlugin.fromPackageSource)) {
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.replaceViteConfigPluginImportSource(content, replacesVitePlugin.importName, replacesVitePlugin.fromPackageSource, compatVitePluginConfig.pluginPackageSource));
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to import ${replacesVitePlugin.importName} from ${compatVitePluginConfig.pluginPackageSource}`);
+			} else {
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateViteConfigForCompatPlugin(content, extension, compatVitePluginConfig));
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include ${compatVitePluginConfig.pluginFunctionName} compat plugin`);
+			}
+		} else if (!content.includes("vite-intlayer")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateViteConfig(content, extension));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer plugin`);
+		}
+		break;
+	}
+	const nextConfigs = [
+		"next.config.js",
+		"next.config.mjs",
+		"next.config.ts"
+	];
+	let isNextJsProject = false;
+	for (const file of nextConfigs) if (await require_init_utils_fileSystem.exists(rootDir, file)) {
+		isNextJsProject = true;
+		hasAliasConfiguration = true;
+		const content = await require_init_utils_fileSystem.readFileFromRoot(rootDir, file);
+		const extension = file.split(".").pop();
+		if (allDeps["next-i18next"]) if (!content.includes("@intlayer/next-i18next")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateNextConfigForNextI18next(content, extension));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer next-i18next compat plugin`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(file)} already includes @intlayer/next-i18next`);
+		else if (allDeps["next-intl"]) if (!content.includes("@intlayer/next-intl/plugin")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateNextConfigForNextIntl(content, extension));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer next-intl compat plugin`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(file)} already includes @intlayer/next-intl/plugin`);
+		else if (allDeps["next-translate"]) if (!content.includes("@intlayer/next-translate")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateNextConfigForNextTranslate(content, extension));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer next-translate compat plugin`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(file)} already includes @intlayer/next-translate`);
+		else if (!content.includes("next-intlayer")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateNextConfig(content, extension));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer plugin`);
+		}
+		break;
+	}
+	if (isNextJsProject) await require_init_utils_nextCompilerBabel.setupNextCompilerBabelConfig({
+		rootDir,
+		packageManager,
+		allDeps,
+		skipInstall: Boolean(options?.noInstallPackages)
+	});
+	for (const file of [
+		"astro.config.mjs",
+		"astro.config.js",
+		"astro.config.ts",
+		"astro.config.cjs"
+	]) if (await require_init_utils_fileSystem.exists(rootDir, file)) {
+		hasAliasConfiguration = true;
+		if (file.startsWith("astro.config.")) {
+			const content = await require_init_utils_fileSystem.readFileFromRoot(rootDir, file);
+			if (!content.includes("astro-intlayer")) {
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateAstroConfig(content, file.split(".").pop()));
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer integration`);
+			}
+		}
+		break;
+	}
+	for (const file of ["nuxt.config.js", "nuxt.config.ts"]) if (await require_init_utils_fileSystem.exists(rootDir, file)) {
+		hasAliasConfiguration = true;
+		const content = await require_init_utils_fileSystem.readFileFromRoot(rootDir, file);
+		if (allDeps["@nuxtjs/i18n"]) if (!content.includes("@intlayer/nuxtjs-i18n")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateNuxtConfigForNuxtjsI18n(content));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include @intlayer/nuxtjs-i18n module`);
+		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(file)} already includes @intlayer/nuxtjs-i18n`);
+		else if (!content.includes("nuxt-intlayer")) {
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, file, require_init_utils_configManipulation.updateNuxtConfig(content));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(file)} to include Intlayer module`);
+		}
+		break;
+	}
+	if (Boolean(allDeps["react-native"] || allDeps.expo)) {
+		hasAliasConfiguration = true;
+		const metroConfigs = [
+			"metro.config.js",
+			"metro.config.cjs",
+			"metro.config.mjs",
+			"metro.config.ts"
+		];
+		let metroConfigFile;
+		for (const file of metroConfigs) if (await require_init_utils_fileSystem.exists(rootDir, file)) {
+			metroConfigFile = file;
+			break;
+		}
+		if (metroConfigFile) {
+			const content = await require_init_utils_fileSystem.readFileFromRoot(rootDir, metroConfigFile);
+			if (content.includes("react-native-intlayer")) (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(metroConfigFile)} already includes the Intlayer Metro plugin`);
+			else {
+				const updatedContent = require_init_utils_configManipulation.updateMetroConfig(content, metroConfigFile.split(".").pop());
+				if (updatedContent !== content) {
+					await require_init_utils_fileSystem.writeFileToRoot(rootDir, metroConfigFile, updatedContent);
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(metroConfigFile)} to include the Intlayer Metro plugin`);
+				} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not automatically update ${(0, _intlayer_config_logger.colorizePath)(metroConfigFile)}. Wrap your exported config with ${(0, _intlayer_config_logger.colorize)("configMetroIntlayer", _intlayer_config_colors.MAGENTA)}: ${(0, _intlayer_config_logger.colorizePath)(DocumentationRouter.ReactNativeAndExpo)}`, { level: "warn" });
+			}
+		} else {
+			const newMetroConfigFile = "metro.config.js";
+			await require_init_utils_fileSystem.writeFileToRoot(rootDir, newMetroConfigFile, require_init_utils_configManipulation.getMetroConfigTemplate(Boolean(allDeps.expo)));
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Created ${(0, _intlayer_config_logger.colorizePath)(newMetroConfigFile)} with the Intlayer Metro plugin`);
+		}
+	}
+	const isVersionGreaterOrEqual = (versionString, major) => {
+		if (!versionString || typeof versionString !== "string") return false;
+		const match = versionString.match(/^[^\d]*(\d+)/);
+		if (!match?.[1]) return false;
+		return parseInt(match[1], 10) >= major;
+	};
+	const backendIntlayerPackages = [
+		"express-intlayer",
+		"fastify-intlayer",
+		"adonis-intlayer",
+		"hono-intlayer"
+	];
+	const devScript = packageJson.scripts?.dev;
+	let newDevScript;
+	if ((isNextJsProject && allDeps.next && isVersionGreaterOrEqual(allDeps.next, 16) || backendIntlayerPackages.some((pkg) => allDeps[pkg])) && !devScript.includes("intlayer watch")) newDevScript = `intlayer watch --with '${devScript}'`;
+	if (newDevScript) {
+		packageJson.scripts.dev = newDevScript;
+		await require_init_utils_fileSystem.writeFileToRoot(rootDir, packageJsonPath, JSON.stringify(packageJson, null, 2));
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)("package.json")} dev script to run intlayer watch`);
+	}
+	for (const file of [
+		"webpack.config.js",
+		"webpack.config.ts",
+		"webpack.config.mjs",
+		"webpack.config.cjs"
+	]) if (await require_init_utils_fileSystem.exists(rootDir, file)) {
+		hasAliasConfiguration = true;
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Found ${(0, _intlayer_config_logger.colorizePath)(file)}. Make sure to configure aliases manually or use the Intlayer Webpack plugin.`);
+		break;
+	}
+	if ([
+		"express",
+		"fastify",
+		"@adonisjs/core",
+		"hono",
+		...backendIntlayerPackages
+	].some((pkg) => allDeps[pkg])) hasAliasConfiguration = true;
+	if (!hasAliasConfiguration) {
+		const aliases = (0, _intlayer_config_utils.getAlias)({ configuration: (0, _intlayer_config_node.getConfiguration)({ baseDir: rootDir }) });
+		if (hasTsConfig && tsConfigFiles.length > 0) {
+			const tsConfigPath = tsConfigFiles.find((file) => file === "tsconfig.json") || tsConfigFiles[0];
+			if (tsConfigPath) {
+				const config = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, tsConfigPath));
+				config.compilerOptions ??= {};
+				config.compilerOptions.paths ??= {};
+				let updated = false;
+				Object.entries(aliases).forEach(([alias, path]) => {
+					if (!config.compilerOptions.paths[alias]) {
+						config.compilerOptions.paths[alias] = [path];
+						updated = true;
+					}
+				});
+				if (updated) {
+					await require_init_utils_fileSystem.writeFileToRoot(rootDir, tsConfigPath, JSON.stringify(config, null, 2));
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(tsConfigPath)} to include Intlayer aliases`);
+				}
+			}
+		} else {
+			const jsConfigPath = "jsconfig.json";
+			if (await require_init_utils_fileSystem.exists(rootDir, jsConfigPath)) {
+				const config = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, jsConfigPath));
+				config.compilerOptions ??= {};
+				config.compilerOptions.paths ??= {};
+				let updated = false;
+				Object.entries(aliases).forEach(([alias, path]) => {
+					if (!config.compilerOptions.paths[alias]) {
+						config.compilerOptions.paths[alias] = [path];
+						updated = true;
+					}
+				});
+				if (updated) {
+					await require_init_utils_fileSystem.writeFileToRoot(rootDir, jsConfigPath, JSON.stringify(config, null, 2));
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(jsConfigPath)} to include Intlayer aliases`);
+				}
+			} else {
+				packageJson.imports ??= {};
+				let updated = false;
+				Object.entries(aliases).forEach(([alias, path]) => {
+					const importAlias = alias.replace("@", "#");
+					const importPath = path.startsWith(".") ? path : `./${path}`;
+					if (!packageJson.imports[importAlias]) {
+						packageJson.imports[importAlias] = importPath;
+						updated = true;
+					}
+				});
+				if (updated) {
+					await require_init_utils_fileSystem.writeFileToRoot(rootDir, packageJsonPath, JSON.stringify(packageJson, null, 2));
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(packageJsonPath)} to include Intlayer imports`);
+				}
+			}
+		}
+	}
+	if (!options?.noFrameworkSetup) try {
+		const routingMode = options?.routingMode ?? (0, _intlayer_config_node.getConfiguration)({ baseDir: rootDir }).routing.mode;
+		await require_init_frameworkSetup_index.setupFramework({
+			rootDir,
+			allDeps,
+			packageManager,
+			useTypeScript: hasTsConfig,
+			routingMode
+		});
+	} catch {
+		(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Framework-specific scaffolding failed. Your existing files were left untouched; follow the documentation to finish the setup.`, { level: "warn" });
+	}
+	(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorize)("Intlayer init setup complete.", _intlayer_config_colors.GREEN)}`);
+	(0, _intlayer_config_logger.logger)([
+		(0, _intlayer_config_logger.colorize)("Next →", _intlayer_config_colors.MAGENTA),
+		(0, _intlayer_config_logger.colorize)(`Follow the instructions in the documentation to complete the setup:`, _intlayer_config_colors.GREY_LIGHT),
+		(0, _intlayer_config_logger.colorizePath)(guideUrl)
+	]);
+	(0, _intlayer_config_logger.logger)([
+		(0, _intlayer_config_logger.colorize)("Intlayer LSP →", _intlayer_config_colors.MAGENTA),
+		(0, _intlayer_config_logger.colorize)("The Intlayer Language Server is available via the `@intlayer/lsp` package. It lets IDEs and AI agents jump from `useIntlayer`/`getIntlayer` keys to their `.content` files.", _intlayer_config_colors.GREY_LIGHT),
+		(0, _intlayer_config_logger.colorize)("Ask the user which platform/editor they want to enable it on (VS Code, Cursor, Windsurf, Zed, Neovim, Claude Code, …), then follow the matching setup instructions:", _intlayer_config_colors.GREY_LIGHT),
+		(0, _intlayer_config_logger.colorizePath)(DocumentationRouter.LSP)
+	]);
+};
+
+//#endregion
+exports.initIntlayer = initIntlayer;
+//# sourceMappingURL=index.cjs.map