@intlayer/engine 9.2.0 → 9.3.1

package/dist/types/buildIntlayerDictionary/writeNestedDictionary.d.ts

@@ -0,0 +1,54 @@
+import { IntlayerConfig } from "@intlayer/types/config";
+//#region src/buildIntlayerDictionary/writeNestedDictionary.d.ts
+/**
+ * Subdirectory of `dictionariesDir` holding the companion modules. Nested under
+ * the compiled dictionaries so both stay together and are cleaned as one, and
+ * because the `**\/*.json` globs listing compiled dictionaries never match the
+ * `.mjs` / `.cjs` files written here.
+ */
+declare const NESTED_DICTIONARIES_SUBDIR = "nested";
+/**
+ * Path of the companion module carrying the `nest()` targets of a dictionary.
+ *
+ * Shared with the bundler plugins, which re-point the static import they inject
+ * at a `useIntlayer` call site to this module whenever the dictionary has nest
+ * targets.
+ *
+ * @param dictionariesDir - The compiled dictionaries directory.
+ * @param key - The dictionary key.
+ * @param extension - Module extension, `'mjs'` (default) or `'cjs'`.
+ */
+declare const getNestedDictionaryPath: (dictionariesDir: string, key: string, extension?: 'mjs' | 'cjs') => string;
+/**
+ * Generates a companion module that re-exports a compiled dictionary with its
+ * `nest()` targets attached.
+ *
+ * The optimizer imports this instead of the raw JSON, so `getNesting` resolves
+ * the reference from `nestedDictionaries` rather from the global registry
+ * — which lets the registry be stripped, and puts each nest target in the same
+ * chunk as the dictionary that references it.
+ *
+ * @param key - The dictionary key.
+ * @param nestedKeys - Keys of the dictionaries it references, transitively.
+ * @param format - Output module format.
+ *
+ * @example
+ * ```js
+ * import _dictionary from '../dashboard.json' with { type: 'json' };
+ * import _1a2b3c from '../common.json' with { type: 'json' };
+ *
+ * export default { ..._dictionary, nestedDictionaries: { 'common': _1a2b3c } };
+ * ```
+ */
+declare const generateNestedDictionaryEntryPoint: (key: string, nestedKeys: string[], format?: 'cjs' | 'esm') => string;
+/**
+ * Writes one companion module per dictionary holding `nest()` references.
+ *
+ * @param nestedDictionaryGraph - Dictionary key → keys it nests, transitively.
+ * @param configuration - The resolved intlayer configuration.
+ * @param formats - Module formats to emit.
+ */
+declare const writeNestedDictionaries: (nestedDictionaryGraph: Map<string, Set<string>>, configuration: IntlayerConfig, formats?: ('cjs' | 'esm')[]) => Promise<void>;
+//#endregion
+export { NESTED_DICTIONARIES_SUBDIR, generateNestedDictionaryEntryPoint, getNestedDictionaryPath, writeNestedDictionaries };
+//# sourceMappingURL=writeNestedDictionary.d.ts.map

package/dist/types/buildIntlayerDictionary/writeNestedDictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeNestedDictionary.d.ts","names":[],"sources":["../../../src/buildIntlayerDictionary/writeNestedDictionary.ts"],"mappings":";;;;;;;;cAgBa;;;;;;;;;;;;cAoBA,0BAAuB,yBACX,aACZ;;;;;;;;;;;;;;;;;;;;;;cA0BA,qCAAkC,aAClC,sBACS;;;;;;;;cAkDT,0BAAuB,uBACX,YAAY,cAAY,eAChC,gBAAc,gCAE5B"}

package/dist/types/fetchDistantDictionaries.d.ts

@@ -6,9 +6,35 @@ type FetchDistantDictionariesOptions = {
   dictionaryKeys: string[];
   newDictionariesPath?: string;
   logPrefix?: string;
+  /**
+   * Number of dictionaries fetched by a single request.
+   * @default 3
+   */
+  dictionariesPerRequest?: number;
+  /**
+   * Number of requests kept in flight at the same time.
+   * @default 5
+   */
+  parallelRequests?: number;
+  /**
+   * Number of retries performed when a batch request fails.
+   * @default 2
+   */
+  maxRetry?: number;
+  /**
+   * Delay between two attempts of a failing batch request, in milliseconds.
+   * @default 250
+   */
+  retryDelay?: number;
 };
 /**
  * Fetch distant dictionaries and update the logger with their statuses.
+ *
+ * Keys are grouped into batches fetched by a single request each, and those
+ * requests are kept in flight together — by default 5 concurrent requests of 3
+ * dictionaries, so 15 dictionaries travel at any given time. A slot is refilled
+ * as soon as its request settles, so no batch waits for the whole wave.
+ * Failing requests are retried before their keys are reported as errors.
  */
 declare const fetchDistantDictionaries: (options: FetchDistantDictionariesOptions, onStatusUpdate?: (status: DictionariesStatus[]) => void) => Promise<DictionaryAPI[]>;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KASK;EACH;EACA;EACA;;;;;cAMW,2BAAwB,SAC1B,iCAA+B,kBACtB,QAAQ,kCACzB,QAAQ"}
+{"version":3,"file":"fetchDistantDictionaries.d.ts","names":[],"sources":["../../src/fetchDistantDictionaries.ts"],"mappings":";;;;KAqDK;EACH;EACA;EACA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;cAYW,2BAAwB,SAC1B,iCAA+B,kBACtB,QAAQ,kCACzB,QAAQ"}

package/dist/types/formatDictionary.d.ts

@@ -8,6 +8,7 @@ declare const formatDictionaryOutput: (dictionary: Dictionary, format: Dictionar
   projectIds?: string[];
   localId?: import("@intlayer/types").LocalDictionaryId;
   localIds?: import("@intlayer/types").LocalDictionaryId[];
+  nestedDictionaries?: Record<import("@intlayer/types").DictionaryKey, unknown>;
   key: import("@intlayer/types").DictionaryKey;
   title?: string;
   description?: string;
@@ -34,6 +35,7 @@ declare const formatDictionariesOutput: (dictionaries: Dictionary[], format: Dic
   projectIds?: string[];
   localId?: import("@intlayer/types").LocalDictionaryId;
   localIds?: import("@intlayer/types").LocalDictionaryId[];
+  nestedDictionaries?: Record<import("@intlayer/types").DictionaryKey, unknown>;
   key: import("@intlayer/types").DictionaryKey;
   title?: string;
   description?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;cAYa,mBAAgB,YAAgB,eAAa;cAoC7C,qBAAkB,cACf,iBACb,QAAQ;cAEE,yBAAsB,YACrB,YAAU,QACd;;;;;;;;;;;;;;;;;;;;;;;;;IAmCT;cAEY,2BAAwB,cACrB,cAAY,QAClB;;;;;;;;;;;;;;;;;;;;;;;;;IAEoE"}
+{"version":3,"file":"formatDictionary.d.ts","names":[],"sources":["../../src/formatDictionary.ts"],"mappings":";;cAYa,mBAAgB,YAAgB,eAAa;cAoC7C,qBAAkB,cACf,iBACb,QAAQ;cAEE,yBAAsB,YACrB,YAAU,QACd;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCT;cAEY,2BAAwB,cACrB,cAAY,QAClB;;;;;;;;;;;;;;;;;;;;;;;;;;IAEoE"}

package/dist/types/init/frameworkSetup/tanstackStart/templates.d.ts

@@ -13,10 +13,15 @@
 declare const buildLocaleRouteTemplate: (localeSegment: string) => string;
 /**
  * Root route document (`routes/__root.tsx`) providing `<html>` + the Intlayer
- * provider, with the locale read from the `{-$locale}` route param.
+ * provider, with the locale read from the locale segment route params.
+ *
+ * The route is reached through `getRouteApi(<route id>)` rather than by
+ * importing `<segment>/route`, so the root never imports a child route module —
+ * the recommended way to consume another route's typed hooks.
  */
-declare const ROOT_TEMPLATE_TS = "import {\n  createRootRoute,\n  HeadContent,\n  Scripts,\n  useParams,\n} from \"@tanstack/react-router\";\nimport { defaultLocale, getHTMLTextDir } from \"intlayer\";\nimport type { ReactNode } from \"react\";\nimport { IntlayerProvider } from \"react-intlayer\";\n\nexport const Route = createRootRoute({\n  shellComponent: RootDocument,\n});\n\nfunction RootDocument({ children }: { children: ReactNode }) {\n  const params = useParams({ strict: false });\n  const locale = params.locale ?? defaultLocale;\n\n  return (\n    <html dir={getHTMLTextDir(locale)} lang={locale}>\n      <head>\n        <HeadContent />\n      </head>\n      <body>\n        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>\n        <Scripts />\n      </body>\n    </html>\n  );\n}\n";
-declare const ROOT_TEMPLATE_JS = "import {\n  createRootRoute,\n  HeadContent,\n  Scripts,\n  useParams,\n} from \"@tanstack/react-router\";\nimport { defaultLocale, getHTMLTextDir } from \"intlayer\";\nimport { IntlayerProvider } from \"react-intlayer\";\n\nexport const Route = createRootRoute({\n  shellComponent: RootDocument,\n});\n\nfunction RootDocument({ children }) {\n  const params = useParams({ strict: false });\n  const locale = params.locale ?? defaultLocale;\n\n  return (\n    <html dir={getHTMLTextDir(locale)} lang={locale}>\n      <head>\n        <HeadContent />\n      </head>\n      <body>\n        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>\n        <Scripts />\n      </body>\n    </html>\n  );\n}\n";
+declare const buildRootTemplateTs: (localeSegment: string) => string;
+/** JavaScript counterpart of {@link buildRootTemplateTs}. */
+declare const buildRootTemplateJs: (localeSegment: string) => string;
 //#endregion
-export { ROOT_TEMPLATE_JS, ROOT_TEMPLATE_TS, buildLocaleRouteTemplate };
+export { buildLocaleRouteTemplate, buildRootTemplateJs, buildRootTemplateTs };
 //# sourceMappingURL=templates.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/templates.ts"],"mappings":";;;;;;;;;;;;cAYa,2BAAwB;;;;;cA4BxB;cAgCA"}
+{"version":3,"file":"templates.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/templates.ts"],"mappings":";;;;;;;;;;;;cAYa,2BAAwB;;;;;;;;;cAgCxB,sBAAmB;;cAkCnB,sBAAmB"}

package/dist/types/init/frameworkSetup/tanstackStart/transforms.d.ts

@@ -6,12 +6,16 @@ type TransformResult = {
 };
 /**
  * Wraps the `{children}` of a TanStack Start root document with
- * `IntlayerProvider`, deriving the locale from the `{-$locale}` route param.
+ * `IntlayerProvider`, deriving the locale from the locale segment route params.
  * Safe and idempotent: bails (returns the original code) when the provider is
  * already present, when no `<html>` document function is found, or when there is
  * no `{children}` placeholder to wrap.
+ *
+ * @param code Source of the project's `__root` document.
+ * @param localeSegment Locale segment directory in use — `{-$locale}` for every
+ * routing mode but `prefix-all`, which uses the required `$locale`.
  */
-declare const wrapRootWithProvider: (code: string) => TransformResult;
+declare const wrapRootWithProvider: (code: string, localeSegment: string) => TransformResult;
 //#endregion
 export { TransformResult, wrapRootWithProvider };
 //# sourceMappingURL=transforms.d.ts.map

package/dist/types/init/frameworkSetup/tanstackStart/transforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/transforms.ts"],"mappings":";;KAWY;EACV;EACA;;;;;;;;;cAqJW,uBAAoB,iBAAmB"}
+{"version":3,"file":"transforms.d.ts","names":[],"sources":["../../../../../src/init/frameworkSetup/tanstackStart/transforms.ts"],"mappings":";;KAkBY;EACV;EACA;;;;;;;;;;;;;cAoMW,uBAAoB,cACnB,0BAEX"}

package/dist/types/loadDictionaries/log.d.ts

@@ -14,6 +14,7 @@ declare class DictionariesLogger {
   private remoteError;
   private pluginTotal;
   private pluginDone;
+  private pluginNames;
   private pluginError;
   constructor();
   setExpectRemote(expect: boolean): void;
@@ -24,9 +25,23 @@ declare class DictionariesLogger {
   private startSpinner;
   private stopSpinner;
   setRemoteError: (error?: Error) => void;
+  /**
+   * Register the names of the plugins providing dictionaries.
+   * They are displayed next to the plugin progress counters, e.g.
+   * `Plugin content: 6/6 (sync-json, load-po)`.
+   *
+   * @param names - Names of the plugins exposing a `loadDictionaries` hook
+   */
+  setPluginNames(names: string[]): void;
   setPluginTotal(total: number): void;
   setPluginDone(done: number): void;
-  setPluginError(error?: Error): void;
+  /**
+   * Flag the plugin line as errored.
+   *
+   * @param error - Error thrown while loading the plugin dictionaries
+   * @param pluginName - Name of the plugin that threw, prefixed to the message
+   */
+  setPluginError(error?: Error, pluginName?: string): void;
   private render;
   private computeProgress;
 }

package/dist/types/loadDictionaries/log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/loadDictionaries/log.ts"],"mappings":";;cAYa;UACH;UACA;UACA;UACA;mBACS;UACT;mBACS;UACT;UACA;UACA;UACA;UACA;UACA;UACA;EAER;EAIA,gBAAgB;EAIhB;EAOA;EAIA,OAAO,aAAa;EAyBpB;UAOQ;UAQA;EAMD,iBAAc,QAAY;EAQjC,eAAe;EASf,cAAc;EAMd,eAAe,QAAQ;UAMf;UAqGA"}
+{"version":3,"file":"log.d.ts","names":[],"sources":["../../../src/loadDictionaries/log.ts"],"mappings":";;cAYa;UACH;UACA;UACA;UACA;mBACS;UACT;mBACS;UACT;UACA;UACA;UACA;UACA;UACA;UACA;UACA;EAER;EAIA,gBAAgB;EAIhB;EAOA;EAIA,OAAO,aAAa;EAyBpB;UAOQ;UAQA;EAMD,iBAAc,QAAY;;;;;;;;EAejC,eAAe;EAOf,eAAe;EASf,cAAc;;;;;;;EAYd,eAAe,QAAQ,OAAO;UAStB;UA0GA"}

package/dist/types/utils/chunkArray.d.ts

@@ -0,0 +1,16 @@
+//#region src/utils/chunkArray.d.ts
+/**
+ * Splits an array into consecutive chunks of at most `chunkSize` items.
+ *
+ * The last chunk holds the remainder and may be smaller. An empty input, or a
+ * `chunkSize` lower than 1, returns an empty list of chunks.
+ *
+ * @example
+ * ```ts
+ * chunkArray(['a', 'b', 'c', 'd', 'e'], 2); // [['a', 'b'], ['c', 'd'], ['e']]
+ * ```
+ */
+declare const chunkArray: <T>(items: T[], chunkSize: number) => T[][];
+//#endregion
+export { chunkArray };
+//# sourceMappingURL=chunkArray.d.ts.map

package/dist/types/utils/chunkArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunkArray.d.ts","names":[],"sources":["../../../src/utils/chunkArray.ts"],"mappings":";;;;;;;;;;;;cAWa,aAAc,GAAC,OAAS,KAAG,sBAAsB"}

package/dist/types/utils/index.d.ts

@@ -1,6 +1,7 @@
 import { Extension, Format, getExtensionFromFormat, getFormatFromExtension } from "./getFormatFromExtension.js";
 import { autoDecorateContent } from "./autoDecorateContent.js";
 import { buildComponentFilesList } from "./buildComponentFilesList.js";
+import { chunkArray } from "./chunkArray.js";
 import { JSONObject, JsonChunk, assembleJSON, chunkJSON, reconstructFromSingleChunk } from "./chunkJSON.js";
 import { formatLocale, formatPath } from "./formatter.js";
 import { getChunk } from "./getChunk.js";
@@ -18,4 +19,4 @@ import { ParallelHandle, runParallel } from "./runParallel/index.js";
 import { sortAlphabetically } from "./sortAlphabetically.js";
 import { splitTextByLines } from "./splitTextByLine.js";
 import { verifyIdenticObjectFormat } from "./verifyIdenticObjectFormat.js";
-export { Extension, Format, JSONObject, JsonChunk, ParallelHandle, Primitive, Queue, Recursive, RunOnceContext, assembleJSON, autoDecorateContent, buildComponentFilesList, chunkJSON, excludeObjectFormat, formatLocale, formatPath, getChunk, getContentExtension, getExtensionFromFormat, getFormatFromExtension, getGlobalLimiter, getPathHash, getTaskLimiter, mergeChunks, pLimit, parallelize, parallelizeGlobal, reconstructFromSingleChunk, reduceObjectFormat, resolveObjectPromises, resolveRelativePath, runOnce, runParallel, sortAlphabetically, splitTextByLines, verifyIdenticObjectFormat };
+export { Extension, Format, JSONObject, JsonChunk, ParallelHandle, Primitive, Queue, Recursive, RunOnceContext, assembleJSON, autoDecorateContent, buildComponentFilesList, chunkArray, chunkJSON, excludeObjectFormat, formatLocale, formatPath, getChunk, getContentExtension, getExtensionFromFormat, getFormatFromExtension, getGlobalLimiter, getPathHash, getTaskLimiter, mergeChunks, pLimit, parallelize, parallelizeGlobal, reconstructFromSingleChunk, reduceObjectFormat, resolveObjectPromises, resolveRelativePath, runOnce, runParallel, sortAlphabetically, splitTextByLines, verifyIdenticObjectFormat };

package/dist/types/writeContentDeclaration/transformJSFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformJSFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/transformJSFile.ts"],"mappings":";;;;;;cAwmBa,kBAAe,qBACP,YACP,YAAU,iBACL,QAAM,yBAEtB"}
+{"version":3,"file":"transformJSFile.d.ts","names":[],"sources":["../../../src/writeContentDeclaration/transformJSFile.ts"],"mappings":";;;;;;cAixBa,kBAAe,qBACP,YACP,YAAU,iBACL,QAAM,yBAEtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/engine",
-  "version": "9.2.0",
+  "version": "9.3.1",
   "private": false,
   "description": "Scans and builds Intlayer declaration files into dictionaries based on Intlayer configuration.",
   "keywords": [
@@ -141,22 +141,22 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.2.0",
-    "@intlayer/config": "9.2.0",
-    "@intlayer/core": "9.2.0",
-    "@intlayer/dictionaries-entry": "9.2.0",
-    "@intlayer/remote-dictionaries-entry": "9.2.0",
-    "@intlayer/types": "9.2.0",
-    "@intlayer/unmerged-dictionaries-entry": "9.2.0",
+    "@intlayer/api": "9.3.1",
+    "@intlayer/config": "9.3.1",
+    "@intlayer/core": "9.3.1",
+    "@intlayer/dictionaries-entry": "9.3.1",
+    "@intlayer/remote-dictionaries-entry": "9.3.1",
+    "@intlayer/types": "9.3.1",
+    "@intlayer/unmerged-dictionaries-entry": "9.3.1",
     "@parcel/watcher": "2.6.0",
     "defu": "6.1.7",
     "fast-glob": "3.3.3",
-    "recast": "0.23.14",
+    "recast": "0.24.0",
     "simple-git": "3.36.0",
     "zod-to-ts": "2.1.0"
   },
   "devDependencies": {
-    "@types/node": "26.1.2",
+    "@types/node": "26.2.0",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
@@ -167,7 +167,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "@intlayer/babel": "9.2.0"
+    "@intlayer/babel": "9.3.1"
   },
   "peerDependenciesMeta": {
     "@intlayer/babel": {