@intlayer/babel 9.2.0 → 9.3.0

package/dist/types/babel-plugin-intlayer-optimize.d.ts

@@ -47,6 +47,21 @@ type OptimizePluginOptions = {
    * If true, the plugin will replace the dictionary entry file with `export default {}`.
    */
   replaceDictionaryEntry: boolean;
+  /**
+   * Keys of the dictionaries that reference other dictionaries through
+   * `nest()`.
+   *
+   * For those, the injected static import points at the generated companion
+   * module (`<dictionariesDir>/nested/<key>.mjs`) instead of the raw JSON. The
+   * companion re-exports the dictionary with its nest targets attached, so
+   * `getNesting` resolves them from that local reference rather than from the
+   * global registry this plugin empties — and each target lands in the chunk of
+   * the dictionary referencing it.
+   *
+   * Dynamic and fetch modes need nothing here: their generated loaders already
+   * attach the same targets per locale.
+   */
+  nestingDictionaryKeys?: string[];
   /**
    * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.
    */

package/dist/types/babel-plugin-intlayer-optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA6BM;;;;KAqDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8RW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA8BM;;;;KAqDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiTW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}

package/dist/types/babel-plugin-intlayer-purge.d.ts

@@ -1,6 +1,8 @@
 import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
+import { IntlayerConfig } from "@intlayer/types/config";
+import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
 //#region src/babel-plugin-intlayer-purge.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerPurgeBabelPlugin}.
@@ -54,6 +56,14 @@ type PurgePluginOptions = {
    * `content` glob patterns.
    */
   componentFilesList: string[];
+  /**
+   * Dictionaries referenced through `nest()`, mapped to the top-level fields
+   * those references read (`'all'` when the whole dictionary is nested).
+   *
+   * Those fields are resolved at runtime by `getNesting` using their original
+   * names, so they must survive purging and must never be renamed.
+   */
+  nestedDictionaryReferences?: Map<string, NestedFieldReferences>;
   /**
    * Per-dictionary import-mode overrides, keyed by dictionary `key`.
    * Dictionaries with mode `'fetch'` are excluded from field renaming because
@@ -72,6 +82,13 @@ type PurgePluginOptions = {
    * Defaults to `[]` (no compat callers) when omitted.
    */
   compatCallers?: CompatCallerConfig[];
+  /**
+   * Logging configuration used to report what the pipeline purged and
+   * minified, so a Babel- or SWC-driven build prints the same summary as the
+   * Vite one.  Mirrors `log` in `intlayer.config.ts`; omit to fall back to the
+   * logger defaults.
+   */
+  logConfig?: Pick<IntlayerConfig, 'log'>;
 };
 /**
  * Returns the shared {@link PruneContext} for the given base directory, or
@@ -82,6 +99,24 @@ type PurgePluginOptions = {
  * creating a circular dependency.
  */
 declare const getSharedPruneContext: (baseDir: string) => PruneContext | null;
+/**
+ * Runs the full purge/minify pipeline for the given options, using a
+ * module-level cache so the work happens at most once per process per
+ * unique `baseDir`.
+ *
+ * Exported so bundler integrations that do not go through Babel can drive the
+ * same pipeline. The Next.js integration is the main consumer: its SWC plugin
+ * runs as a per-file Wasm transform with no filesystem access, so the analysis
+ * and the dictionary rewrite happen here, in Node, and only the resulting
+ * field-rename tables (see {@link serializeFieldRenameMap}) are forwarded to
+ * the plugin.
+ *
+ * **This performs file I/O**: it reads every source file listed in
+ * `componentFilesList` and overwrites the compiled dictionary JSON files
+ * in-place. Call it at most once per build, after the dictionaries have been
+ * built.
+ */
+declare const runIntlayerPurgePipeline: (options: PurgePluginOptions) => PruneContext;
 /**
  * Babel plugin that analyses all project source files and rewrites compiled
  * dictionary JSON files in-place to remove unused content fields
@@ -134,5 +169,5 @@ declare const intlayerPurgeBabelPlugin: (_babel: {
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin };
+export { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin, runIntlayerPurgePipeline };
 //# sourceMappingURL=babel-plugin-intlayer-purge.d.ts.map

package/dist/types/babel-plugin-intlayer-purge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;KAgCY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;EAOA,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;;;;cAqBL,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwjB3C,2BAAwB;EACnC,cAAc;MACZ"}
+{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;;;KA2CY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;;;EASA,6BAA6B,YAAY;;;;;;EAOzC,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;EAQhB,YAAY,KAAK;;;;;;;;;;cAwBN,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;cAssB3C,2BAAwB,SAC1B,uBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2HU,2BAAwB;EACnC,cAAc;MACZ"}

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts

@@ -1,6 +1,7 @@
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 import { CallerDescriptor, CallerDescriptor as CallerDescriptor$1, CallerResultShape, CallerValueSource } from "@intlayer/config/callers";
+import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
 //#region src/babel-plugin-intlayer-usage-analyzer.d.ts
 /**
  * Dictionary field usage result for a single dictionary key.
@@ -117,6 +118,34 @@ type PruneContext = {
   }[]>;
 };
 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`.
+ */
+declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, nestedDictionaryReferences: Map<string, NestedFieldReferences>) => void;
 /** Canonical intlayer caller names that trigger usage analysis. */
 declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer'];
 type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
@@ -158,5 +187,5 @@ declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export { type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin };
+export { type CallerDescriptor, type CallerResultShape, type CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields };
 //# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.d.ts.map

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;KAgBY,uBAAuB;;;;;;;;KASvB;EACV;EACA,UAAU;;;KAIA,kBAAkB,YAAY;;;;;;;KAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;KAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;cAIf,0BAAyB;;cAiBzB;KACD,6BAA6B;;;;;;;KAmB7B,qBAAqB;;;;;;;;;;;cAYpB,wBAAwB;;;;;;;;;;;;;;;cAmiCxB,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;;KAiBY,uBAAuB;;;;;;;;KASvB;EACV;EACA,UAAU;;;KAIA,kBAAkB,YAAY;;;;;;;KAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;KAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;cAIf,0BAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyCzB,iCAA8B,cAC3B,cAAY,4BACE,YAAY;;cAwC7B;KACD,6BAA6B;;;;;;;KAmB7B,qBAAqB;;;;;;;;;;;cAYpB,wBAAwB;;;;;;;;;;;;;;;cAmiCxB,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}

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

@@ -1 +1 @@
-{"version":3,"file":"getOptimizePluginOptions.d.ts","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"mappings":";;;;KAUK;;;;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;;;;;;;cAyBT,2BAAwB,SAC1B,mCACR"}

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

@@ -1 +1 @@
-{"version":3,"file":"getPurgePluginOptions.d.ts","names":[],"sources":["../../src/getPurgePluginOptions.ts"],"mappings":";;;;;KAkCK;;;;;;EAMH,gBAAgB;;;;;;EAOhB,eAAe;;;;EAKf,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,wBAAqB,SACvB,gCACR;KA4CE;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,wBAAqB,SACvB,gCACR;KA8CE;;;;EAIH,gBAAgB;;;;EAKhB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;cAwBT,yBAAsB,SACxB,iCACR"}

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
 import { ATTRIBUTES_TO_EXTRACT, PackageName, SERVER_CAPABLE_PACKAGES, packageList } from "./extractContent/utils/constants.js";
 import { ExtractPluginOptions, ExtractResult, intlayerExtractBabelPlugin } from "./babel-plugin-intlayer-extract.js";
-import { CallerDescriptor, CallerResultShape, CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.js";
-import { buildNestedRenameMapFromContent, generateShortFieldName, getNestedRenameEntryAtPath, makeFieldRenameBabelPlugin, renameIntlayerFieldAccesses } from "./babel-plugin-intlayer-field-rename.js";
+import { CallerDescriptor, CallerResultShape, CallerValueSource, CompatCallerConfig, DEFAULT_COMPAT_CALLERS, DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields } 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";
-import { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin } from "./babel-plugin-intlayer-purge.js";
+import { PurgePluginOptions, getSharedPruneContext, intlayerPurgeBabelPlugin, runIntlayerPurgePipeline } from "./babel-plugin-intlayer-purge.js";
 import { detectPackageName } from "./extractContent/utils/detectPackageName.js";
 import { ExtractDictionaryInfoOptions, ResolveContentFilePaths, extractDictionaryInfo, getOutput, resolveContentFilePaths } from "./extractContent/utils/extractDictionaryInfo.js";
 import { extractDictionaryKey, extractDictionaryKeyFromPath } from "./extractContent/utils/extractDictionaryKey.js";
@@ -18,4 +18,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 { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, 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, 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, renameFieldsInCode, renameFieldsInSourceFile, renameIntlayerFieldAccesses, resolveContentFilePaths, writeContentHelper };
+export { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, 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, writeContentHelper };

package/dist/types/transformers.d.ts

@@ -1,12 +1,12 @@
 import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { OptimizePluginOptions } from "./babel-plugin-intlayer-optimize.js";
-import { TransformOptions } from "@babel/core";
+import { ParserOptions } from "@babel/parser";
 //#region src/transformers.d.ts
 /**
  * Babel parser options covering the superset of syntaxes used across all
  * supported frameworks (React / Vue / Svelte / Angular / …).
  */
-declare const BABEL_PARSER_OPTIONS: NonNullable<TransformOptions['parserOpts']>;
+declare const BABEL_PARSER_OPTIONS: ParserOptions;
 /**
  * Fast pre-check: matches files that could contain native intlayer calls
  * (`useIntlayer` / `getIntlayer`). Used by the optimize/transform pass, which

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

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","names":[],"sources":["../../src/transformers.ts"],"mappings":";;;;;;;;cAmBa,sBAAsB,YAAY;;;;;;cAyBlC,sBAAoB;;;;;;;;;;;;;;;cAgBpB,uBAAoB,gCAAkC;;;;;;cAwBtD,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":";;;;;;;;cAyBa,sBAAsB;;;;;;cAwBtB,sBAAoB;;;;;;;;;;;;;;;cAgBpB,uBAAoB,gCAAkC;;;;;;cAwBtD,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/babel",
-  "version": "9.2.0",
+  "version": "9.3.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,20 @@
     "@babel/plugin-syntax-jsx": "8.0.1",
     "@babel/traverse": "8.0.4",
     "@babel/types": "8.0.4",
-    "@intlayer/config": "9.2.0",
-    "@intlayer/core": "9.2.0",
-    "@intlayer/dictionaries-entry": "9.2.0",
-    "@intlayer/engine": "9.2.0",
-    "@intlayer/types": "9.2.0",
-    "@intlayer/unmerged-dictionaries-entry": "9.2.0"
+    "@intlayer/config": "9.3.0",
+    "@intlayer/core": "9.3.0",
+    "@intlayer/dictionaries-entry": "9.3.0",
+    "@intlayer/engine": "9.3.0",
+    "@intlayer/types": "9.3.0",
+    "@intlayer/unmerged-dictionaries-entry": "9.3.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.1.2",
+    "@types/convert-source-map": "^2.0.3",
+    "@types/node": "26.2.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
@@ -112,8 +113,8 @@
     "vitest": "4.1.10"
   },
   "peerDependencies": {
-    "@intlayer/svelte-compiler": "9.2.0",
-    "@intlayer/vue-compiler": "9.2.0"
+    "@intlayer/svelte-compiler": "9.3.0",
+    "@intlayer/vue-compiler": "9.3.0"
   },
   "peerDependenciesMeta": {
     "@intlayer/svelte-compiler": {