@intlayer/babel 9.4.4 → 9.5.1

package/dist/esm/babel-plugin-intlayer-optimize.mjs

@@ -1,8 +1,9 @@
+import { readStaticString } from "./staticAstReaders.mjs";
+import { createDictionaryImportRegistry } from "./dictionaryImports.mjs";
 import { getNormalizedFilesListSet } from "./normalizedFilesList.mjs";
+import { createCompatOptimizePass } from "./compat/optimizePass.mjs";
 import { dirname, join, relative } from "node:path";
-import { getPathHash } from "@intlayer/engine/utils";
 import { normalizePath } from "@intlayer/config/utils";
-import { getRewritableCallers } from "@intlayer/config/callers";
 
 //#region src/babel-plugin-intlayer-optimize.ts
 const PACKAGE_LIST = [
@@ -28,10 +29,10 @@ const CALLER_LIST = [
 	"getIntlayer",
 	"getIntlayerAsync"
 ];
-/**
-* Packages that support dynamic import
-*/
-const PACKAGE_LIST_DYNAMIC = [
+/** Membership sets for the tables above — hit once per import and per call. */
+const NATIVE_PACKAGE_SET = new Set(PACKAGE_LIST);
+const CALLER_NAME_SET = new Set(CALLER_LIST);
+const DYNAMIC_PACKAGE_SET = /* @__PURE__ */ new Set([
 	"react-intlayer",
 	"react-intlayer/client",
 	"react-intlayer/server",
@@ -45,7 +46,7 @@ const PACKAGE_LIST_DYNAMIC = [
 	"angular-intlayer",
 	"lit-intlayer",
 	"vanilla-intlayer"
-];
+]);
 const STATIC_IMPORT_FUNCTION = {
 	getIntlayer: "getDictionary",
 	getIntlayerAsync: "getDictionaryAsync",
@@ -66,15 +67,6 @@ const DYNAMIC_HELPER_MAP = {
 */
 const SSR_STATIC_IMPORT_SOURCE = { "solid-intlayer": "solid-intlayer/server" };
 /**
-* Replicates the xxHash64 → Base-62 algorithm used by the SWC version
-* and prefixes an underscore so the generated identifiers never collide
-* with user-defined ones.
-*/
-const makeIdent = (key, t) => {
-	const hash = getPathHash(key);
-	return t.identifier(`_${hash}`);
-};
-/**
 * Builds the module specifier pointing at `targetPath` from `fromFile`, with
 * forward slashes and an explicit `./` prefix so bundlers never treat it as a
 * bare package specifier.
@@ -96,66 +88,26 @@ const computeImport = (fromFile, dictionariesDir, dynamicDictionariesDir, fetchD
 	if (importMode === "dynamic") dictionaryPath = join(dynamicDictionariesDir, `${key}.mjs`);
 	return toRelativeSpecifier(fromFile, dictionaryPath);
 };
-const getKeyFromArgument = (arg, t) => {
-	if (arg && t.isStringLiteral(arg)) return arg.value;
-	if (arg && t.isTemplateLiteral(arg) && arg.expressions.length === 0 && arg.quasis.length === 1) return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;
-};
-const isCallerName = (name) => CALLER_LIST.includes(name);
+const isCallerName = (name) => CALLER_NAME_SET.has(name);
+const isDynamicPackage = (packageName) => DYNAMIC_PACKAGE_SET.has(packageName);
+/** The name an import specifier brings in, whether written as an identifier or a string. */
+const importedSpecifierName = (babelTypes, specifier) => babelTypes.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+const EMPTY_KEY_SET = /* @__PURE__ */ new Set();
 /**
-* Splits a namespace string at the first `.` to separate the dictionary key
-* from an optional key prefix for nested namespaces, mirroring the SWC
-* plugin's `split_namespace`.
-*
-*   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`
-*   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`
+* `nestingDictionaryKeys` as a set, cached by array reference: Babel reuses one
+* options object for the whole build, so the set is built once instead of once
+* per transformed file.
 */
-const splitNamespace = (namespace) => {
-	const dotPosition = namespace.indexOf(".");
-	if (dotPosition === -1) return {
-		dictionaryKey: namespace,
-		keyPrefix: ""
-	};
-	return {
-		dictionaryKey: namespace.slice(0, dotPosition),
-		keyPrefix: namespace.slice(dotPosition + 1)
-	};
-};
-/**
-* Statically resolves the namespace of a compat caller call-site from its
-* descriptor's `namespaceSources` (argument / option / fixed — the
-* per-message-id `path-first-segment` form cannot bind one dictionary to the
-* call site and is skipped). Returns `undefined` when the namespace is absent
-* or dynamic, in which case the call is left untouched and resolves through
-* the runtime dictionary registry.
-*/
-const resolveCompatNamespaceMatch = (t, callArguments, descriptor) => {
-	for (const source of descriptor.namespaceSources) {
-		if (source.from === "fixed") return { fullNamespace: source.value };
-		if (source.from === "argument") {
-			const namespace = getKeyFromArgument(callArguments[source.index], t);
-			if (namespace !== void 0) return {
-				fullNamespace: namespace,
-				argumentIndex: source.index
-			};
-			continue;
-		}
-		if (source.from === "option") {
-			const optionsArgument = callArguments[source.argumentIndex];
-			if (!optionsArgument || !t.isObjectExpression(optionsArgument)) continue;
-			for (const property of optionsArgument.properties) {
-				if (!t.isObjectProperty(property)) continue;
-				if (!(t.isIdentifier(property.key) && property.key.name === source.property || t.isStringLiteral(property.key) && property.key.value === source.property)) continue;
-				const namespace = getKeyFromArgument(property.value, t);
-				if (namespace !== void 0) return {
-					fullNamespace: namespace,
-					optionProperty: property,
-					optionsObject: optionsArgument
-				};
-			}
-		}
+const nestingKeysCache = /* @__PURE__ */ new WeakMap();
+const getNestingDictionaryKeySet = (nestingDictionaryKeys) => {
+	if (!nestingDictionaryKeys) return EMPTY_KEY_SET;
+	let keySet = nestingKeysCache.get(nestingDictionaryKeys);
+	if (!keySet) {
+		keySet = new Set(nestingDictionaryKeys);
+		nestingKeysCache.set(nestingDictionaryKeys, keySet);
 	}
+	return keySet;
 };
-const isDynamicPackage = (packageName) => PACKAGE_LIST_DYNAMIC.includes(packageName);
 /**
 * Decides, once per package import, which helper family applies to this file.
 * The import rewrite and the per-call rewrite must both derive from this
@@ -171,6 +123,29 @@ const resolveHelperPlan = (packageName, importMode, isServer, packageHasDynamicC
 	return "static";
 };
 /**
+* Builds the dictionary import declarations the rewrite accumulated for one
+* file — the compiled JSON (or its `nest()` companion) for static reads, and
+* the generated per-locale loader for dynamic and fetch ones.
+*/
+const buildDictionaryImportDeclarations = (babelTypes, state, imports) => {
+	const { dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, nestingDictionaryKeys } = state.opts;
+	const fromFile = state.file.opts.filename;
+	const nestingKeys = getNestingDictionaryKeySet(nestingDictionaryKeys);
+	const importDeclarations = [];
+	for (const [key, ident] of imports.staticImports) {
+		const hasNestedDictionaries = nestingKeys.has(key);
+		const specifier = computeImport(fromFile, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, "static", hasNestedDictionaries);
+		const importDeclaration = babelTypes.importDeclaration([babelTypes.importDefaultSpecifier(babelTypes.identifier(ident.name))], babelTypes.stringLiteral(specifier));
+		if (!hasNestedDictionaries) importDeclaration.attributes = [babelTypes.importAttribute(babelTypes.identifier("type"), babelTypes.stringLiteral("json"))];
+		importDeclarations.push(importDeclaration);
+	}
+	for (const [key, ident] of imports.dynamicImports) {
+		const mode = ident.name.endsWith("_fetch") ? "fetch" : "dynamic";
+		importDeclarations.push(babelTypes.importDeclaration([babelTypes.importDefaultSpecifier(babelTypes.identifier(ident.name))], babelTypes.stringLiteral(computeImport(fromFile, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, mode))));
+	}
+	return importDeclarations;
+};
+/**
 * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.
 *
 * This plugin transforms calls to `useIntlayer()`, `getIntlayer()` and
@@ -271,13 +246,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 	return {
 		name: "babel-plugin-intlayer-transform",
 		pre() {
-			this._newStaticImports = /* @__PURE__ */ new Map();
-			this._newDynamicImports = /* @__PURE__ */ new Map();
-			this._callerMap = /* @__PURE__ */ new Map();
-			this._callerPackageMap = /* @__PURE__ */ new Map();
-			this._compatCallerMap = /* @__PURE__ */ new Map();
 			this._isIncluded = true;
-			this._hasValidImport = false;
 			this._isDictEntry = false;
 			if (this.opts.optimize === false) {
 				this._isIncluded = false;
@@ -295,16 +264,9 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			enter(programPath, state) {
 				const filename = state.file.opts.filename ? normalizePath(state.file.opts.filename) : void 0;
 				const dictionariesEntryPath = state.opts.dictionariesEntryPath ? normalizePath(state.opts.dictionariesEntryPath) : void 0;
-				if (state.opts.replaceDictionaryEntry && filename === dictionariesEntryPath) {
+				if (state.opts.replaceDictionaryEntry && filename && filename === dictionariesEntryPath) {
 					state._isDictEntry = true;
-					programPath.traverse({
-						ImportDeclaration(path) {
-							path.remove();
-						},
-						VariableDeclarator(path) {
-							if (t.isObjectExpression(path.node.init)) path.node.init.properties = [];
-						}
-					});
+					programPath.node.body = [t.exportDefaultDeclaration(t.objectExpression([])), t.exportNamedDeclaration(t.variableDeclaration("const", [t.variableDeclarator(t.identifier("getDictionaries"), t.arrowFunctionExpression([], t.objectExpression([])))]))];
 				}
 			},
 			/**
@@ -318,215 +280,142 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			exit(programPath, state) {
 				if (state._isDictEntry) return;
 				if (!state._isIncluded) return;
-				const rewritableCompatCallers = getRewritableCallers(state.opts.compatCallers ?? []);
-				programPath.traverse({ ImportDeclaration(path) {
-					const src = path.node.source.value;
-					const isNativePackage = PACKAGE_LIST.includes(src);
-					const compatCallersForSource = rewritableCompatCallers.filter((descriptor) => descriptor.importSources.includes(src));
-					if (!isNativePackage && compatCallersForSource.length === 0) return;
-					state._hasValidImport = true;
-					for (const spec of path.node.specifiers) {
+				const imports = createDictionaryImportRegistry(t);
+				const compat = createCompatOptimizePass(t, state.opts.compatCallers ?? [], imports, {
+					importMode: state.opts.importMode,
+					dictionaryModeMap: state.opts.dictionaryModeMap
+				});
+				const programBody = programPath.node.body;
+				const nativeImportNodes = [];
+				const compatImportNodes = [];
+				/** Local alias → the native caller it was imported as. */
+				const callerMap = /* @__PURE__ */ new Map();
+				/** Local alias → the intlayer package it was imported from. */
+				const callerPackageMap = /* @__PURE__ */ new Map();
+				/** Whether the file imported any native or compat caller at all. */
+				let hasValidImport = false;
+				for (const statement of programBody) {
+					if (!t.isImportDeclaration(statement)) continue;
+					const src = statement.source.value;
+					const isNativePackage = NATIVE_PACKAGE_SET.has(src);
+					const isCompatPackage = compat?.ownsImportSource(src) ?? false;
+					if (!isNativePackage && !isCompatPackage) continue;
+					hasValidImport = true;
+					if (isNativePackage) nativeImportNodes.push(statement);
+					if (isCompatPackage) compatImportNodes.push(statement);
+					for (const spec of statement.specifiers) {
 						if (!t.isImportSpecifier(spec)) continue;
-						const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+						const importedName = importedSpecifierName(t, spec);
 						if (isNativePackage && isCallerName(importedName)) {
-							state._callerMap?.set(spec.local.name, importedName);
-							state._callerPackageMap?.set(spec.local.name, src);
+							callerMap.set(spec.local.name, importedName);
+							callerPackageMap.set(spec.local.name, src);
 						}
-						const compatDescriptor = compatCallersForSource.find((descriptor) => descriptor.callerName === importedName);
-						if (compatDescriptor) state._compatCallerMap?.set(spec.local.name, compatDescriptor);
+						if (isCompatPackage) compat?.noteImport(src, importedName, spec.local.name);
 					}
+				}
+				const nativeCallNodes = [];
+				const compatCallNodes = [];
+				if (callerMap.size > 0 || compat?.hasCallers()) programPath.traverse({ CallExpression(path) {
+					const callee = path.node.callee;
+					if (!t.isIdentifier(callee)) return;
+					if (callerMap.has(callee.name)) nativeCallNodes.push(path.node);
+					else if (compat?.ownsLocalName(callee.name)) compatCallNodes.push(path.node);
 				} });
 				const packagesWithDynamicCall = /* @__PURE__ */ new Set();
 				const packagesWithFetchCall = /* @__PURE__ */ new Set();
-				let compatHasDynamicCall = false;
-				const unresolvableCompatLocalNames = /* @__PURE__ */ new Set();
-				programPath.traverse({ CallExpression(path) {
-					const callee = path.node.callee;
-					if (!t.isIdentifier(callee)) return;
-					const compatDescriptor = state._compatCallerMap?.get(callee.name);
-					if (compatDescriptor) {
-						const namespaceMatch = resolveCompatNamespaceMatch(t, path.node.arguments, compatDescriptor);
-						if (!namespaceMatch) {
-							unresolvableCompatLocalNames.add(callee.name);
-							return;
+				for (const callNode of nativeCallNodes) {
+					const callee = callNode.callee;
+					if (callerMap.get(callee.name) !== "useIntlayer") continue;
+					const callerPackage = callerPackageMap.get(callee.name);
+					if (!callerPackage) continue;
+					const key = readStaticString(t, callNode.arguments[0]);
+					if (!key) continue;
+					const overrideMode = state.opts.dictionaryModeMap?.[key];
+					if (overrideMode === "dynamic") packagesWithDynamicCall.add(callerPackage);
+					else if (overrideMode === "fetch") packagesWithFetchCall.add(callerPackage);
+				}
+				compat?.analyzeCalls(compatCallNodes);
+				const helperPlanCache = /* @__PURE__ */ new Map();
+				const getHelperPlan = (packageName) => {
+					let plan = helperPlanCache.get(packageName);
+					if (plan === void 0) {
+						plan = resolveHelperPlan(packageName, state.opts.importMode, state.opts.isServer, packagesWithDynamicCall.has(packageName), packagesWithFetchCall.has(packageName));
+						helperPlanCache.set(packageName, plan);
+					}
+					return plan;
+				};
+				const serverImportsByAnchor = /* @__PURE__ */ new Map();
+				const emptiedImportNodes = /* @__PURE__ */ new Set();
+				for (const importNode of compatImportNodes) compat?.rewriteImportSpecifiers(importNode);
+				for (const importNode of nativeImportNodes) {
+					const helperPlan = getHelperPlan(importNode.source.value);
+					const serverSource = helperPlan === "ssrStatic" ? SSR_STATIC_IMPORT_SOURCE[importNode.source.value] : void 0;
+					const helperMap = helperPlan === "dynamic" ? DYNAMIC_HELPER_MAP : STATIC_IMPORT_FUNCTION;
+					const serverSpecifiers = [];
+					for (const spec of importNode.specifiers) {
+						if (!t.isImportSpecifier(spec)) continue;
+						const importedName = importedSpecifierName(t, spec);
+						if (!isCallerName(importedName)) continue;
+						if (serverSource && importedName === "useIntlayer") {
+							spec.imported = t.identifier("useDictionary");
+							serverSpecifiers.push(spec);
+							continue;
 						}
-						const { dictionaryKey } = splitNamespace(namespaceMatch.fullNamespace);
-						const compatOverrideMode = state.opts.dictionaryModeMap?.[dictionaryKey];
-						if (compatOverrideMode === "dynamic" || compatOverrideMode === "fetch") compatHasDynamicCall = true;
-						return;
+						const newIdentifier = helperMap[importedName];
+						if (newIdentifier) spec.imported = t.identifier(newIdentifier);
 					}
-					if (state._callerMap?.get(callee.name) !== "useIntlayer") return;
-					const callerPackage = state._callerPackageMap?.get(callee.name);
-					if (!callerPackage) return;
-					const key = getKeyFromArgument(path.node.arguments[0], t);
-					if (!key) return;
+					if (serverSpecifiers.length > 0 && serverSource) {
+						serverImportsByAnchor.set(importNode, t.importDeclaration(serverSpecifiers, t.stringLiteral(serverSource)));
+						const serverSpecifierSet = new Set(serverSpecifiers);
+						importNode.specifiers = importNode.specifiers.filter((spec) => !serverSpecifierSet.has(spec));
+						if (importNode.specifiers.length === 0) emptiedImportNodes.add(importNode);
+					}
+				}
+				for (const callNode of compatCallNodes) compat?.rewriteCall(callNode);
+				for (const callNode of nativeCallNodes) {
+					const callee = callNode.callee;
+					const originalImportedName = callerMap.get(callee.name);
+					const key = readStaticString(t, callNode.arguments[0]);
+					if (!key) continue;
+					const callerPackage = callerPackageMap.get(callee.name);
+					const importMode = state.opts.importMode;
+					const isUseIntlayer = originalImportedName === "useIntlayer";
+					const isGetIntlayerAsync = originalImportedName === "getIntlayerAsync";
 					const dictionaryOverrideMode = state.opts.dictionaryModeMap?.[key];
-					if (dictionaryOverrideMode === "dynamic") packagesWithDynamicCall.add(callerPackage);
-					else if (dictionaryOverrideMode === "fetch") packagesWithFetchCall.add(callerPackage);
-				} });
-				for (const localName of unresolvableCompatLocalNames) state._compatCallerMap?.delete(localName);
-				const getHelperPlan = (packageName) => resolveHelperPlan(packageName, state.opts.importMode, state.opts.isServer, packagesWithDynamicCall.has(packageName), packagesWithFetchCall.has(packageName));
-				const compatUseDynamicHelpers = state.opts.importMode === "dynamic" || state.opts.importMode === "fetch" || compatHasDynamicCall;
-				programPath.traverse({
-					ImportDeclaration(path) {
-						const src = path.node.source.value;
-						for (const spec of path.node.specifiers) {
-							if (!t.isImportSpecifier(spec)) continue;
-							const compatDescriptor = state._compatCallerMap?.get(spec.local.name);
-							if (!compatDescriptor) continue;
-							if (!compatDescriptor.importSources.includes(src)) continue;
-							spec.imported = t.identifier(compatUseDynamicHelpers ? compatDescriptor.dynamicReplacement : compatDescriptor.staticReplacement);
-						}
-						if (!PACKAGE_LIST.includes(src)) return;
-						const helperPlan = getHelperPlan(src);
-						const serverSource = helperPlan === "ssrStatic" ? SSR_STATIC_IMPORT_SOURCE[src] : void 0;
-						const helperMap = helperPlan === "dynamic" ? DYNAMIC_HELPER_MAP : STATIC_IMPORT_FUNCTION;
-						const serverSpecifiers = [];
-						for (const spec of path.node.specifiers) {
-							if (!t.isImportSpecifier(spec)) continue;
-							const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-							if (!isCallerName(importedName)) continue;
-							if (serverSource && importedName === "useIntlayer") {
-								spec.imported = t.identifier("useDictionary");
-								serverSpecifiers.push(spec);
-								continue;
-							}
-							const newIdentifier = helperMap[importedName];
-							if (newIdentifier) spec.imported = t.identifier(newIdentifier);
-						}
-						if (serverSpecifiers.length > 0 && serverSource) {
-							path.insertAfter(t.importDeclaration(serverSpecifiers, t.stringLiteral(serverSource)));
-							path.node.specifiers = path.node.specifiers.filter((spec) => !serverSpecifiers.includes(spec));
-							if (path.node.specifiers.length === 0) path.remove();
-						}
-					},
-					CallExpression(path) {
-						const callee = path.node.callee;
-						if (!t.isIdentifier(callee)) return;
-						const compatDescriptor = state._compatCallerMap?.get(callee.name);
-						if (compatDescriptor) {
-							const callArguments = path.node.arguments;
-							const namespaceMatch = resolveCompatNamespaceMatch(t, callArguments, compatDescriptor);
-							if (!namespaceMatch) return;
-							state._hasValidImport = true;
-							const { dictionaryKey, keyPrefix } = splitNamespace(namespaceMatch.fullNamespace);
-							const compatOverrideMode = state.opts.dictionaryModeMap?.[dictionaryKey];
-							let compatCallMode = "static";
-							if (compatUseDynamicHelpers) {
-								if (compatOverrideMode === "dynamic" || compatOverrideMode === "fetch") compatCallMode = compatOverrideMode;
-								else if (state.opts.importMode === "dynamic" || state.opts.importMode === "fetch") compatCallMode = state.opts.importMode;
-								else compatCallMode = "dynamic";
-							}
-							let dictionaryIdent;
-							if (compatCallMode === "static") {
-								let staticIdent = state._newStaticImports?.get(dictionaryKey);
-								if (!staticIdent) {
-									staticIdent = makeIdent(dictionaryKey, t);
-									state._newStaticImports?.set(dictionaryKey, staticIdent);
-								}
-								dictionaryIdent = staticIdent;
-							} else {
-								let dynamicIdent = state._newDynamicImports?.get(dictionaryKey);
-								if (!dynamicIdent) {
-									const hash = getPathHash(dictionaryKey);
-									const suffix = compatCallMode === "fetch" ? "fetch" : "dyn";
-									dynamicIdent = t.identifier(`_${hash}_${suffix}`);
-									state._newDynamicImports?.set(dictionaryKey, dynamicIdent);
-								}
-								dictionaryIdent = dynamicIdent;
-							}
-							if (namespaceMatch.argumentIndex !== void 0) {
-								callArguments[namespaceMatch.argumentIndex] = t.identifier(dictionaryIdent.name);
-								const insertAt = namespaceMatch.argumentIndex + 1;
-								const insertedArguments = [];
-								if (compatCallMode !== "static") insertedArguments.push(t.stringLiteral(dictionaryKey));
-								if (keyPrefix) insertedArguments.push(t.stringLiteral(keyPrefix));
-								callArguments.splice(insertAt, 0, ...insertedArguments);
-							} else if (compatCallMode !== "static") callArguments.unshift(t.identifier(dictionaryIdent.name), t.stringLiteral(dictionaryKey));
-							else callArguments.unshift(t.identifier(dictionaryIdent.name));
-							if (namespaceMatch.optionProperty && namespaceMatch.optionsObject) {
-								if (keyPrefix) namespaceMatch.optionProperty.value = t.stringLiteral(keyPrefix);
-								else namespaceMatch.optionsObject.properties = namespaceMatch.optionsObject.properties.filter((property) => property !== namespaceMatch.optionProperty);
-							}
-							return;
-						}
-						const originalImportedName = state._callerMap?.get(callee.name);
-						if (!originalImportedName) return;
-						state._hasValidImport = true;
-						const key = getKeyFromArgument(path.node.arguments[0], t);
-						if (!key) return;
-						const callerPackage = state._callerPackageMap?.get(callee.name);
-						const importMode = state.opts.importMode;
-						const isUseIntlayer = originalImportedName === "useIntlayer";
-						const isGetIntlayerAsync = originalImportedName === "getIntlayerAsync";
-						const dictionaryOverrideMode = state.opts.dictionaryModeMap?.[key];
-						const helperPlan = callerPackage === void 0 ? "static" : getHelperPlan(callerPackage);
-						let perCallMode = "static";
-						if (isGetIntlayerAsync) perCallMode = dictionaryOverrideMode === "fetch" ? "fetch" : "dynamic";
-						else if (isUseIntlayer && helperPlan === "dynamic") {
-							if (dictionaryOverrideMode) perCallMode = dictionaryOverrideMode;
-							else if (importMode === "dynamic" || importMode === "fetch") perCallMode = importMode;
-						} else if (isUseIntlayer && helperPlan === "static") {
-							if (dictionaryOverrideMode === "dynamic" || dictionaryOverrideMode === "fetch") perCallMode = dictionaryOverrideMode;
-						}
-						let ident;
-						if (perCallMode === "fetch") {
-							let dynamicIdent = state._newDynamicImports?.get(key);
-							if (!dynamicIdent) {
-								const hash = getPathHash(key);
-								dynamicIdent = t.identifier(`_${hash}_fetch`);
-								state._newDynamicImports?.set(key, dynamicIdent);
-							}
-							ident = dynamicIdent;
-							path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
-						} else if (perCallMode === "dynamic") {
-							let dynamicIdent = state._newDynamicImports?.get(key);
-							if (!dynamicIdent) {
-								const hash = getPathHash(key);
-								dynamicIdent = t.identifier(`_${hash}_dyn`);
-								state._newDynamicImports?.set(key, dynamicIdent);
-							}
-							ident = dynamicIdent;
-							path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
-						} else {
-							let staticIdent = state._newStaticImports?.get(key);
-							if (!staticIdent) {
-								staticIdent = makeIdent(key, t);
-								state._newStaticImports?.set(key, staticIdent);
-							}
-							ident = staticIdent;
-							path.node.arguments[0] = t.identifier(ident.name);
-						}
+					const helperPlan = callerPackage === void 0 ? "static" : getHelperPlan(callerPackage);
+					let perCallMode = "static";
+					if (isGetIntlayerAsync) perCallMode = dictionaryOverrideMode === "fetch" ? "fetch" : "dynamic";
+					else if (isUseIntlayer && helperPlan === "dynamic") {
+						if (dictionaryOverrideMode) perCallMode = dictionaryOverrideMode;
+						else if (importMode === "dynamic" || importMode === "fetch") perCallMode = importMode;
+					} else if (isUseIntlayer && helperPlan === "static") {
+						if (dictionaryOverrideMode === "dynamic" || dictionaryOverrideMode === "fetch") perCallMode = dictionaryOverrideMode;
 					}
-				});
-				if (!state._hasValidImport) return;
-				const file = state.file.opts.filename;
-				const dictionariesDir = state.opts.dictionariesDir;
-				const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;
-				const fetchDictionariesDir = state.opts.fetchDictionariesDir;
-				const imports = [];
-				const nestingDictionaryKeys = new Set(state.opts.nestingDictionaryKeys ?? []);
-				for (const [key, ident] of state._newStaticImports) {
-					const hasNestedDictionaries = nestingDictionaryKeys.has(key);
-					const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, "static", hasNestedDictionaries);
-					const importDeclarationNode = t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel));
-					if (!hasNestedDictionaries) importDeclarationNode.attributes = [t.importAttribute(t.identifier("type"), t.stringLiteral("json"))];
-					imports.push(importDeclarationNode);
+					const ident = imports.identFor(key, perCallMode);
+					if (perCallMode === "static") callNode.arguments[0] = t.identifier(ident.name);
+					else callNode.arguments = [t.identifier(ident.name), ...callNode.arguments];
 				}
-				for (const [key, ident] of state._newDynamicImports) {
-					const modeForThisIdent = ident.name.endsWith("_fetch") ? "fetch" : "dynamic";
-					const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, modeForThisIdent);
-					imports.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel)));
+				const dictionaryImports = hasValidImport ? buildDictionaryImportDeclarations(t, state, imports) : [];
+				const hasImportMoves = serverImportsByAnchor.size > 0 || emptiedImportNodes.size > 0;
+				if (dictionaryImports.length === 0 && !hasImportMoves) return;
+				const nextBody = [];
+				for (const statement of programBody) {
+					if (t.isImportDeclaration(statement) && emptiedImportNodes.has(statement)) {
+						const serverImport = serverImportsByAnchor.get(statement);
+						if (serverImport) nextBody.push(serverImport);
+						continue;
+					}
+					nextBody.push(statement);
+					if (t.isImportDeclaration(statement)) {
+						const serverImport = serverImportsByAnchor.get(statement);
+						if (serverImport) nextBody.push(serverImport);
+					}
 				}
-				if (!imports.length) return;
-				const bodyPaths = programPath.get("body");
 				let insertPos = 0;
-				for (const stmtPath of bodyPaths) {
-					const stmt = stmtPath.node;
-					if (t.isExpressionStatement(stmt) && t.isStringLiteral(stmt.expression) && !stmt.expression.value.startsWith("import") && !stmt.expression.value.startsWith("require")) insertPos += 1;
-					else break;
-				}
-				programPath.node.body.splice(insertPos, 0, ...imports);
+				for (const statement of nextBody) if (t.isExpressionStatement(statement) && t.isStringLiteral(statement.expression) && !statement.expression.value.startsWith("import") && !statement.expression.value.startsWith("require")) insertPos += 1;
+				else break;
+				nextBody.splice(insertPos, 0, ...dictionaryImports);
+				programPath.node.body = nextBody;
 			}
 		} }
 	};