@intlayer/babel 9.4.3 → 9.5.0

package/dist/types/extractScriptBlocks.d.ts

@@ -8,7 +8,7 @@
  *   `contentEndOffset`   – Byte offset one past the last byte of `content` in the
  *                          full source string (i.e. `source.slice(start, end) === content`).
  */
-type ScriptBlock = {
+export type ScriptBlock = {
   content: string;
   contentStartOffset: number;
   contentEndOffset: number;
@@ -27,7 +27,7 @@ type ScriptBlock = {
  *  - everything else → treats the whole file as a single script block and
  *    returns it wrapped in a single-element array.
  */
-declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlock[];
+export declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlock[];
 /**
  * Applies modified script block content back into the original source string.
  *
@@ -38,10 +38,9 @@ declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlo
  *
  * Returns `originalCode` unchanged when `modifications` is empty.
  */
-declare const injectScriptBlocks: (originalCode: string, modifications: ReadonlyArray<{
+export declare const injectScriptBlocks: (originalCode: string, modifications: ReadonlyArray<{
   block: ScriptBlock;
   modifiedContent: string;
 }>) => string;
 //#endregion
-export { ScriptBlock, extractScriptBlocks, injectScriptBlocks };
 //# sourceMappingURL=extractScriptBlocks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;;;;;;;;;KAWY;EACV;EACA;EACA;;;;;;;;;;;;;;;;cA8FW,sBAAmB,kBACd,iBAEf;;;;;;;;;;;cA+BU,qBAAkB,sBACT,eACL;EACb,OAAO;EACP"}
+{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;;;;;;;;;YAWY;EACV;EACA;EACA;;;;;;;;;;;;;;;;qBA8FW,sBAAmB,kBACd,iBAEf;;;;;;;;;;;qBA+BU,qBAAkB,sBACT,eACL;EACb,OAAO;EACP"}

package/dist/types/getExtractPluginOptions.d.ts

@@ -6,13 +6,12 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * - 'dev': Development mode with HMR support
  * - 'build': Production build mode
  */
-type CompilerMode = 'dev' | 'build';
+export type CompilerMode = 'dev' | 'build';
 /**
  * Get the options for the Intlayer Babel extraction plugin
  * This function loads the Intlayer configuration and sets up the onExtract callback
  * to write dictionaries to the filesystem.
  */
-declare const getExtractPluginOptions: (configuration?: IntlayerConfig, isDev?: CompilerMode | string | undefined) => ExtractPluginOptions;
+export declare const getExtractPluginOptions: (configuration?: IntlayerConfig, isDev?: CompilerMode | string | undefined) => ExtractPluginOptions;
 //#endregion
-export { CompilerMode, getExtractPluginOptions };
 //# sourceMappingURL=getExtractPluginOptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getExtractPluginOptions.d.ts","names":[],"sources":["../../src/getExtractPluginOptions.ts"],"mappings":";;;;;;;;KAcY;;;;;;cAOC,0BAAuB,gBACnB,gBAAc,QACtB,sCACN"}
+{"version":3,"file":"getExtractPluginOptions.d.ts","names":[],"sources":["../../src/getExtractPluginOptions.ts"],"mappings":";;;;;;;;YAcY;;;;;;qBAOC,0BAAuB,gBACnB,gBAAc,QACtB,sCACN"}

package/dist/types/getOptimizePluginOptions.d.ts

@@ -27,7 +27,6 @@ type GetOptimizePluginOptionsParams = {
  * This function loads the Intlayer configuration and returns the paths
  * needed for dictionary optimization and import rewriting.
  */
-declare const getOptimizePluginOptions: (params?: GetOptimizePluginOptionsParams) => OptimizePluginOptions;
+export declare const getOptimizePluginOptions: (params?: GetOptimizePluginOptionsParams) => OptimizePluginOptions;
 //#endregion
-export { getOptimizePluginOptions };
 //# sourceMappingURL=getOptimizePluginOptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;KAWK;;;;EAIH,gBAAgB;;;;EAIhB,eAAe;;;;;;EAMf;;;;EAIA,YAAY,QAAQ;;;;;;;cAyBT,2BAAwB,SAC1B,mCACR"}
+{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;KAWK;;;;EAIH,gBAAgB;;;;EAIhB,eAAe;;;;;;EAMf;;;;EAIA,YAAY,QAAQ;;;;;;;qBAyBT,2BAAwB,SAC1B,mCACR"}

package/dist/types/getPurgePluginOptions.d.ts

@@ -44,7 +44,7 @@ type GetPurgePluginOptionsParams = {
  * };
  * ```
  */
-declare const getPurgePluginOptions: (params?: GetPurgePluginOptionsParams) => PurgePluginOptions;
+export declare const getPurgePluginOptions: (params?: GetPurgePluginOptionsParams) => PurgePluginOptions;
 type GetMinifyPluginOptionsParams = {
   /**
    * Options forwarded to the intlayer configuration loader.
@@ -76,7 +76,6 @@ type GetMinifyPluginOptionsParams = {
  * };
  * ```
  */
-declare const getMinifyPluginOptions: (params?: GetMinifyPluginOptionsParams) => MinifyPluginOptions;
+export declare const getMinifyPluginOptions: (params?: GetMinifyPluginOptionsParams) => MinifyPluginOptions;
 //#endregion
-export { getMinifyPluginOptions, getPurgePluginOptions };
 //# sourceMappingURL=getPurgePluginOptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;KAmCK;;;;;;EAMH,gBAAgB;;;;;;EAOhB,eAAe;;;;EAKf,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,wBAAqB,SACvB,gCACR;KA8CE;;;;EAIH,gBAAgB;;;;EAKhB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;cAwBT,yBAAsB,SACxB,iCACR"}
+{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;KAmCK;;;;;;EAMH,gBAAgB;;;;;;EAOhB,eAAe;;;;EAKf,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BT,wBAAqB,SACvB,gCACR;KA8CE;;;;EAIH,gBAAgB;;;;EAKhB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;qBAwBT,yBAAsB,SACxB,iCACR"}

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/normalizedFilesList.d.ts

@@ -6,7 +6,6 @@
  * @param filesList - The plugin's `filesList` option (absolute file paths).
  * @returns A set of the same paths normalized via `normalizePath`.
  */
-declare const getNormalizedFilesListSet: (filesList: readonly string[]) => Set<string>;
+export declare const getNormalizedFilesListSet: (filesList: readonly string[]) => Set<string>;
 //#endregion
-export { getNormalizedFilesListSet };
 //# sourceMappingURL=normalizedFilesList.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"normalizedFilesList.d.ts","names":[],"sources":["../../src/normalizedFilesList.ts"],"mappings":";;;;;;;;cAiBa,4BAAyB,iCAEnC"}
+{"version":3,"file":"normalizedFilesList.d.ts","names":[],"sources":["../../src/normalizedFilesList.ts"],"mappings":";;;;;;;;qBAiBa,4BAAyB,iCAEnC"}

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
@@ -6,7 +7,7 @@ import { ParserOptions } from "@babel/parser";
  * Babel parser options covering the superset of syntaxes used across all
  * supported frameworks (React / Vue / Svelte / Angular / …).
  */
-declare const BABEL_PARSER_OPTIONS: ParserOptions;
+export declare const BABEL_PARSER_OPTIONS: ParserOptions;
 /**
  * Builds a fast pre-check regex that matches files potentially containing
  * native intlayer calls and/or the given compat namespace caller names.
@@ -26,25 +27,25 @@ declare const BABEL_PARSER_OPTIONS: ParserOptions;
  *   (e.g. `['useTranslation', 'getFixedT']` from `@intlayer/react-i18next`).
  * @returns A `RegExp` matching any of the native or provided caller names.
  */
-declare const buildUsageCheckRegex: (extraCallerNames?: string[]) => RegExp;
+export declare const buildUsageCheckRegex: (extraCallerNames?: string[]) => RegExp;
 /**
  * Fast pre-check: matches files that could contain native intlayer calls
  * (`useIntlayer` / `getIntlayer` / `getIntlayerAsync`). Used by the
  * optimize/transform pass, which only rewrites native calls.
  */
-declare const INTLAYER_USAGE_REGEX: RegExp;
+export declare const INTLAYER_USAGE_REGEX: RegExp;
 /**
  * Returns the usage-check regex for the given compat callers, memoised by the
  * array reference. Plugins pass the same options array for every analysed
  * file, so the regex is built once per build instead of once per file.
  */
-declare const getUsageCheckRegex: (compatCallers?: readonly CompatCallerConfig[]) => RegExp;
+export declare const getUsageCheckRegex: (compatCallers?: readonly CompatCallerConfig[]) => RegExp;
 /**
  * Matches source files that are valid targets for usage analysis and Babel
  * transformation. Excludes sourcemap files, declaration files, and other
  * non-source extensions.
  */
-declare const SOURCE_FILE_REGEX: RegExp;
+export declare const SOURCE_FILE_REGEX: RegExp;
 /**
  * Runs the usage-analysis Babel plugin on a source file, accumulating
  * field-usage data into `pruneContext`.
@@ -57,14 +58,14 @@ declare const SOURCE_FILE_REGEX: RegExp;
  * Throws if Babel cannot parse the file (caller should handle and flag
  * `pruneContext.hasUnparsableSourceFiles`).
  */
-declare const analyzeFieldUsageInFile: (sourceFilePath: string, code: string, pruneContext: PruneContext, compatCallers?: CompatCallerConfig[]) => Promise<void>;
+export declare const analyzeFieldUsageInFile: (sourceFilePath: string, code: string, pruneContext: PruneContext, compatCallers?: CompatCallerConfig[]) => Promise<void>;
 /**
  * Applies field-renaming to a single JS/TS code string (not an SFC).
  *
  * Returns the renamed code string, or `null` if nothing changed or if
  * Babel failed to parse the input (caller should fall back to original code).
  */
-declare const renameFieldsInCode: (code: string, sourceFilePath: string, pruneContext: PruneContext) => Promise<string | null>;
+export declare const renameFieldsInCode: (code: string, sourceFilePath: string, pruneContext: PruneContext) => Promise<string | null>;
 /**
  * Applies field-renaming to a source file, correctly handling both plain
  * JS/TS files and SFC files (Vue / Svelte) by operating on each script block
@@ -72,7 +73,7 @@ declare const renameFieldsInCode: (code: string, sourceFilePath: string, pruneCo
  *
  * Returns the renamed code string, or `null` if nothing changed.
  */
-declare const renameFieldsInSourceFile: (sourceFilePath: string, code: string, pruneContext: PruneContext) => Promise<string | null>;
+export declare const renameFieldsInSourceFile: (sourceFilePath: string, code: string, pruneContext: PruneContext) => Promise<string | null>;
 /**
  * Runs the intlayer optimize Babel plugin on a source file, transforming
  * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`
@@ -81,10 +82,9 @@ declare const renameFieldsInSourceFile: (sourceFilePath: string, code: string, p
  * Returns `{ code, map }` on success, or `null` if the transformation produced
  * no output.
  */
-declare const optimizeSourceFile: (code: string, sourceFilePath: string, options: OptimizePluginOptions) => Promise<{
+export declare const optimizeSourceFile: (code: string, sourceFilePath: string, options: OptimizePluginOptions) => Promise<{
   code: string;
   map: string | object | null | undefined;
 } | null>;
 //#endregion
-export { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildUsageCheckRegex, getUsageCheckRegex, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile };
 //# sourceMappingURL=transformers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;cA0Ba,sBAAsB;;;;;;;;;;;;;;;;;;;;cAsCtB,uBAAoB,gCAAkC;;;;;;cAWtD,sBAAoB;;;;;;cAgBpB,qBAAkB,yBACJ,yBACxB;;;;;;cAoBU,mBAAiB;;;;;;;;;;;;;cAqCjB,0BAAuB,wBACZ,cACV,cACE,cAAY,gBACV,yBACf;;;;;;;cAyBU,qBAAkB,cACjB,wBACU,cACR,iBACb;;;;;;;;cAqBU,2BAAwB,wBACb,cACV,cACE,iBACb;;;;;;;;;cA8CU,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.3",
+  "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,31 +89,31 @@
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@babel/traverse": "8.0.4",
     "@babel/types": "8.0.4",
-    "@intlayer/config": "9.4.3",
-    "@intlayer/core": "9.4.3",
-    "@intlayer/dictionaries-entry": "9.4.3",
-    "@intlayer/engine": "9.4.3",
-    "@intlayer/types": "9.4.3",
-    "@intlayer/unmerged-dictionaries-entry": "9.4.3"
+    "@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",
     "@vitejs/plugin-react": "6.1.1",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
-    "@intlayer/svelte-compiler": "9.4.3",
-    "@intlayer/vue-compiler": "9.4.3"
+    "@intlayer/svelte-compiler": "9.5.0",
+    "@intlayer/vue-compiler": "9.5.0"
   },
   "peerDependenciesMeta": {
     "@intlayer/svelte-compiler": {