@intlayer/core 8.12.5-canary.0 → 9.0.0-canary.0

package/dist/types/interpreter/getVariant.d.ts

@@ -0,0 +1,26 @@
+import { VariantContentState } from "../transpiler/variant/variant.js";
+
+//#region src/interpreter/getVariant.d.ts
+/**
+ * Resolves a variant node to its selected alternative.
+ *
+ * Falls back to `control` when the requested `variantKey` does not exist in
+ * the node or when no key is specified.
+ *
+ * @param variantContent - The map of variant alternatives.
+ * @param variantKey - Optional name of the alternative to select.
+ * @returns The resolved content for the requested variant.
+ *
+ * @example
+ * ```ts
+ * const node = { control: 'Welcome', black_friday: 'Up to 50% off' };
+ *
+ * getVariant(node);                   // 'Welcome'
+ * getVariant(node, 'black_friday');   // 'Up to 50% off'
+ * getVariant(node, 'nonexistent');    // 'Welcome'  (fallback to control)
+ * ```
+ */
+declare const getVariant: <T>(variantContent: VariantContentState<T>, variantKey?: string) => T;
+//#endregion
+export { getVariant };
+//# sourceMappingURL=getVariant.d.ts.map

package/dist/types/interpreter/getVariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getVariant.d.ts","names":[],"sources":["../../../src/interpreter/getVariant.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;;;;;cAAa,UAAA,MACX,cAAA,EAAgB,mBAAA,CAAoB,CAAA,GACpC,UAAA,cACC,CAAA"}

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

@@ -0,0 +1,4 @@
+import { Dictionary } from "@intlayer/types/dictionary";
+import { LocalesValues as LocalesValues$1 } from "@intlayer/types/module_augmentation";
+import { IntlayerConfig } from "@intlayer/types/config";
+export { type LocalesValues$1 as LocalesValues };

package/dist/types/messageFormat/ICU.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;;KA6CY,SAAA,sCAKR,SAAA;EAAA,CACG,GAAA,WAAc,SAAA;AAAA;AAAA,cAkiBR,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA"}
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;;KAkDY,SAAA,sCAKR,SAAA;EAAA,CACG,GAAA,WAAc,SAAA;AAAA;AAAA,cAwlBR,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA"}

package/dist/types/messageFormat/i18next.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;;cAqjBa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;;cAsjBa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}

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

@@ -1,5 +1,6 @@
 import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./ICU.js";
 import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./i18next.js";
 import { PortableObject, intlayerToPortableObjectFormatter, portableObjectToIntlayerFormatter } from "./po.js";
+import { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode } from "./resolveMessage.js";
 import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./vue-i18n.js";
-export { JsonValue, PortableObject, i18nextToIntlayerFormatter, icuToIntlayerFormatter, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, portableObjectToIntlayerFormatter, vueI18nToIntlayerFormatter };
+export { JsonValue, MessageFormatDialect, MessageValues, PortableObject, TaggedMessageToken, i18nextToIntlayerFormatter, icuToIntlayerFormatter, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, parseTaggedMessage, portableObjectToIntlayerFormatter, resolveMessage, resolveMessageNode, vueI18nToIntlayerFormatter };

package/dist/types/messageFormat/resolveMessage.d.ts

@@ -0,0 +1,72 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/messageFormat/resolveMessage.d.ts
+/**
+ * Runtime counterpart of the `messageFormat` converters.
+ *
+ * The converters (`icuToIntlayerFormatter`, `i18nextToIntlayerFormatter`,
+ * `vueI18nToIntlayerFormatter`) turn library-specific message syntax into
+ * intlayer nodes (`insert`, `plural`, `enu`, `gender`, `html`). This module
+ * resolves those nodes — or raw message strings — into a final string using
+ * the provided interpolation values and locale.
+ *
+ * It is the mutualized resolution engine used by the compat adapter packages
+ * (`@intlayer/i18next`, `@intlayer/next-intl`, `@intlayer/vue-i18n`, …).
+ */
+/** Message syntax dialect of the source i18n library. */
+type MessageFormatDialect = 'icu' | 'i18next' | 'vue-i18n';
+/** Interpolation values passed alongside a translation lookup. */
+type MessageValues = Record<string, unknown>;
+/**
+ * Interpolates a message template with values.
+ *
+ * Handles, in order:
+ * 1. Intlayer insertions `{{name}}` (whitespace-tolerant, dotted paths)
+ * 2. ICU formatted arguments `{value, number}` / `{ts, date, long}`
+ * 3. Bare single-brace arguments `{name}` (ICU / vue-i18n simple args)
+ */
+declare const interpolateMessage: (template: string, values?: MessageValues, locale?: LocalesValues) => string;
+/**
+ * Resolves an intlayer message node tree (as produced by the
+ * `*ToIntlayerFormatter` converters, or already present in a built
+ * dictionary) into its final value using interpolation values and locale.
+ *
+ * Function nodes (produced by the interpreter plugins for `insertion`,
+ * `enumeration` and `plural` content) are invoked with the values.
+ */
+declare const resolveMessageNode: (node: unknown, values?: MessageValues, locale?: LocalesValues) => unknown;
+/**
+ * Resolves a raw message — string in a library dialect, or an intlayer node
+ * tree — into a final string using interpolation values and locale.
+ *
+ * @example
+ * ```ts
+ * resolveMessage('Hello {name}', { name: 'John' }, 'en', 'icu');
+ * // 'Hello John'
+ *
+ * resolveMessage(
+ *   '{count, plural, one {# item} other {# items}}',
+ *   { count: 3 },
+ *   'en',
+ *   'icu'
+ * );
+ * // '3 items'
+ * ```
+ */
+declare const resolveMessage: (message: unknown, values?: MessageValues, locale?: LocalesValues, dialect?: MessageFormatDialect) => string;
+/** A parsed token of a tagged message: plain text or a tag with children. */
+type TaggedMessageToken = string | {
+  tag: string;
+  children: TaggedMessageToken[];
+};
+/**
+ * Tokenizes a message containing XML-like tags (`'Visit <link>the docs</link>'`,
+ * `'hello <1>{{name}}</1>'`, `'line<br/>break'`) into a token tree.
+ *
+ * Used by rich-text renderers (`t.rich`, `<Trans components>`,
+ * `<i18n-t>` slots) to map tags to framework elements.
+ */
+declare const parseTaggedMessage: (message: string) => TaggedMessageToken[];
+//#endregion
+export { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode };
+//# sourceMappingURL=resolveMessage.d.ts.map

package/dist/types/messageFormat/resolveMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;AAwBA;;;;;AAGA;;;;;AAsFA;AAAA,KAzFY,oBAAA;;KAGA,aAAA,GAAgB,MAAA;;;;;;;;AA2H5B;cArCa,kBAAA,GACX,QAAA,UACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA;;;;;;;;;cAkCG,kBAAA,GACX,IAAA,WACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA;AA6IV;;;;;;;;;;;;;;;;;AAiBA;AAjBA,cAAa,cAAA,GACX,OAAA,WACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA,EACR,OAAA,GAAS,oBAAA;;KAaC,kBAAA;EAEN,GAAA;EAAa,QAAA,EAAU,kBAAA;AAAA;;;AAS7B;;;;;cAAa,kBAAA,GAAsB,OAAA,aAAkB,kBAAA"}

package/dist/types/messageFormat/vue-i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;;cA2Ta,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;;cAoUa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}

package/dist/types/transpiler/collection/collection.d.ts

@@ -0,0 +1,34 @@
+import { COLLECTION } from "@intlayer/types/nodeType";
+
+//#region src/transpiler/collection/collection.d.ts
+/**
+ * Shape of a collection node stored in the dictionary JSON.
+ * Items may contain any other node type (translations, conditions, etc.).
+ */
+type CollectionContent<T = unknown> = {
+  nodeType: typeof COLLECTION;
+  collection: T[];
+};
+/**
+ * Declares an ordered list of content items inside a dictionary.
+ *
+ * At runtime, `useIntlayer('my-key')` returns all items as an array.
+ * `useIntlayer('my-key', { item: 2 })` returns only the item at index 2.
+ *
+ * @example
+ * ```ts
+ * import { t, collection } from 'intlayer';
+ *
+ * export default {
+ *   key: 'faq',
+ *   content: collection([
+ *     { question: t({ en: 'What is Intlayer?' }), answer: t({ en: '...' }) },
+ *     { question: t({ en: 'Is it free?' }),       answer: t({ en: '...' }) },
+ *   ]),
+ * } satisfies Dictionary;
+ * ```
+ */
+declare const collection: <T>(items: T[]) => CollectionContent<T>;
+//#endregion
+export { CollectionContent, collection };
+//# sourceMappingURL=collection.d.ts.map

package/dist/types/transpiler/collection/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","names":[],"sources":["../../../../src/transpiler/collection/collection.ts"],"mappings":";;;;;AAMA;;KAAY,iBAAA;EACV,QAAA,SAAiB,UAAA;EACjB,UAAA,EAAY,CAAA;AAAA;;;;;;AAsBd;;;;;;;;;;;;;;cAAa,UAAA,MAAiB,KAAA,EAAO,CAAA,OAAM,iBAAA,CAAkB,CAAA"}

package/dist/types/transpiler/collection/index.d.ts

@@ -0,0 +1,2 @@
+import { CollectionContent, collection } from "./collection.js";
+export { CollectionContent, collection };

package/dist/types/transpiler/variant/index.d.ts

@@ -0,0 +1,2 @@
+import { VariantContent, VariantContentState, variant } from "./variant.js";
+export { VariantContent, VariantContentState, variant };

package/dist/types/transpiler/variant/variant.d.ts

@@ -0,0 +1,43 @@
+import { VARIANT } from "@intlayer/types/nodeType";
+
+//#region src/transpiler/variant/variant.d.ts
+/**
+ * Shape of a variant node stored in the dictionary JSON.
+ * `control` is the mandatory default/fallback key; all other keys are
+ * optional named experiment branches.
+ */
+type VariantContentState<T = unknown> = {
+  control: T;
+} & Record<string, T>;
+type VariantContent<T = unknown> = {
+  nodeType: typeof VARIANT;
+  variant: VariantContentState<T>;
+};
+/**
+ * Declares a set of named content alternatives for A/B testing or feature flags.
+ *
+ * The `control` key is mandatory and acts as the default when no variant is
+ * selected. At runtime, `useIntlayer('my-key')` returns the `control` variant.
+ * `useIntlayer('my-key', { variant: 'black_friday' })` returns that variant.
+ *
+ * @example
+ * ```ts
+ * import { t, variant } from 'intlayer';
+ *
+ * export default {
+ *   key: 'hero-banner',
+ *   content: {
+ *     headline: variant({
+ *       control:      t({ en: 'Welcome',       fr: 'Bienvenue'       }),
+ *       black_friday: t({ en: 'Up to 50% off', fr: 'Jusqu\'à -50 %'  }),
+ *     }),
+ *   },
+ * } satisfies Dictionary;
+ * ```
+ */
+declare const variant: <T>(variants: {
+  control: T;
+} & Partial<Record<string, T>>) => VariantContent<T>;
+//#endregion
+export { VariantContent, VariantContentState, variant };
+//# sourceMappingURL=variant.d.ts.map

package/dist/types/transpiler/variant/variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant.d.ts","names":[],"sources":["../../../../src/transpiler/variant/variant.ts"],"mappings":";;;;;AAOA;;;KAAY,mBAAA;EAAqC,OAAA,EAAS,CAAA;AAAA,IAAM,MAAA,SAE9D,CAAA;AAAA,KAGU,cAAA;EACV,QAAA,SAAiB,OAAA;EACjB,OAAA,EAAS,mBAAA,CAAoB,CAAA;AAAA;;;;;;AAF/B;;;;;;;;;;;;;;;;AA2BA;cAAa,OAAA,MACX,QAAA;EAAY,OAAA,EAAS,CAAA;AAAA,IAAM,OAAA,CAAQ,MAAA,SAAe,CAAA,OACjD,cAAA,CAAe,CAAA"}

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

@@ -4,6 +4,6 @@ import { getCookie } from "./getCookie.js";
 import { isSameKeyPath } from "./isSameKeyPath.js";
 import { isValidElement } from "./isValidReactElement.js";
 import { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, localeStorageOptions, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer } from "./localeStorage.js";
-import { parseYaml } from "./parseYaml.js";
+import { YamlRecord, YamlValue, parseYaml } from "./parseYaml.js";
 import { stringifyYaml } from "./stringifyYaml.js";
-export { CachedIntl, CachedIntl as Intl, CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, WrappedIntl, bindIntl, checkIsURLAbsolute, getCachedIntl, getCookie, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, isSameKeyPath, isValidElement, localeStorageOptions, parseYaml, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, stringifyYaml };
+export { CachedIntl, CachedIntl as Intl, CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, WrappedIntl, YamlRecord, YamlValue, bindIntl, checkIsURLAbsolute, getCachedIntl, getCookie, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, isSameKeyPath, isValidElement, localeStorageOptions, parseYaml, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, stringifyYaml };

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

@@ -1,5 +1,15 @@
 //#region src/utils/parseYaml.d.ts
-declare const parseYaml: <T = any>(input: string) => T | null;
+interface YamlRecord {
+  [key: string]: YamlValue;
+}
+type YamlValue = string | number | YamlValue[] | YamlRecord;
+/**
+ * Parses a YAML/JSON-like string into a typed value.
+ * Supports scalars, quoted strings, inline arrays/objects, and indented YAML syntax.
+ * Boolean/null literals (true, false, null, yes, no, etc.) are preserved as strings,
+ * not coerced to their native JS equivalents.
+ */
+declare const parseYaml: <T = YamlValue>(input: string) => T | null;
 //#endregion
-export { parseYaml };
+export { YamlRecord, YamlValue, parseYaml };
 //# sourceMappingURL=parseYaml.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parseYaml.d.ts","names":[],"sources":["../../../src/utils/parseYaml.ts"],"mappings":";cAca,SAAA,YAAsB,KAAA,aAAgB,CAAA"}
+{"version":3,"file":"parseYaml.d.ts","names":[],"sources":["../../../src/utils/parseYaml.ts"],"mappings":";UAciB,UAAA;EAAA,CACd,GAAA,WAAc,SAAA;AAAA;AAAA,KAEL,SAAA,qBAA8B,SAAA,KAAc,UAAA;;;AAAxD;;;;cAQa,SAAA,OAAiB,SAAA,EAAW,KAAA,aAAgB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "8.12.5-canary.0",
+  "version": "9.0.0-canary.0",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -172,15 +172,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.12.5-canary.0",
-    "@intlayer/config": "8.12.5-canary.0",
-    "@intlayer/dictionaries-entry": "8.12.5-canary.0",
-    "@intlayer/types": "8.12.5-canary.0",
-    "@intlayer/unmerged-dictionaries-entry": "8.12.5-canary.0",
+    "@intlayer/api": "9.0.0-canary.0",
+    "@intlayer/config": "9.0.0-canary.0",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.0",
+    "@intlayer/types": "9.0.0-canary.0",
+    "@intlayer/unmerged-dictionaries-entry": "9.0.0-canary.0",
     "defu": "6.1.7"
   },
   "devDependencies": {
-    "@types/node": "25.9.2",
+    "@types/node": "25.9.3",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",