@intlayer/config 9.0.0-canary.8 → 9.0.0

package/dist/types/callers/types.d.ts

@@ -0,0 +1,160 @@
+//#region src/callers/types.d.ts
+/**
+ * Shared caller-descriptor model.
+ *
+ * A "caller" is any function or JSX component through which application code
+ * reads intlayer content: the base getters (`useIntlayer`, `getIntlayer`) and
+ * every compat-adapter entry point (`useTranslation`, `useTranslations`,
+ * `formatMessage`, lingui's `t`/`_`, …).
+ *
+ * This registry is the single source of truth consumed by:
+ * - `@intlayer/babel` — field-usage analysis (purge/minify) and the optimize
+ *   pass that rewrites caller invocations to `useDictionary(...)` /
+ *   `useDictionaryDynamic(...)` with pre-imported dictionaries.
+ * - `@intlayer/swc` — the same optimize pass for Next.js builds; descriptors
+ *   are serialised to the plugin's wire format via `toSwcExtraCallers`.
+ * - `@intlayer/lsp` and the VS Code extension — AST/regex matchers powering
+ *   go-to-definition, references and completion.
+ * - Each compat package's bundler plugin — injects its library's descriptors
+ *   into the pipelines above, so no compat-specific name is hard-coded in the
+ *   core packages.
+ */
+/**
+ * Where a value (namespace/dictionary key, or key prefix) is read from a call
+ * expression.
+ */
+type CallerValueSource =
+/** Positional argument holding a string literal, e.g. `useTranslations('ns')`. */
+{
+  from: 'argument';
+  index: number;
+} |
+/** Property of an options-object argument, e.g. `useI18n({ namespace: 'ns' })`. */
+{
+  from: 'option';
+  argumentIndex: number;
+  property: string;
+} |
+/**
+ * Compile-time constant — every call site reads the same dictionary.
+ * Used by single-catalog libraries such as lingui (`messages`).
+ */
+{
+  from: 'fixed';
+  value: string;
+} |
+/**
+ * The first dot-segment of the message id passed to the call itself.
+ * Used by react-intl where `formatMessage({ id: 'home.title' })` encodes
+ * both the dictionary key (`home`) and the field path (`title`).
+ */
+{
+  from: 'path-first-segment';
+};
+/**
+ * How translated content is obtained from the caller's result.
+ *
+ * - `'content'`        — returns the dictionary content object; fields are
+ *                        read through member access or destructuring
+ *                        (`useIntlayer`, `getIntlayer`).
+ * - `'return-value'`   — returns the translation function directly:
+ *                        `const t = useTranslations('ns'); t('key')`.
+ * - `'destructured-t'` — returns an object holding `t`:
+ *                        `const { t } = useTranslation('ns'); t('key')`.
+ * - `'self'`           — the caller IS the translation call; the message id is
+ *                        one of its own arguments (`formatMessage`, `i18n._`).
+ * - `'all'`            — field-level analysis is impossible; the whole
+ *                        dictionary is marked as used (Angular templates,
+ *                        lingui hashed ids).
+ */
+type CallerResultShape = 'content' | 'return-value' | 'destructured-t' | 'self' | 'all';
+/**
+ * Full description of a single caller.
+ */
+type CallerDescriptor = {
+  /** Function or JSX component name, e.g. `'useTranslation'`, `'FormattedMessage'`. */
+  callerName: string;
+  /** Library identifier grouping related callers, e.g. `'react-i18next'`. */
+  library: string;
+  /**
+   * Module specifiers the caller may be imported from. Includes both the
+   * original library names and the `@intlayer/*` adapter equivalents, because
+   * bundler aliasing keeps user imports on the original names.
+   */
+  importSources: string[];
+  /**
+   * When `true`, the caller only participates in matching when the analysed
+   * file imports from one of `importSources`. Used for generic names such as
+   * lingui's `t` / `_` that would otherwise produce false positives.
+   */
+  requiresImport?: boolean;
+  /**
+   * When `true`, the caller is also matched as a method on any object
+   * (`i18n.getFixedT(...)`, `intl.formatMessage(...)`) in addition to the
+   * bare-identifier form.
+   */
+  matchAsMethod?: boolean;
+  /** When `true`, also match the tagged-template form, e.g. lingui's ``t`…` ``. */
+  matchAsTaggedTemplate?: boolean;
+  /**
+   * When set, the caller is also matched as a JSX element whose attribute of
+   * this name holds the message id, e.g. `<FormattedMessage id="home.title" />`
+   * or `<Trans i18nKey="richText" />`.
+   */
+  jsxIdAttribute?: string;
+  /**
+   * Optional JSX attribute carrying the namespace (dictionary key), e.g.
+   * react-i18next's `<Trans ns="home" i18nKey="title" />`.
+   */
+  jsxNamespaceAttribute?: string;
+  /**
+   * Where the dictionary key is read from, tried in declaration order.
+   * The first source that yields a static string wins.
+   */
+  namespaceSources: CallerValueSource[];
+  /**
+   * Optional key prefix prepended to every message path resolved through the
+   * returned translation function, e.g. `getFixedT(lng, ns, keyPrefix)` or
+   * `useTranslation(ns, { keyPrefix })`.
+   */
+  keyPrefixSources?: CallerValueSource[];
+  /**
+   * When `true`, a dotted namespace is split at the first `.`: the first
+   * segment is the dictionary key and the rest becomes a key prefix.
+   * next-intl semantics: `useTranslations('about.counter')` reads the
+   * `about` dictionary with every `t()` path prefixed by `counter`.
+   */
+  nestedNamespace?: boolean;
+  /**
+   * When `true`, the caller may be invoked without any namespace
+   * (`useTranslations()` root scope) — the dictionary key is then the first
+   * dot-segment of each message id passed to the returned `t()`.
+   */
+  allowRootScope?: boolean;
+  /** How translated content is obtained from the caller's result. */
+  translationFunction: CallerResultShape;
+  /**
+   * When `true`, the message id is a *flat* dictionary field that itself may
+   * contain dots (lingui catalogs). When unset, dotted ids map onto nested
+   * dictionary objects and are split into a field path.
+   */
+  flatKey?: boolean;
+  /**
+   * Name of the dictionary-accepting replacement used by the optimize pass in
+   * static import mode, e.g. `'useDictionary'`. The replacement must be
+   * exported from every module in `importSources` (the compat package exports
+   * it; original-library specifiers are bundler-aliased to the compat package).
+   *
+   * Only callers with both replacements set — and matched as plain imported
+   * functions (not `matchAsMethod` / JSX) — are rewritten at build time.
+   */
+  staticReplacement?: string;
+  /**
+   * Name of the dictionary-accepting replacement used by the optimize pass in
+   * dynamic/fetch import mode, e.g. `'useDictionaryDynamic'`.
+   */
+  dynamicReplacement?: string;
+};
+//#endregion
+export { CallerDescriptor, CallerResultShape, CallerValueSource };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/callers/types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;KAyBY;;;EAEN;EAAkB;;;;EAElB;EAAgB;EAAuB;;;;;;;EAKvC;EAAe;;;;;;;;EAMf;;;;;;;;;;;;;;;;;;KAkBM;;;;KAUA;;EAEV;;EAEA;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA;;EAEA;;;;;;EAMA;;;;;EAKA;;;;;EAKA,kBAAkB;;;;;;EAMlB,mBAAmB;;;;;;;EAOnB;;;;;;EAMA;;EAEA,qBAAqB;;;;;;EAMrB;;;;;;;;;;EAUA;;;;;EAKA"}

package/dist/types/client.d.ts

@@ -1,4 +1,4 @@
-import { BrowserIntlayerConfig, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./configFile/buildBrowserConfiguration.js";
+import { BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./configFile/buildBrowserConfiguration.js";
 import { extractErrorMessage } from "./utils/extractErrorMessage.js";
 import { logStack } from "./utils/logStack.js";
 import { normalizePath } from "./utils/normalizePath.js";
@@ -7,4 +7,4 @@ import { camelCaseToKebabCase } from "./utils/stringFormatter/camelCaseToKebabCa
 import { camelCaseToSentence } from "./utils/stringFormatter/camelCaseToSentence.js";
 import { kebabCaseToCamelCase } from "./utils/stringFormatter/kebabCaseToCamelCase.js";
 import { toLowerCamelCase } from "./utils/stringFormatter/toLowerCamelCase.js";
-export { BrowserIntlayerConfig, WindowsWithIntlayer, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, camelCaseToKebabCase, camelCaseToSentence, extractBrowserConfiguration, extractErrorMessage, kebabCaseToCamelCase, logStack, normalizePath, setIntlayerIdentifier, toLowerCamelCase };
+export { BrowserIntlayerConfig, WindowsWithIntlayer, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, camelCaseToKebabCase, camelCaseToSentence, extractBrowserConfiguration, extractErrorMessage, kebabCaseToCamelCase, logStack, normalizePath, setIntlayerIdentifier, toLowerCamelCase };

package/dist/types/colors.d.ts

@@ -1,20 +1,20 @@
 declare namespace colors_d_exports {
   export { BEIGE, BLUE, BOLD, CYAN, GREEN, GREY, GREY_DARK, GREY_LIGHT, MAGENTA, ORANGE, RED, RESET, WHITE, YELLOW };
 }
-declare const RESET: "\u001B[0m";
-declare const GREY: "\u001B[90m";
-declare const GREY_DARK: "\u001B[38;5;239m";
-declare const GREY_LIGHT: "\u001B[38;5;252m";
-declare const BLUE: "\u001B[34m";
-declare const RED: "\u001B[31m";
-declare const GREEN: "\u001B[32m";
-declare const YELLOW: "\u001B[38;5;226m";
-declare const MAGENTA: "\u001B[35m";
-declare const BEIGE: "\u001B[38;5;3m";
-declare const ORANGE: "\u001B[38;5;208m";
-declare const CYAN: "\u001B[36m";
-declare const WHITE: "\u001B[37m";
-declare const BOLD: "\u001B[1m";
+declare const RESET: '';
+declare const GREY: '';
+declare const GREY_DARK: '';
+declare const GREY_LIGHT: '';
+declare const BLUE: '';
+declare const RED: '';
+declare const GREEN: '';
+declare const YELLOW: '';
+declare const MAGENTA: '';
+declare const BEIGE: '';
+declare const ORANGE: '';
+declare const CYAN: '';
+declare const WHITE: '';
+declare const BOLD: '';
 //#endregion
 export { BEIGE, BLUE, BOLD, CYAN, GREEN, GREY, GREY_DARK, GREY_LIGHT, MAGENTA, ORANGE, RED, RESET, WHITE, YELLOW, colors_d_exports };
 //# sourceMappingURL=colors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"colors.d.ts","names":[],"sources":["../../src/colors.ts"],"mappings":";;;cAAa,KAAA;AAAA,cACA,IAAA;AAAA,cACA,SAAA;AAAA,cACA,UAAA;AAAA,cACA,IAAA;AAAA,cACA,GAAA;AAAA,cACA,KAAA;AAAA,cACA,MAAA;AAAA,cACA,OAAA;AAAA,cACA,KAAA;AAAA,cACA,MAAA;AAAA,cACA,IAAA;AAAA,cACA,KAAA;AAAA,cACA,IAAA"}
+{"version":3,"file":"colors.d.ts","names":[],"sources":["../../src/colors.ts"],"mappings":";;;cAAa;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA"}

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

@@ -1,5 +1,4 @@
-import { CustomIntlayerConfig, CustomRoutingConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RoutingConfig } from "@intlayer/types/config";
-
+import { AnalyticsConfig, CustomIntlayerConfig, CustomRoutingConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RoutingConfig } from "@intlayer/types/config";
 //#region src/configFile/buildBrowserConfiguration.d.ts
 /**
  * Browser-safe subset of {@link IntlayerConfig}.
@@ -12,6 +11,7 @@ type BrowserIntlayerConfig = {
   internationalization: Pick<InternationalizationConfig, 'locales' | 'defaultLocale'>;
   routing: RoutingConfig;
   editor: Omit<EditorConfig, 'clientId' | 'clientSecret'>;
+  analytics: AnalyticsConfig;
   log: Pick<LogConfig, 'mode' | 'prefix'>;
 };
 declare global {
@@ -41,10 +41,30 @@ 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.
+ *
  * @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>) => EditorConfig;
+declare const buildEditorFields: (customConfiguration?: Partial<EditorConfig>, env?: NodeJS.ProcessEnv) => EditorConfig;
+/**
+ * Build the analytics section of the Intlayer configuration.
+ *
+ * Analytics is strictly opt-in: `enabled` defaults to `false` and, even when
+ * enabled, the runtime additionally requires a project key (`editor.clientId`)
+ * for attribution before collecting anything.
+ *
+ * @param customConfiguration - Partial user-supplied analytics config.
+ * @returns A fully-defaulted {@link AnalyticsConfig}.
+ */
+declare const buildAnalyticsFields: (customConfiguration?: Partial<AnalyticsConfig>) => AnalyticsConfig;
 /**
  * Build the log section of the Intlayer configuration.
  *
@@ -89,5 +109,5 @@ declare const buildBrowserConfiguration: (customConfig?: CustomIntlayerConfig) =
  */
 declare const extractBrowserConfiguration: (config: IntlayerConfig) => BrowserIntlayerConfig;
 //#endregion
-export { BrowserIntlayerConfig, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
+export { BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
 //# sourceMappingURL=buildBrowserConfiguration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buildBrowserConfiguration.d.ts","names":[],"sources":["../../../src/configFile/buildBrowserConfiguration.ts"],"mappings":";;;;;AA+CA;;;;;KAAY,qBAAA;EACV,oBAAA,EAAsB,IAAA,CACpB,0BAAA;EAGF,OAAA,EAAS,aAAA;EACT,MAAA,EAAQ,IAAA,CAAK,YAAA;EACb,GAAA,EAAK,IAAA,CAAK,SAAA;AAAA;AAAA,QAGJ,MAAA;EAAA,UACI,MAAA;IAVY;IAYpB,eAAA,GAAkB,qBAAA;EAAA;AAAA;;;;;;;cAiBT,+BAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,0BAAA,MAC7B,0BAAA;;AAxBD;;;;;cAuEW,kBAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,mBAAA,MAC7B,aAAA;;;;;;AAnDH;;;;;cAkKa,iBAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,YAAA,MAC7B,YAAA;;;;;;;;cAmIU,cAAA,GACX,mBAAA,GAAsB,OAAA,CAAQ,SAAA,GAC9B,YAAA,GAAe,YAAA,KACd,SAAA;AAzPH;;;;;;;;;;;;;;AAiHA;;;;;;;;AAjHA,cAiTa,yBAAA,GACX,YAAA,GAAe,oBAAA,KACd,qBAAA;;;;;;AA7DH;;;;;;cA4Fa,2BAAA,GACX,MAAA,EAAQ,cAAA,KACP,qBAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
-import { BrowserIntlayerConfig, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./buildBrowserConfiguration.js";
+import { BrowserIntlayerConfig, buildAnalyticsFields, buildBrowserConfiguration, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration } from "./buildBrowserConfiguration.js";
 import { CustomIntlayerConfig, IntlayerConfig, LogFunctions } from "@intlayer/types/config";
-
 //#region src/configFile/buildConfigurationFields.d.ts
 /**
  * Build the complete Intlayer configuration by merging user-supplied values
@@ -18,9 +17,14 @@ 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) => IntlayerConfig;
+declare const buildConfigurationFields: (customConfiguration?: CustomIntlayerConfig, baseDir?: string, logFunctions?: LogFunctions, env?: NodeJS.ProcessEnv) => IntlayerConfig;
 //#endregion
-export { type BrowserIntlayerConfig, buildBrowserConfiguration, buildConfigurationFields, buildEditorFields, buildInternationalizationFields, buildLogFields, buildRoutingFields, extractBrowserConfiguration };
+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":";;;;;;AA0uBA;;;;;;;;;;;;;;;;cAAa,wBAAA,GACX,mBAAA,GAAsB,oBAAA,EACtB,OAAA,WACA,YAAA,GAAe,YAAA,KACd,cAAA"}
+{"version":3,"file":"buildConfigurationFields.d.ts","names":[],"sources":["../../../src/configFile/buildConfigurationFields.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cAivBa,2BAAwB,sBACb,sBAAoB,kBAC1B,eACD,cAAY,MACtB,OAAO,eACX"}

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

@@ -1,14 +1,13 @@
 import { AiProviders } from "@intlayer/types/config";
 import z from "zod";
-
 //#region src/configFile/configurationSchema.d.ts
 declare const internationalizationSchema: z.ZodObject<{
   locales: z.ZodArray<z.ZodString>;
   requiredLocales: z.ZodOptional<z.ZodArray<z.ZodString>>;
   strictMode: z.ZodOptional<z.ZodEnum<{
-    strict: "strict";
     inclusive: "inclusive";
     loose: "loose";
+    strict: "strict";
   }>>;
   defaultLocale: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -20,26 +19,26 @@ declare const cookiesAttributesSchema: z.ZodObject<{
   secure: z.ZodOptional<z.ZodBoolean>;
   httpOnly: z.ZodOptional<z.ZodBoolean>;
   sameSite: z.ZodOptional<z.ZodEnum<{
+    lax: "lax";
     none: "none";
     strict: "strict";
-    lax: "lax";
   }>>;
   expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
   maxAge: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const storageAttributesSchema: z.ZodObject<{
   type: z.ZodEnum<{
+    header: "header";
     localStorage: "localStorage";
     sessionStorage: "sessionStorage";
-    header: "header";
   }>;
   name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const storageSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum<{
   cookie: "cookie";
+  header: "header";
   localStorage: "localStorage";
   sessionStorage: "sessionStorage";
-  header: "header";
 }>, z.ZodObject<{
   type: z.ZodLiteral<"cookie">;
   name: z.ZodOptional<z.ZodString>;
@@ -48,24 +47,24 @@ declare const storageSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum
   secure: z.ZodOptional<z.ZodBoolean>;
   httpOnly: z.ZodOptional<z.ZodBoolean>;
   sameSite: z.ZodOptional<z.ZodEnum<{
+    lax: "lax";
     none: "none";
     strict: "strict";
-    lax: "lax";
   }>>;
   expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
   maxAge: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodEnum<{
+    header: "header";
     localStorage: "localStorage";
     sessionStorage: "sessionStorage";
-    header: "header";
   }>;
   name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
   cookie: "cookie";
+  header: "header";
   localStorage: "localStorage";
   sessionStorage: "sessionStorage";
-  header: "header";
 }>, z.ZodObject<{
   type: z.ZodLiteral<"cookie">;
   name: z.ZodOptional<z.ZodString>;
@@ -74,17 +73,17 @@ declare const storageSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum
   secure: z.ZodOptional<z.ZodBoolean>;
   httpOnly: z.ZodOptional<z.ZodBoolean>;
   sameSite: z.ZodOptional<z.ZodEnum<{
+    lax: "lax";
     none: "none";
     strict: "strict";
-    lax: "lax";
   }>>;
   expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
   maxAge: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodEnum<{
+    header: "header";
     localStorage: "localStorage";
     sessionStorage: "sessionStorage";
-    header: "header";
   }>;
   name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>]>>]>;
@@ -140,17 +139,17 @@ declare const routingSchema: z.ZodObject<{
     }, z.core.$strip>>;
   }, z.core.$strip>]>>;
   mode: z.ZodOptional<z.ZodEnum<{
-    "prefix-no-default": "prefix-no-default";
-    "prefix-all": "prefix-all";
     "no-prefix": "no-prefix";
+    "prefix-all": "prefix-all";
+    "prefix-no-default": "prefix-no-default";
     "search-params": "search-params";
   }>>;
   enableProxy: z.ZodOptional<z.ZodBoolean>;
   storage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum<{
     cookie: "cookie";
+    header: "header";
     localStorage: "localStorage";
     sessionStorage: "sessionStorage";
-    header: "header";
   }>, z.ZodObject<{
     type: z.ZodLiteral<"cookie">;
     name: z.ZodOptional<z.ZodString>;
@@ -159,24 +158,24 @@ declare const routingSchema: z.ZodObject<{
     secure: z.ZodOptional<z.ZodBoolean>;
     httpOnly: z.ZodOptional<z.ZodBoolean>;
     sameSite: z.ZodOptional<z.ZodEnum<{
+      lax: "lax";
       none: "none";
       strict: "strict";
-      lax: "lax";
     }>>;
     expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
     maxAge: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strip>, z.ZodObject<{
     type: z.ZodEnum<{
+      header: "header";
       localStorage: "localStorage";
       sessionStorage: "sessionStorage";
-      header: "header";
     }>;
     name: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>, z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
     cookie: "cookie";
+    header: "header";
     localStorage: "localStorage";
     sessionStorage: "sessionStorage";
-    header: "header";
   }>, z.ZodObject<{
     type: z.ZodLiteral<"cookie">;
     name: z.ZodOptional<z.ZodString>;
@@ -185,17 +184,17 @@ declare const routingSchema: z.ZodObject<{
     secure: z.ZodOptional<z.ZodBoolean>;
     httpOnly: z.ZodOptional<z.ZodBoolean>;
     sameSite: z.ZodOptional<z.ZodEnum<{
+      lax: "lax";
       none: "none";
       strict: "strict";
-      lax: "lax";
     }>>;
     expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
     maxAge: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strip>, z.ZodObject<{
     type: z.ZodEnum<{
+      header: "header";
       localStorage: "localStorage";
       sessionStorage: "sessionStorage";
-      header: "header";
     }>;
     name: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>]>>]>>;
@@ -234,18 +233,23 @@ declare const editorSchema: z.ZodObject<{
   clientId: z.ZodOptional<z.ZodString>;
   clientSecret: z.ZodOptional<z.ZodString>;
   dictionaryPriorityStrategy: z.ZodOptional<z.ZodEnum<{
-    local_first: "local_first";
     distant_first: "distant_first";
+    local_first: "local_first";
   }>>;
   liveSync: z.ZodOptional<z.ZodBoolean>;
   liveSyncPort: z.ZodOptional<z.ZodNumber>;
   liveSyncURL: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>>;
 }, z.core.$strip>;
+declare const analyticsSchema: z.ZodObject<{
+  enabled: z.ZodOptional<z.ZodBoolean>;
+  flushInterval: z.ZodOptional<z.ZodNumber>;
+  sampleRate: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 declare const logSchema: z.ZodObject<{
   mode: z.ZodOptional<z.ZodEnum<{
     default: "default";
-    verbose: "verbose";
     disabled: "disabled";
+    verbose: "verbose";
   }>>;
   prefix: z.ZodOptional<z.ZodString>;
   error: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
@@ -272,9 +276,9 @@ declare const buildSchema: z.ZodObject<{
   }>>;
   optimize: z.ZodOptional<z.ZodBoolean>;
   importMode: z.ZodOptional<z.ZodEnum<{
-    static: "static";
     dynamic: "dynamic";
     fetch: "fetch";
+    static: "static";
   }>>;
   traversePattern: z.ZodOptional<z.ZodArray<z.ZodString>>;
   outputFormat: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -310,9 +314,9 @@ declare const intlayerConfigSchema: z.ZodObject<{
     locales: z.ZodArray<z.ZodString>;
     requiredLocales: z.ZodOptional<z.ZodArray<z.ZodString>>;
     strictMode: z.ZodOptional<z.ZodEnum<{
-      strict: "strict";
       inclusive: "inclusive";
       loose: "loose";
+      strict: "strict";
     }>>;
     defaultLocale: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
@@ -338,17 +342,17 @@ declare const intlayerConfigSchema: z.ZodObject<{
       }, z.core.$strip>>;
     }, z.core.$strip>]>>;
     mode: z.ZodOptional<z.ZodEnum<{
-      "prefix-no-default": "prefix-no-default";
-      "prefix-all": "prefix-all";
       "no-prefix": "no-prefix";
+      "prefix-all": "prefix-all";
+      "prefix-no-default": "prefix-no-default";
       "search-params": "search-params";
     }>>;
     enableProxy: z.ZodOptional<z.ZodBoolean>;
     storage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum<{
       cookie: "cookie";
+      header: "header";
       localStorage: "localStorage";
       sessionStorage: "sessionStorage";
-      header: "header";
     }>, z.ZodObject<{
       type: z.ZodLiteral<"cookie">;
       name: z.ZodOptional<z.ZodString>;
@@ -357,24 +361,24 @@ declare const intlayerConfigSchema: z.ZodObject<{
       secure: z.ZodOptional<z.ZodBoolean>;
       httpOnly: z.ZodOptional<z.ZodBoolean>;
       sameSite: z.ZodOptional<z.ZodEnum<{
+        lax: "lax";
         none: "none";
         strict: "strict";
-        lax: "lax";
       }>>;
       expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
       maxAge: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
       type: z.ZodEnum<{
+        header: "header";
         localStorage: "localStorage";
         sessionStorage: "sessionStorage";
-        header: "header";
       }>;
       name: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
       cookie: "cookie";
+      header: "header";
       localStorage: "localStorage";
       sessionStorage: "sessionStorage";
-      header: "header";
     }>, z.ZodObject<{
       type: z.ZodLiteral<"cookie">;
       name: z.ZodOptional<z.ZodString>;
@@ -383,17 +387,17 @@ declare const intlayerConfigSchema: z.ZodObject<{
       secure: z.ZodOptional<z.ZodBoolean>;
       httpOnly: z.ZodOptional<z.ZodBoolean>;
       sameSite: z.ZodOptional<z.ZodEnum<{
+        lax: "lax";
         none: "none";
         strict: "strict";
-        lax: "lax";
       }>>;
       expires: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Date, Date>, z.ZodNumber, z.ZodString]>>;
       maxAge: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
       type: z.ZodEnum<{
+        header: "header";
         localStorage: "localStorage";
         sessionStorage: "sessionStorage";
-        header: "header";
       }>;
       name: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>]>>;
@@ -432,18 +436,23 @@ declare const intlayerConfigSchema: z.ZodObject<{
     clientId: z.ZodOptional<z.ZodString>;
     clientSecret: z.ZodOptional<z.ZodString>;
     dictionaryPriorityStrategy: z.ZodOptional<z.ZodEnum<{
-      local_first: "local_first";
       distant_first: "distant_first";
+      local_first: "local_first";
     }>>;
     liveSync: z.ZodOptional<z.ZodBoolean>;
     liveSyncPort: z.ZodOptional<z.ZodNumber>;
     liveSyncURL: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodLiteral<"">]>>;
   }, z.core.$strip>>;
+  analytics: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    flushInterval: z.ZodOptional<z.ZodNumber>;
+    sampleRate: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
   log: z.ZodOptional<z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
       default: "default";
-      verbose: "verbose";
       disabled: "disabled";
+      verbose: "verbose";
     }>>;
     prefix: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
@@ -470,9 +479,9 @@ declare const intlayerConfigSchema: z.ZodObject<{
     }>>;
     optimize: z.ZodOptional<z.ZodBoolean>;
     importMode: z.ZodOptional<z.ZodEnum<{
-      static: "static";
       dynamic: "dynamic";
       fetch: "fetch";
+      static: "static";
     }>>;
     traversePattern: z.ZodOptional<z.ZodArray<z.ZodString>>;
     outputFormat: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -512,5 +521,5 @@ declare const intlayerConfigSchema: z.ZodObject<{
   }, z.core.$strip>>;
 }, z.core.$strip>;
 //#endregion
-export { aiSchema, buildSchema, compilerSchema, contentSchema, cookiesAttributesSchema, dictionarySchema, editorSchema, internationalizationSchema, intlayerConfigSchema, logSchema, rewriteObjectSchema, rewriteRuleSchema, rewriteRulesSchema, routingSchema, storageAttributesSchema, storageSchema, systemSchema };
+export { aiSchema, analyticsSchema, buildSchema, compilerSchema, contentSchema, cookiesAttributesSchema, dictionarySchema, editorSchema, internationalizationSchema, intlayerConfigSchema, logSchema, rewriteObjectSchema, rewriteRuleSchema, rewriteRulesSchema, routingSchema, storageAttributesSchema, storageSchema, systemSchema };
 //# sourceMappingURL=configurationSchema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"configurationSchema.d.ts","names":[],"sources":["../../../src/configFile/configurationSchema.ts"],"mappings":";;;;cAGa,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;;;;;;;;cA+B1B,uBAAA,EAAuB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;cAYvB,uBAAA,EAAuB,CAAA,CAAA,SAAA;;;;;;;;cAKvB,aAAA,EAAa,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,UAAA,SAAA,CAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAcb,iBAAA,EAAiB,CAAA,CAAA,SAAA;;;;cAKjB,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;cAIlB,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;cAMnB,aAAA,EAAa,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgBb,YAAA,EAAY,CAAA,CAAA,SAAA;;;;;;;;;;;;;;cAeZ,aAAA,EAAa,CAAA,CAAA,SAAA;;;;;;;;cASb,YAAA,EAAY,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;cAiBZ,SAAA,EAAS,CAAA,CAAA,SAAA;;;;;;;;;;;;cAST,QAAA,EAAQ,CAAA,CAAA,SAAA;;;;;;;;;;;;cAUR,WAAA,EAAW,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;cAWX,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;;;;cAUd,gBAAA,EAAgB,CAAA,CAAA,SAAA;;;;;;;;;;;cAiBhB,oBAAA,EAAoB,CAAA,CAAA,SAAA"}
+{"version":3,"file":"configurationSchema.d.ts","names":[],"sources":["../../../src/configFile/configurationSchema.ts"],"mappings":";;;cAGa,4BAA0B,EAAA;;;;;;;;;GAKrC,EAAA,KAAA;cA0BW,yBAAuB,EAAA;;;;;;;;;;;;;;GAUlC,EAAA,KAAA;cAEW,yBAAuB,EAAA;;;;;;;GAGlC,EAAA,KAAA;cAEW,eAAa,EAAA,mBAAA,EAAA,mBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;cAEW,mBAAiB,EAAA;;;GAG5B,EAAA,KAAA;cAEW,oBAAkB,EAAA;;;;;GAE7B,EAAA,KAAA;cAEW,qBAAmB,EAAA;;;;;;;;;;;;;;;;;;;GAI9B,EAAA,KAAA;cAEW,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAcxB,EAAA,KAAA;cAEW,cAAY,EAAA;;;;;;;;;;;;;GAavB,EAAA,KAAA;cAEW,eAAa,EAAA;;;;;;;GAOxB,EAAA,KAAA;cAEW,cAAY,EAAA;;;;;;;;;;;;;;;;GAevB,EAAA,KAAA;cAEW,iBAAe,EAAA;;;;GAI1B,EAAA,KAAA;cAEW,WAAS,EAAA;;;;;;;;;;;GAOpB,EAAA,KAAA;cAEW,UAAQ,EAAA;;;;;;;;;;;GAQnB,EAAA,KAAA;cAEW,aAAW,EAAA;;;;;;;;;;;;;;;;;;;GAStB,EAAA,KAAA;cAEW,gBAAc,EAAA;;;;;;;;GAQzB,EAAA,KAAA;cAEW,kBAAgB,EAAA;;;;;;;;;;GAe3B,EAAA,KAAA;cAEW,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqB/B,EAAA,KAAA"}

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

@@ -1,7 +1,6 @@
 import { SandBoxContextOptions } from "../loadExternalFile/parseFileContent.js";
 import { LoadExternalFileOptions } from "../loadExternalFile/loadExternalFile.js";
 import { CustomIntlayerConfig, IntlayerConfig, LogFunctions } from "@intlayer/types/config";
-
 //#region src/configFile/getConfiguration.d.ts
 type GetConfigurationOptions = {
   baseDir?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"getConfiguration.d.ts","names":[],"sources":["../../../src/configFile/getConfiguration.ts"],"mappings":";;;;;KAcY,uBAAA;EACV,OAAA;EACA,QAAA,GAAW,oBAAA;EAEX,GAAA;EACA,OAAA;EAEA,YAAA,GAAe,YAAA;EAEf,OAAA,GAAU,MAAA,CAAO,OAAA;EAEjB,KAAA;EAEA,YAAA,GAAe,uBAAA;AAAA,IACb,IAAA,CAAK,qBAAA;AAAA,KAEG,iCAAA;EACV,aAAA,EAAe,cAAA;EACf,mBAAA,EAAqB,oBAAA;EACrB,sBAAA;EACA,qBAAA;AAAA;;;;cAMW,2BAAA,GACX,OAAA,GAAU,uBAAA,KACT,iCAAA;;;;cAqGU,gBAAA,GACX,OAAA,GAAU,uBAAA,KACT,cAAA"}
+{"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"}