@intlayer/babel 9.4.4 → 9.5.0

package/dist/types/compat/usageAnalysis.d.ts

@@ -0,0 +1,75 @@
+import { PruneContext } from "../pruneContext.js";
+import { NodePath } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+import { CallerDescriptor } from "@intlayer/config/callers";
+//#region src/compat/usageAnalysis.d.ts
+/**
+ * Analyses how the translation function produced by a compat namespace caller
+ * (`useTranslation`, `useTranslations`, `getTranslations`, `getFixedT`,
+ * `useI18n`) is consumed, then records the accessed top-level dictionary fields
+ * into `pruneContext`.
+ *
+ * Dictionaries consumed this way are always added to
+ * `dictionariesSkippingFieldRename`: the field accesses are string-literal
+ * dot-paths inside `t()` calls, which the field-rename plugin cannot rewrite,
+ * so renaming the compiled JSON keys would break runtime lookups. Pruning
+ * (top-level field removal) remains safe because it preserves field names.
+ */
+export declare const analyzeNamespaceCallerUsage: (babelTypes: typeof BabelTypes, pruneContext: PruneContext, callArguments: BabelTypes.CallExpression['arguments'], callerConfig: CallerDescriptor, isSfcFile: boolean,
+/** Absolute path of the analysed file (for untracked-binding reporting). */
+currentSourceFilePath: string,
+/**
+ * The call-expression path, when the caller was matched as a call. Omitted
+ * for JSX-element matches (`<FormattedMessage id>`), where only the static
+ * `'self'` / `'all'` analysis paths apply — the binding-based
+ * `'destructured-t'` / `'return-value'` paths require a call site.
+ */
+callExpressionPath?: NodePath<BabelTypes.CallExpression>,
+/**
+ * Pre-resolved namespace bypassing `namespaceSources`, e.g. the `ns`
+ * attribute of react-i18next's `<Trans ns="home" i18nKey="title" />`.
+ */
+namespaceOverride?: string) => void;
+/**
+ * Compat half of the usage analyser, kept behind one object so the native
+ * plugin body contains no adapter-specific branching.
+ *
+ * The analyser is created only when compat callers were injected, so a plain
+ * intlayer build never allocates it and never pays for its lookups —
+ * {@link createCompatUsageAnalyzer} returns `null` for an empty registry.
+ */
+export type CompatUsageAnalyzer = {
+  /**
+   * Records the local aliases one import declaration introduces. Called for
+   * every import of the file, before any call site is inspected.
+   */
+  noteImport: (importSource: string, importedName: string, localName: string) => void;
+  /**
+   * Whether any compat caller can match in this file — either an imported
+   * alias was recorded, or a method-matched caller is active. Checked after
+   * every import was noted, so the plugin can skip the call traversal.
+   */
+  hasMatchableCallers: () => boolean;
+  /**
+   * Analyses one call site. Returns `true` when the call belonged to a compat
+   * caller and was handled, `false` when the native path should look at it.
+   */
+  analyzeCall: (callExpressionPath: NodePath<BabelTypes.CallExpression>, localCallerName: string, isMethodCall: boolean) => boolean;
+  /** Analyses one JSX element, e.g. `<Trans i18nKey="…" />`. */
+  analyzeJsxElement: (jsxOpeningElementPath: NodePath<BabelTypes.JSXOpeningElement>) => void;
+};
+/**
+ * Builds the compat analyser for one source file, or `null` when no compat
+ * caller was injected — the base intlayer pipeline then runs untouched.
+ *
+ * @param babelTypes - Babel's type helpers.
+ * @param pruneContext - Shared analysis state to write into.
+ * @param compatCallers - Descriptors injected by the compat packages' plugins.
+ * @param fileContext - Path of the analysed file and whether it is an SFC.
+ */
+export declare const createCompatUsageAnalyzer: (babelTypes: typeof BabelTypes, pruneContext: PruneContext, compatCallers: readonly CallerDescriptor[], fileContext: {
+  sourceFilePath: string;
+  isSfcFile: boolean;
+}) => CompatUsageAnalyzer | null;
+//#endregion
+//# sourceMappingURL=usageAnalysis.d.ts.map

package/dist/types/compat/usageAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usageAnalysis.d.ts","names":[],"sources":["../../../src/compat/usageAnalysis.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAgCa,8BAA2B,mBACnB,YAAU,cACf,cAAY,eACX,WAAW,6BAA2B,cACvC,kBAAgB,oBAGP;;AAAA,+BAOF;;;;;;;AAAA,qBAAA,SAAS,WAAW,iBAKrB;;;;;AAAA;;;;;;;;;YAgRV;;;;;EAKV,aACE,sBACA,sBACA;;;;;;EAOF;;;;;EAKA,cACE,oBAAoB,SAAS,WAAW,iBACxC,yBACA;;EAGF,oBACE,uBAAuB,SAAS,WAAW;;;;;;;;;;;qBAalC,4BAAyB,mBACjB,YAAU,cACf,cAAY,wBACF,oBAAkB;EAC3B;EAAwB;MACtC"}

package/dist/types/dictionaryImports.d.ts

@@ -0,0 +1,46 @@
+import * as BabelTypes from "@babel/types";
+//#region src/dictionaryImports.d.ts
+/**
+ * How a dictionary reaches a call site.
+ *
+ * - `static`  — the compiled JSON is imported directly.
+ * - `dynamic` — a generated per-locale loader is imported and resolved at
+ *               runtime (Suspense).
+ * - `fetch`   — same as `dynamic`, but the loader fetches remote content.
+ */
+export type ImportMode = 'static' | 'dynamic' | 'fetch';
+/**
+ * Builds the generated identifier for a dictionary key.
+ *
+ * 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.
+ */
+export declare const makeDictionaryIdent: (babelTypes: typeof BabelTypes, key: string, mode: ImportMode) => BabelTypes.Identifier;
+/**
+ * The dictionary imports one file needs, accumulated while its call sites are
+ * rewritten and injected in one pass at the end.
+ *
+ * Both the native and the compat rewrites write here, so a dictionary read
+ * through `useIntlayer('about')` and through `useTranslation('about')` in the
+ * same file shares a single import.
+ *
+ * `dynamic` and `fetch` share one map because they occupy the same import
+ * slot, distinguished only by their identifier suffix — mirroring
+ * `InjectedImports` in the SWC plugin.
+ */
+export type DictionaryImportRegistry = {
+  /** Dictionary key → identifier of the static JSON (or nested companion) import. */
+  readonly staticImports: Map<string, BabelTypes.Identifier>;
+  /** Dictionary key → identifier of the dynamic / fetch loader import. */
+  readonly dynamicImports: Map<string, BabelTypes.Identifier>;
+  /**
+   * Returns the identifier for `key` in `mode`, creating and registering it on
+   * first use.
+   */
+  identFor: (key: string, mode: ImportMode) => BabelTypes.Identifier;
+};
+/** Creates an empty registry for one source file. */
+export declare const createDictionaryImportRegistry: (babelTypes: typeof BabelTypes) => DictionaryImportRegistry;
+//#endregion
+//# sourceMappingURL=dictionaryImports.d.ts.map

package/dist/types/dictionaryImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionaryImports.d.ts","names":[],"sources":["../../src/dictionaryImports.ts"],"mappings":";;;;;;;;;;YAWY;;;;;;;;qBAgBC,sBAAmB,mBACX,YAAU,aAClB,MACL,eACL,WAAW;;;;;;;;;;;;;YAeF;;WAED,eAAe,YAAY,WAAW;;WAEtC,gBAAgB,YAAY,WAAW;;;;;EAKhD,WAAW,aAAa,MAAM,eAAe,WAAW;;;qBAI7C,iCAA8B,mBACtB,eAClB"}

package/dist/types/index.d.ts

@@ -1,6 +1,9 @@
+import { DictionaryFieldUsage, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, preserveNestedDictionaryFields } from "./pruneContext.js";
 import { PackageName, SERVER_CAPABLE_PACKAGES, packageList } from "./extractContent/utils/constants.js";
 import { ExtractPluginOptions, ExtractResult, intlayerExtractBabelPlugin } from "./babel-plugin-intlayer-extract.js";
-import { CHAINABLE_RUNTIME_METHOD_NAMES, CallerDescriptor, CallerResultShape, CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields, unwrapAwait } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { CHAINABLE_RUNTIME_METHOD_NAMES, INTLAYER_CALLER_NAMES, IntlayerCallerName, NATIVE_CALLER_NAME_SET } from "./nativeCallers.js";
+import { unwrapAwait } from "./staticAstReaders.js";
+import { CallerDescriptor, CallerResultShape, CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { SerializedFieldRenameEntry, SerializedFieldRenameMap, buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses, serializeFieldRenameMap } from "./babel-plugin-intlayer-field-rename.js";
 import { MinifyPluginOptions, intlayerMinifyBabelPlugin } from "./babel-plugin-intlayer-minify.js";
 import { OptimizePluginOptions, intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.js";
@@ -18,4 +21,4 @@ import { CompilerMode, getExtractPluginOptions } from "./getExtractPluginOptions
 import { getOptimizePluginOptions } from "./getOptimizePluginOptions.js";
 import { getMinifyPluginOptions, getPurgePluginOptions } from "./getPurgePluginOptions.js";
 import { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, getUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile } from "./transformers.js";
-export { BABEL_PARSER_OPTIONS, CHAINABLE_RUNTIME_METHOD_NAMES, type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, CompilerMode, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, ExtractDictionaryInfoOptions, ExtractIntlayerOptions, ExtractPluginOptions, ExtractResult, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, IntlayerCallerName, MinifyPluginOptions, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, OptimizePluginOptions, PackageName, PruneContext, PurgePluginOptions, ResolveContentFilePaths, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, ScriptBlock, SerializedFieldRenameEntry, SerializedFieldRenameMap, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, buildUsageCheckRegex, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getMinifyPluginOptions, getNestedRenameEntryAtPath, getOptimizePluginOptions, getOutput, getPurgePluginOptions, getSharedPruneContext, getUsageCheckRegex, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerMinifyBabelPlugin, intlayerOptimizeBabelPlugin, intlayerPurgeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, preserveNestedDictionaryFields, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, runIntlayerPurgePipeline, serializeFieldRenameMap, unwrapAwait, writeContentHelper };
+export { BABEL_PARSER_OPTIONS, CHAINABLE_RUNTIME_METHOD_NAMES, type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, CompilerMode, DEFAULT_COMPAT_CALLERS, type DictionaryFieldUsage, ExtractDictionaryInfoOptions, ExtractIntlayerOptions, ExtractPluginOptions, ExtractResult, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, type IntlayerCallerName, MinifyPluginOptions, NATIVE_CALLER_NAME_SET, type NestedRenameEntry, type NestedRenameMap, type OpaqueFieldOccurrence, OptimizePluginOptions, PackageName, type PruneContext, PurgePluginOptions, ResolveContentFilePaths, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, ScriptBlock, SerializedFieldRenameEntry, SerializedFieldRenameMap, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, buildUsageCheckRegex, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getMinifyPluginOptions, getNestedRenameEntryAtPath, getOptimizePluginOptions, getOutput, getPurgePluginOptions, getSharedPruneContext, getUsageCheckRegex, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerMinifyBabelPlugin, intlayerOptimizeBabelPlugin, intlayerPurgeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, preserveNestedDictionaryFields, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, runIntlayerPurgePipeline, serializeFieldRenameMap, unwrapAwait, writeContentHelper };

package/dist/types/nativeCallers.d.ts

@@ -0,0 +1,33 @@
+//#region src/nativeCallers.d.ts
+/**
+ * The intlayer getters the build pipeline recognises without any adapter, and
+ * the runtime methods their result carries.
+ *
+ * Kept apart from the compat registry (`@intlayer/config/callers`) so the
+ * native passes never have to reason about adapter descriptors.
+ */
+/** Canonical intlayer caller names that trigger usage analysis. */
+export declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer', 'getIntlayerAsync'];
+export type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
+/**
+ * {@link INTLAYER_CALLER_NAMES} as a set — the import scan tests every
+ * specifier of every file against it, so membership must not be a linear scan.
+ */
+export declare const NATIVE_CALLER_NAME_SET: ReadonlySet<string>;
+/**
+ * Methods the runtime attaches to a resolved content object rather than fields
+ * declared in a `.content` file.
+ *
+ * `vanilla-intlayer`'s `useIntlayer` / `useDictionary` assign `onChange` onto
+ * the content they return, so `useIntlayer('app').onChange(cb)` is a
+ * subscription — not a read of a field named `onChange`. Without this list the
+ * analyser records `onChange` as the only consumed field and the purge pass
+ * strips every real field from the compiled dictionary.
+ *
+ * The analyser looks *through* these calls: the callback parameter is analysed
+ * as a fresh content root, and the call result is analysed again because the
+ * helpers return the content object for chaining.
+ */
+export declare const CHAINABLE_RUNTIME_METHOD_NAMES: Set<string>;
+//#endregion
+//# sourceMappingURL=nativeCallers.d.ts.map

package/dist/types/nativeCallers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeCallers.d.ts","names":[],"sources":["../../src/nativeCallers.ts"],"mappings":";;;;;;;;;qBASa;YAMD,6BAA6B;;;;;qBAM5B,wBAAwB;;;;;;;;;;;;;;;qBAkBxB,gCAA8B"}

package/dist/types/pruneContext.d.ts

@@ -0,0 +1,152 @@
+import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
+//#region src/pruneContext.d.ts
+/**
+ * Dictionary field usage result for a single dictionary key.
+ *
+ *   'all'        → could not determine statically which fields are used;
+ *                  keep every field (no pruning possible).
+ *   Set<string>  → the exact top-level content field names that were accessed.
+ */
+export type DictionaryFieldUsage = Set<string> | 'all';
+/**
+ * One node in the nested field-rename tree.
+ *
+ *   shortName – the compact alias assigned to this field name.
+ *   children  – rename table for the next level of user-defined keys inside
+ *               this field's value (empty when the value is a leaf / primitive).
+ */
+export type NestedRenameEntry = {
+  shortName: string;
+  children: NestedRenameMap;
+};
+/** A level of the field-rename tree, mapping original field names to entries. */
+export type NestedRenameMap = Map<string, NestedRenameEntry>;
+/**
+ * One opaque consumption of a dictionary content value: the value at
+ * `fieldPath` escapes static analysis (passed as-is to a child component or a
+ * function argument), so its children must keep their original key names in
+ * the compiled JSON.
+ */
+export type OpaqueFieldOccurrence = {
+  /**
+   * Original (pre-rename) user-defined field names from the content root to
+   * the escaping value, e.g. `['sections', 'hero']` for
+   * `<Card data={content.sections.hero} />`.
+   */
+  fieldPath: string[];
+  /** Source locations (`filePath:line`) where the value escapes. */
+  locations: string[];
+};
+/**
+ * Shared mutable state created once by the vite plugin and passed by reference
+ * to the usage-analyzer (writer) and the prune/minify plugins (readers).
+ *
+ * All mutations happen during the usage-analysis `buildStart` phase; readers
+ * only access this state during the subsequent `transform` phase.
+ */
+export type PruneContext = {
+  /**
+   * Maps every dictionary key seen in source files to the set of top-level
+   * content fields statically accessed, or `'all'` when the access pattern
+   * could not be determined.
+   */
+  dictionaryKeyToFieldUsageMap: Map<string, DictionaryFieldUsage>;
+  /**
+   * Dictionary keys for which the prune/minify step must be skipped entirely
+   * because an edge case was detected during analysis or structure recognition.
+   */
+  dictionariesWithEdgeCases: Set<string>;
+  /**
+   * True if at least one source file failed to parse during the analysis phase.
+   * The prune plugin uses this flag conservatively: any dictionary key without
+   * a usage entry might have been referenced by the unparsable file.
+   */
+  hasUnparsableSourceFiles: boolean;
+  /**
+   * Maps dictionary keys to the source file paths where the result of
+   * `useIntlayer` / `getIntlayer` was assigned to a plain variable, making
+   * static field analysis impossible.
+   */
+  dictionaryKeysWithUntrackedBindings: Map<string, string[]>;
+  /**
+   * Maps each dictionary key to a nested field-rename tree built after the
+   * usage analysis phase (only populated when `build.minify` is active and
+   * the field usage for that dictionary is a finite `Set<string>`).
+   */
+  dictionaryKeyToFieldRenameMap: Map<string, NestedRenameMap>;
+  /**
+   * Maps each dictionary key to the content field paths whose values are
+   * consumed "opaquely" (passed as-is to a child component or function
+   * argument). When an opaque value has nested user-defined structure, its
+   * children must not be renamed.
+   *
+   * The inner map is keyed by the dot-joined field path for de-duplication
+   * only; the authoritative path is {@link OpaqueFieldOccurrence.fieldPath}.
+   *
+   * Structure: dictionaryKey → joinedFieldPath → { fieldPath, locations }
+   */
+  dictionaryKeysWithOpaqueFields: Map<string, Map<string, OpaqueFieldOccurrence>>;
+  /**
+   * Dictionary keys for which field-key renaming must be skipped even if a
+   * finite field-usage set was determined.
+   *
+   * Populated for dictionaries whose plain-variable bindings were resolved by
+   * the framework-specific extractor (Vue / Svelte SFCs), because the Babel
+   * rename plugin cannot update the source-code property accesses for those
+   * indirect patterns (Vue `.value.field` / Svelte `$store.field`).
+   *
+   * Pruning and basic minification still apply; only field-key renaming is
+   * suppressed.
+   */
+  dictionariesSkippingFieldRename: Set<string>;
+  /**
+   * Plain variable bindings that require a framework-specific secondary pass.
+   *
+   * Populated during the Babel analysis phase for `.vue` and `.svelte` source
+   * files where direct field access is not visible to Babel scope analysis:
+   *   - Vue:    `content.value.fieldName` – the `.value` ref-accessor is hidden
+   *   - Svelte: `$varName.fieldName`     – the `$` prefix creates a new identifier
+   *
+   * Structure: filePath → [{variableName, dictionaryKey}, …]
+   */
+  pendingFrameworkAnalysis: Map<string, {
+    variableName: string;
+    dictionaryKey: string;
+  }[]>;
+};
+export declare const createPruneContext: () => PruneContext;
+/**
+ * Records `nest()` references in a prune context so nest targets stay
+ * resolvable — and no larger than they need to be — after purge and minify.
+ *
+ * A nested node stores the ORIGINAL dot path of the field it reads
+ * (`nest('common', 'period')` → `'period'`) and `getNesting` resolves it at
+ * runtime against the compiled JSON. That drives three adjustments:
+ *
+ * - Nest targets never take part in field renaming, since the stored path
+ *   would no longer match the renamed keys.
+ * - A target already consumed by a call site keeps its analysed fields plus
+ *   the nested ones, so neither consumer loses content.
+ * - A target reached *only* through `nest()` is given a usage entry holding
+ *   exactly the nested fields. Without one, the purge pass leaves the whole
+ *   dictionary untouched; with one, it trims the dictionary down to what the
+ *   nest references actually read. This matters most for `dynamic` / `fetch`
+ *   dictionaries, whose full static snapshot would otherwise be pulled into
+ *   the eager bundle just to satisfy a single nested field.
+ *
+ * Seeding is skipped when a source file failed to parse: that file could
+ * reference the dictionary in a way the analysis never saw, which is the same
+ * guard the purge pass applies to keys with no usage entry.
+ *
+ * @param pruneContext - Shared analysis state to update in place.
+ * @param nestedDictionaryReferences - Nest-target key → referenced top-level
+ *   fields, as returned by `getNestedDictionaryReferences`.
+ */
+export declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, nestedDictionaryReferences: Map<string, NestedFieldReferences>) => void;
+/**
+ * Records the usage of a specific dictionary key's fields into `pruneContext`.
+ * Merges with any previously recorded usage for the same key.
+ */
+export declare const recordFieldUsage: (pruneContext: PruneContext, dictionaryKey: string, fieldUsage: DictionaryFieldUsage) => void;
+//#endregion
+//# sourceMappingURL=pruneContext.d.ts.map

package/dist/types/pruneContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pruneContext.d.ts","names":[],"sources":["../../src/pruneContext.ts"],"mappings":";;;;;;;;;YASY,uBAAuB;;;;;;;;YASvB;EACV;EACA,UAAU;;;YAIA,kBAAkB,YAAY;;;;;;;YAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;YAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;qBAIf,0BAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCzB,iCAA8B,cAC3B,cAAY,4BACE,YAAY;;;;;qBAyC7B,mBAAgB,cACb,cAAY,uBACL,YACT"}

package/dist/types/staticAstReaders.d.ts

@@ -0,0 +1,84 @@
+import { NodePath } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+//#region src/staticAstReaders.d.ts
+/**
+ * Static-value readers shared by every pass that has to decide, at build time,
+ * which dictionary a call site reads.
+ *
+ * They were previously duplicated — with small behavioural drifts — between
+ * `babel-plugin-intlayer-optimize` and `babel-plugin-intlayer-usage-analyzer`.
+ * Both now read through this module so a call site the analyser can attribute
+ * is exactly the one the optimizer can rewrite.
+ */
+/**
+ * Reads a fully-static string from an AST node. Returns `undefined` for
+ * dynamic values (identifiers, expressions, template literals with
+ * interpolations, …).
+ */
+export declare const readStaticString: (babelTypes: typeof BabelTypes, node: BabelTypes.Node | null | undefined) => string | undefined;
+/** Returns the first dot-path segment of a key, e.g. `'a.b.c'` → `'a'`. */
+export declare const firstPathSegment: (path: string) => string;
+/**
+ * Reads the static first dot-path segment from a message-id node.
+ *
+ *   t('counter.label')      → 'counter'
+ *   t(`counter.${x}`)       → 'counter'   (static prefix before the first dot)
+ *   t(`${x}.label`)         → undefined   (dynamic first segment)
+ *   t(someVariable)         → undefined
+ */
+export declare const readStaticFirstSegment: (babelTypes: typeof BabelTypes, node: BabelTypes.Node | null | undefined) => string | undefined;
+/** Whether an object-property key (identifier or string literal) reads as `name`. */
+export declare const propertyKeyMatches: (babelTypes: typeof BabelTypes, property: BabelTypes.ObjectProperty, name: string) => boolean;
+/**
+ * Returns the `ObjectProperty` named `propertyName`, or `undefined` when the
+ * object has no such property. Callers that need to mutate the property in
+ * place (rewriting or deleting it) use this rather than a value reader.
+ */
+export declare const findObjectProperty: (babelTypes: typeof BabelTypes, objectExpression: BabelTypes.ObjectExpression, propertyName: string) => BabelTypes.ObjectProperty | undefined;
+/**
+ * Marker returned by the reader helpers when the requested property or
+ * argument is simply absent — distinct from present-but-dynamic, which the
+ * callers must treat conservatively.
+ */
+export declare const ABSENT_VALUE: '__default__';
+/** Either a statically-known value, {@link ABSENT_VALUE}, or `undefined` (dynamic). */
+export type StaticOrAbsent<T> = T | typeof ABSENT_VALUE | undefined;
+/**
+ * Reads a static string property from an object expression. Returns
+ * {@link ABSENT_VALUE} when the property is absent and `undefined` when
+ * present but dynamic.
+ */
+export declare const readObjectProperty: (babelTypes: typeof BabelTypes, objectExpression: BabelTypes.ObjectExpression, propertyName: string) => StaticOrAbsent<string>;
+/**
+ * Returns the value *node* of a named property, so callers can apply their own
+ * reader to it (a full static string, or just its leading path segment).
+ * Returns {@link ABSENT_VALUE} when the property is absent.
+ */
+export declare const readObjectPropertyNode: (babelTypes: typeof BabelTypes, objectExpression: BabelTypes.ObjectExpression, propertyName: string) => StaticOrAbsent<BabelTypes.Node>;
+/**
+ * Reads a named JSX attribute as a static string and returns it wrapped in a
+ * `StringLiteral` node so the result can be fed to the same namespace resolver
+ * as a call argument. Handles both `id="home.title"` and `id={'home.title'}`.
+ * Returns `undefined` when the attribute is absent or dynamic (`id={expr}`).
+ */
+export declare const readJsxAttributeString: (babelTypes: typeof BabelTypes, openingElement: BabelTypes.JSXOpeningElement, attributeName: string) => BabelTypes.StringLiteral | undefined;
+/**
+ * Splits a compat namespace at the first `.` to separate the dictionary key
+ * from an optional key prefix, mirroring the SWC plugin's `split_namespace`.
+ *
+ *   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`
+ *   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`
+ */
+export declare const splitNamespace: (namespace: string) => {
+  dictionaryKey: string;
+  keyPrefix: string;
+};
+/**
+ * Climbs past an enclosing `await` expression so that
+ * `const t = await getTranslations('ns')` — or `await getIntlayerAsync('key')`
+ * — is resolved to its variable declarator the same way the synchronous form
+ * is.
+ */
+export declare const unwrapAwait: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => NodePath<BabelTypes.Node>;
+//#endregion
+//# sourceMappingURL=staticAstReaders.d.ts.map

package/dist/types/staticAstReaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticAstReaders.d.ts","names":[],"sources":["../../src/staticAstReaders.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAkBa,mBAAgB,mBACR,YAAU,MACvB,WAAW;;qBAeN,mBAAgB;;;;;;;;;qBAWhB,yBAAsB,mBACd,YAAU,MACvB,WAAW;;qBAkBN,qBAAkB,mBACV,YAAU,UACnB,WAAW,gBAAc;;;;;;qBAWxB,qBAAkB,mBACV,YAAU,kBACX,WAAW,kBAAgB,yBAE5C,WAAW;;;;;;qBAaD;;YAGD,eAAe,KAAK,WAAW;;;;;;qBAO9B,qBAAkB,mBACV,YAAU,kBACX,WAAW,kBAAgB,yBAE5C;;;;;;qBAeU,yBAAsB,mBACd,YAAU,kBACX,WAAW,kBAAgB,yBAE5C,eAAe,WAAW;;;;;;;qBAgBhB,yBAAsB,mBACd,YAAU,gBACb,WAAW,mBAAiB,0BAE3C,WAAW;;;;;;;;qBAgCD,iBAAc;EAEtB;EAAuB;;;;;;;;qBAef,cAAW,mBACH,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW"}

package/dist/types/transformers.d.ts

@@ -1,4 +1,5 @@
-import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { PruneContext } from "./pruneContext.js";
+import { CompatCallerConfig } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { OptimizePluginOptions } from "./babel-plugin-intlayer-optimize.js";
 import { ParserOptions } from "@babel/parser";
 //#region src/transformers.d.ts

package/dist/types/transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;qBA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;qBAsCtB,uBAAoB,gCAAkC;;;;;;qBAWtD,sBAAoB;;;;;;qBAgBpB,qBAAkB,yBACJ,yBACxB;;;;;;qBAoBU,mBAAiB;;;;;;;;;;;;;qBAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;qBAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;qBAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;qBA8CU,qBAAkB,cACjB,wBACU,SACb,0BACR;EACD;EACA"}
+{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;;qBA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;qBAsCtB,uBAAoB,gCAAkC;;;;;;qBAWtD,sBAAoB;;;;;;qBAgBpB,qBAAkB,yBACJ,yBACxB;;;;;;qBAoBU,mBAAiB;;;;;;;;;;;;;qBAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;qBAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;qBAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;qBA8CU,qBAAkB,cACjB,wBACU,SACb,0BACR;EACD;EACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/babel",
-  "version": "9.4.4",
+  "version": "9.5.0",
   "private": false,
   "description": "A Babel plugin for Intlayer that transforms declaration files and provides internationalization features during the build process according to the Intlayer configuration.",
   "keywords": [
@@ -89,19 +89,19 @@
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@babel/traverse": "8.0.4",
     "@babel/types": "8.0.4",
-    "@intlayer/config": "9.4.4",
-    "@intlayer/core": "9.4.4",
-    "@intlayer/dictionaries-entry": "9.4.4",
-    "@intlayer/engine": "9.4.4",
-    "@intlayer/types": "9.4.4",
-    "@intlayer/unmerged-dictionaries-entry": "9.4.4"
+    "@intlayer/config": "9.5.0",
+    "@intlayer/core": "9.5.0",
+    "@intlayer/dictionaries-entry": "9.5.0",
+    "@intlayer/engine": "9.5.0",
+    "@intlayer/types": "9.5.0",
+    "@intlayer/unmerged-dictionaries-entry": "9.5.0"
   },
   "devDependencies": {
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@types/babel__core": "7.20.5",
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
-    "@types/node": "26.4.1",
+    "@types/node": "26.5.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
@@ -112,8 +112,8 @@
     "vitest": "5.0.0"
   },
   "peerDependencies": {
-    "@intlayer/svelte-compiler": "9.4.4",
-    "@intlayer/vue-compiler": "9.4.4"
+    "@intlayer/svelte-compiler": "9.5.0",
+    "@intlayer/vue-compiler": "9.5.0"
   },
   "peerDependenciesMeta": {
     "@intlayer/svelte-compiler": {