@intlayer/config 9.1.3 → 9.3.0

package/dist/types/configFile/buildBrowserConfiguration.d.ts

@@ -41,19 +41,18 @@ declare const buildRoutingFields: (customConfiguration?: Partial<CustomRoutingCo
  * (`clientId`, `clientSecret`). The browser-safe {@link BrowserIntlayerConfig}
  * omits those fields when exposing config to the client.
  *
- * When the user does not explicitly set `clientId` / `clientSecret` in the
- * configuration file, they fall back to the `INTLAYER_CLIENT_ID` /
- * `INTLAYER_CLIENT_SECRET` environment variables read from `env`. This lets
- * users authenticate purely through their `.env` file (including files passed
- * via the CLI `--env-file` flag) without having to wire `process.env` into the
- * configuration manually.
+ * `clientId` / `clientSecret` are never inferred from the environment: the
+ * configuration file is the single source of truth. A project that wants to
+ * authenticate from its `.env` file must wire the variables explicitly, e.g.
+ * `clientId: process.env.INTLAYER_CLIENT_ID`. Commenting those lines out is
+ * therefore enough to disable every credentialed behaviour (remote dictionary
+ * fetching, CMS access) even when the variables remain defined in the
+ * environment.
  *
  * @param customConfiguration - Partial user-supplied editor config.
- * @param env - Environment variables used to resolve credential fallbacks.
- *   Defaults to `process.env`.
  * @returns A fully-defaulted {@link EditorConfig}.
  */
-declare const buildEditorFields: (customConfiguration?: Partial<EditorConfig>, env?: NodeJS.ProcessEnv) => EditorConfig;
+declare const buildEditorFields: (customConfiguration?: Partial<EditorConfig>) => EditorConfig;
 /**
  * Build the analytics section of the Intlayer configuration.
  *

package/dist/types/configFile/buildBrowserConfiguration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildBrowserConfiguration.d.ts","names":[],"sources":["../../../src/configFile/buildBrowserConfiguration.ts"],"mappings":";;;;;;;;;KAqDY;EACV,sBAAsB,KACpB;EAGF,SAAS;EACT,QAAQ,KAAK;EACb,WAAW;EACX,KAAK,KAAK;;QAGJ;YACI;;IAER,kBAAkB;;;;;;;;;cAiBT,kCAA+B,sBACpB,QAAQ,gCAC7B;;;;;;;cA+CU,qBAAkB,sBACP,QAAQ,yBAC7B;;;;;;;;;;;;;;;;;;;;cAwHU,oBAAiB,sBACN,QAAQ,eAAa,MACtC,OAAO,eACX;;;;;;;;;;;cAuIU,uBAAoB,sBACT,QAAQ,qBAC7B;;;;;;;;cA8BU,iBAAc,sBACH,QAAQ,YAAU,eACzB,iBACd;;;;;;;;;;;;;;;;;;;;;;;cAwDU,4BAAyB,eACrB,yBACd;;;;;;;;;;;;cAiCU,8BAA2B,QAC9B,mBACP"}
+{"version":3,"file":"buildBrowserConfiguration.d.ts","names":[],"sources":["../../../src/configFile/buildBrowserConfiguration.ts"],"mappings":";;;;;;;;;KAqDY;EACV,sBAAsB,KACpB;EAGF,SAAS;EACT,QAAQ,KAAK;EACb,WAAW;EACX,KAAK,KAAK;;QAGJ;YACI;;IAER,kBAAkB;;;;;;;;;cAiBT,kCAA+B,sBACpB,QAAQ,gCAC7B;;;;;;;cA+CU,qBAAkB,sBACP,QAAQ,yBAC7B;;;;;;;;;;;;;;;;;;;cA4HU,oBAAiB,sBACN,QAAQ,kBAC7B;;;;;;;;;;;cAsIU,uBAAoB,sBACT,QAAQ,qBAC7B;;;;;;;;cA8BU,iBAAc,sBACH,QAAQ,YAAU,eACzB,iBACd;;;;;;;;;;;;;;;;;;;;;;;cAwDU,4BAAyB,eACrB,yBACd;;;;;;;;;;;;cAiCU,8BAA2B,QAC9B,mBACP"}

package/dist/types/configFile/buildConfigurationFields.d.ts

@@ -17,14 +17,9 @@ import { CustomIntlayerConfig, IntlayerConfig, LogFunctions } from "@intlayer/ty
  * @param customConfiguration - Optional user-supplied configuration object.
  * @param baseDir - Project root directory. Defaults to `process.cwd()`.
  * @param logFunctions - Optional custom logging functions.
- * @param env - Environment variables used to resolve credential fallbacks
- *   (e.g. `INTLAYER_CLIENT_ID` / `INTLAYER_CLIENT_SECRET`). Defaults to
- *   `process.env`. Callers loading a custom env file (such as the CLI
- *   `--env-file` flag) should pass the merged env so credentials defined there
- *   are picked up without polluting `process.env`.
  * @returns A fully-built {@link IntlayerConfig}.
  */
-declare const buildConfigurationFields: (customConfiguration?: CustomIntlayerConfig, baseDir?: string, logFunctions?: LogFunctions, env?: NodeJS.ProcessEnv) => IntlayerConfig;
+declare const buildConfigurationFields: (customConfiguration?: CustomIntlayerConfig, baseDir?: string, logFunctions?: LogFunctions) => IntlayerConfig;
 //#endregion
 export { type BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildConfigurationFields, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
 //# sourceMappingURL=buildConfigurationFields.d.ts.map

package/dist/types/configFile/buildConfigurationFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildConfigurationFields.d.ts","names":[],"sources":["../../../src/configFile/buildConfigurationFields.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cAivBa,2BAAwB,sBACb,sBAAoB,kBAC1B,eACD,cAAY,MACtB,OAAO,eACX"}
+{"version":3,"file":"buildConfigurationFields.d.ts","names":[],"sources":["../../../src/configFile/buildConfigurationFields.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cA4uBa,2BAAwB,sBACb,sBAAoB,kBAC1B,eACD,iBACd"}

package/dist/types/configFile/getConfiguration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getConfiguration.d.ts","names":[],"sources":["../../../src/configFile/getConfiguration.ts"],"mappings":";;;;KAeY;EACV;EACA,WAAW;EAEX;EACA;EAEA,eAAe;EAEf,UAAU,OAAO;EAEjB;EAEA,eAAe;IACb,KAAK;KAEG;EACV,eAAe;EACf,qBAAqB;EACrB;EACA;;;;;cAMW,8BAA2B,UAC5B,4BACT;;;;cAiHU,mBAAgB,UACjB,4BACT"}
+{"version":3,"file":"getConfiguration.d.ts","names":[],"sources":["../../../src/configFile/getConfiguration.ts"],"mappings":";;;;KAcY;EACV;EACA,WAAW;EAEX;EACA;EAEA,eAAe;EAEf,UAAU,OAAO;EAEjB;EAEA,eAAe;IACb,KAAK;KAEG;EACV,eAAe;EACf,qBAAqB;EACrB;EACA;;;;;cAMW,8BAA2B,UAC5B,4BACT;;;;cAqGU,mBAAgB,UACjB,4BACT"}

package/dist/types/defaultValues/routing.d.ts

@@ -6,7 +6,13 @@ declare const LOCALE_STORAGE_NAME = "INTLAYER_LOCALE";
 declare const BASE_PATH = "";
 declare const SERVER_SET_COOKIE = "always";
 declare const ROUTING_MODE = "prefix-no-default";
-declare const ENABLE_PROXY = true;
+/**
+ * Left `undefined` on purpose: it selects the proxy's *auto* mode, which keeps
+ * locale routing URL-driven on development and preview servers while behaving
+ * like `true` in production. `true` and `false` are the explicit opt-in and
+ * opt-out. See `resolveProxyMode` in `@intlayer/core/localization`.
+ */
+declare const ENABLE_PROXY: boolean | undefined;
 declare const STORAGE: RoutingStorageInput;
 //#endregion
 export { BASE_PATH, COOKIE_NAME, ENABLE_PROXY, HEADER_NAME, LOCALE_STORAGE_NAME, ROUTING_MODE, SERVER_SET_COOKIE, STORAGE };

package/dist/types/defaultValues/routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routing.d.ts","names":[],"sources":["../../../src/defaultValues/routing.ts"],"mappings":";;cAEa;cAEA;cACA;cAEA;cAEA;cAEA;cAEA;cAEA,SAAS"}
+{"version":3,"file":"routing.d.ts","names":[],"sources":["../../../src/defaultValues/routing.ts"],"mappings":";;cAEa;cAEA;cACA;cAEA;cAEA;cAEA;;;;;;;cAQA;cAEA,SAAS"}

package/dist/types/envVars/envVars.d.ts

@@ -31,6 +31,28 @@ declare const formatNodeTypeToEnvVar: (nodeTypes: string[], wrapKey?: (key: stri
  * // { 'process.env.INTLAYER_DICTIONARY_SELECTOR': '"false"' }
  */
 declare const formatDictionarySelectorEnvVar: (hasDictionarySelector: boolean, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
+/**
+ * Returns the env-var definition selecting the local `nest()` resolver, which
+ * reads the nest targets the optimizer attached to each dictionary instead of
+ * looking them up in the global registry.
+ *
+ * Emit it only when the optimize transform actually runs, since it is that
+ * transform which injects the attachment. Setting it to `"true"` lets bundlers
+ * dead-code-eliminate the registry-based resolver, and with it the
+ * `@intlayer/dictionaries-entry` import — which is what allows the dictionaries
+ * entry to be emptied while nesting keeps working.
+ *
+ * @example
+ * formatOptimizedNestingEnvVar(true)
+ * // { INTLAYER_OPTIMIZED_NESTING: '"true"' }
+ *
+ * formatOptimizedNestingEnvVar(false)
+ * // {}
+ *
+ * formatOptimizedNestingEnvVar(true, (k) => `process.env.${k}`, (v) => `"${v}"`)
+ * // { 'process.env.INTLAYER_OPTIMIZED_NESTING': '"true"' }
+ */
+declare const formatOptimizedNestingEnvVar: (isOptimized: boolean, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
 /**
  * Returns env-var definitions for the full Intlayer config to be injected at
  * build time. Allows bundlers to dead-code-eliminate unused routing modes,
@@ -45,5 +67,5 @@ declare const formatDictionarySelectorEnvVar: (hasDictionarySelector: boolean, w
  */
 declare const getConfigEnvVars: (config: IntlayerConfig, wrapKey?: (key: string) => string, wrapValue?: (value: string) => string) => Record<string, string>;
 //#endregion
-export { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, getConfigEnvVars };
+export { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, formatOptimizedNestingEnvVar, getConfigEnvVars };
 //# sourceMappingURL=envVars.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"envVars.d.ts","names":[],"sources":["../../../src/envVars/envVars.ts"],"mappings":";;;;;;;;;;;;;cA2Ba,yBAAsB,qBACd,WAAA,wBACG,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;cA4BU,iCAA8B,gCACX,WAAA,wBACR,aAAA,6BAErB;;;;;;;;;;;;;cAiBU,mBAAgB,QACnB,gBAAc,WAAA,wBACA,aAAA,6BAErB"}
+{"version":3,"file":"envVars.d.ts","names":[],"sources":["../../../src/envVars/envVars.ts"],"mappings":";;;;;;;;;;;;;cA2Ba,yBAAsB,qBACd,WAAA,wBACG,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;cA4BU,iCAA8B,gCACX,WAAA,wBACR,aAAA,6BAErB;;;;;;;;;;;;;;;;;;;;;;cA0BU,+BAA4B,sBACnB,WAAA,wBACE,aAAA,6BAErB;;;;;;;;;;;;;cAiBU,mBAAgB,QACnB,gBAAc,WAAA,wBACA,aAAA,6BAErB"}

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

@@ -1,2 +1,2 @@
-import { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, getConfigEnvVars } from "./envVars.js";
-export { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, getConfigEnvVars };
+import { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, formatOptimizedNestingEnvVar, getConfigEnvVars } from "./envVars.js";
+export { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, formatOptimizedNestingEnvVar, getConfigEnvVars };

package/dist/types/loadExternalFile/bundleJSFile.d.ts

@@ -35,6 +35,7 @@ declare const bundleJSFile: (buildOptions: BuildOptions) => Promise<import("esbu
   color?: boolean;
   logLimit?: number;
   logOverride?: Record<string, import("esbuild").LogLevel>;
+  logStyle?: import("esbuild").LogStyle;
   tsconfigRaw?: string | import("esbuild").TsconfigRaw;
   splitting?: boolean;
   preserveSymlinks?: boolean;

package/dist/types/loadExternalFile/bundleJSFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundleJSFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/bundleJSFile.ts"],"mappings":";;cAyBa,eAAY,cAAwB,iBAAY,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAZlD;aACC;aACA;aACD;aACC;aACA;aACC;aACF;aACC"}
+{"version":3,"file":"bundleJSFile.d.ts","names":[],"sources":["../../../src/loadExternalFile/bundleJSFile.ts"],"mappings":";;cAyBa,eAAY,cAAwB,iBAAY,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAZlD;aACC;aACA;aACD;aACC;aACA;aACC;aACF;aACC"}

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

@@ -4,6 +4,12 @@ type RetryManagerOptions = {
   maxRetry?: number;
   /** delay between attempts, in milliseconds */
   delay?: number;
+  /**
+   * Decides whether a given error is worth another attempt. Returning `false`
+   * gives up immediately, which avoids replaying a request that can only fail
+   * again (ex: a `404`). Every error is retried when omitted.
+   */
+  shouldRetry?: (error: unknown) => boolean;
   /** function to call when an error occurs */
   onError?: (details: {
     error: string;
@@ -24,7 +30,7 @@ type RetryManagerOptions = {
  * @param options  { maxRetry, delay }
  * @returns        A new function with the same signature as `fn`
  */
-declare const retryManager: <Args extends any[], R>(fn: (...args: Args) => Promise<R>, { maxRetry, delay, onError, onMaxTryReached }?: RetryManagerOptions) => ((...args: Args) => Promise<R>);
+declare const retryManager: <Args extends any[], R>(fn: (...args: Args) => Promise<R>, { maxRetry, delay, shouldRetry, onError, onMaxTryReached }?: RetryManagerOptions) => ((...args: Args) => Promise<R>);
 //#endregion
 export { RetryManagerOptions, retryManager };
 //# sourceMappingURL=retryManager.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"retryManager.d.ts","names":[],"sources":["../../../src/utils/retryManager.ts"],"mappings":";KAGY;;EAEV;;EAEA;;EAEA,WAAW;IACT;IACA;IACA;;;EAGF,mBAAmB;IACjB;IACA;IACA;;;;;;;;;;cAcS,eACV,oBAAoB,GAAC,QACZ,MAAM,SAAS,QAAQ,MAAE,UAAA,OAAA,SAAA,oBAM9B,6BACG,MAAM,SAAS,QAAQ"}
+{"version":3,"file":"retryManager.d.ts","names":[],"sources":["../../../src/utils/retryManager.ts"],"mappings":";KAGY;;EAEV;;EAEA;;;;;;EAMA,eAAe;;EAEf,WAAW;IACT;IACA;IACA;;;EAGF,mBAAmB;IACjB;IACA;IACA;;;;;;;;;;cAcS,eACV,oBAAoB,GAAC,QACZ,MAAM,SAAS,QAAQ,MAAE,UAAA,OAAA,aAAA,SAAA,oBAO9B,6BACG,MAAM,SAAS,QAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/config",
-  "version": "9.1.3",
+  "version": "9.3.0",
   "private": false,
   "description": "Retrieve Intlayer configurations and manage environment variables for both server-side and client-side environments.",
   "keywords": [
@@ -164,15 +164,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/types": "9.1.3",
+    "@intlayer/types": "9.3.0",
     "defu": "6.1.7",
     "dotenv": "17.4.2",
-    "esbuild": "0.28.1",
+    "esbuild": "0.28.2",
     "json5": "2.2.3",
     "zod": "4.4.3"
   },
   "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",