@intlayer/core 9.5.9-canary.0 → 9.5.10

package/dist/cjs/dictionaryManipulator/qualifiedDictionary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.cjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantChain,\n  DictionaryVariantValue,\n  ProviderVariantBase,\n  ProviderVariantMap,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Identity of the implicit fallback variant. A selector that pins no variant\n * resolves to it, and a variant that declares no entry of its own falls back to\n * it — so a key only has to ship the entries that actually differ.\n */\nexport const DEFAULT_VARIANT_ID = 'default';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return DEFAULT_VARIANT_ID;\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Serializes the variant coordinate of a selector into the ordered list of\n * candidate ids to try, so a single value and a preference chain share one code\n * path downstream.\n *\n * - `undefined` → `['default']`\n * - a single value → its one serialization\n * - a chain → one serialization per entry, order preserved\n *\n * An empty chain is treated as \"no variant pinned\" (`['default']`) rather than\n * as an unsatisfiable request.\n */\nexport const serializeVariantChain = (\n  variant: DictionaryVariantChain | undefined\n): string[] => {\n  if (!Array.isArray(variant)) {\n    return [serializeVariant(variant as DictionaryVariantValue | undefined)];\n  }\n\n  if (variant.length === 0) return [DEFAULT_VARIANT_ID];\n\n  return variant.map(serializeVariant);\n};\n\n/**\n * Resolves the variant id a selector actually targets among the ids a key\n * declares — the sparse-override fallback.\n *\n * Candidates are tried in order and the first one the key declares wins.\n * Otherwise the key falls back to its `default` entry, so a variant only has to\n * be declared where its wording differs. When the key declares no `default`\n * either, the first candidate is returned unchanged and the caller resolves to\n * `null` / `[]`.\n *\n * @param requestedVariantIds - The serialized ids the selector asks for, in\n *                              preference order (a single value is a 1-element\n *                              list).\n * @param isVariantIdDeclared - Whether the key declares an entry for an id.\n */\nexport const resolveEffectiveVariantId = (\n  requestedVariantIds: string[],\n  isVariantIdDeclared: (variantId: string) => boolean\n): string => {\n  for (const requestedVariantId of requestedVariantIds) {\n    if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;\n  }\n\n  return isVariantIdDeclared(DEFAULT_VARIANT_ID)\n    ? DEFAULT_VARIANT_ID\n    : (requestedVariantIds[0] ?? DEFAULT_VARIANT_ID);\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis); the `variant` dimension is compared against the already-resolved\n * effective id, so the fallback is applied consistently across dimensions.\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined,\n  effectiveVariantId: string\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === effectiveVariantId;\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected, and falls back\n *   to it when the selected variant declares no entry of its own; an object\n *   variant resolves only when the selector provides an equal object (or, again,\n *   through the `default` fallback)\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const compositeIds = Object.keys(content);\n  const variantIndex = qualifierTypes.indexOf('variant');\n\n  const effectiveVariantId =\n    variantIndex === -1\n      ? DEFAULT_VARIANT_ID\n      : resolveEffectiveVariantId(\n          serializeVariantChain(selector?.variant),\n          (variantId) =>\n            compositeIds.some(\n              (compositeId) =>\n                compositeId.split(COMPOSITE_ID_SEPARATOR)[variantIndex] ===\n                variantId\n            )\n        );\n\n  const matchedEntries = compositeIds\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(\n        compositeId,\n        qualifierTypes,\n        selector,\n        effectiveVariantId\n      )\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector };\n};\n\n/**\n * Resolves the variant a provider pins for one dictionary key.\n *\n * A string or a chain applies to every key as-is. A plain object is the per-key\n * map: the entry for `dictionaryKey` wins, falling back to the reserved\n * `default` entry, and `undefined` when neither is present (the key then\n * resolves to its own `default` variant, i.e. the behaviour without a provider\n * variant at all).\n *\n * A plain object is **always** the map here — never a structured variant value,\n * which is why a structured variant has to be nested (`{ default: { id } }`).\n *\n * @param providerVariant - The `variant` prop of the surrounding provider.\n * @param dictionaryKey - The key being read.\n */\nexport const resolveProviderVariant = (\n  providerVariant: ProviderVariantBase | undefined,\n  dictionaryKey: string\n): DictionaryVariantChain | undefined => {\n  if (providerVariant === undefined) return undefined;\n\n  if (typeof providerVariant === 'string' || Array.isArray(providerVariant)) {\n    return providerVariant as DictionaryVariantChain;\n  }\n\n  const variantMap = providerVariant as ProviderVariantMap;\n\n  return variantMap[dictionaryKey] ?? variantMap[DEFAULT_VARIANT_ID];\n};\n\n/**\n * Builds the effective second argument of a dictionary read by layering the\n * provider defaults under the call-site one — the single place the `locale` and\n * `variant` context defaults are applied, shared by every framework binding.\n *\n * Precedence, per dimension independently:\n * - a call-site selector always wins; `{ variant: 'x' }` **replaces** the\n *   provider chain rather than extending it\n * - otherwise the provider value applies\n *\n * Returns a bare locale (not a selector object) whenever no variant is in play,\n * so the existing fast path — and the cache keys built from it — are unchanged\n * for projects that never use variants.\n */\nexport const resolveDictionaryArgument = (params: {\n  localeOrSelector?: LocalesValues | DictionarySelector;\n  contextLocale?: LocalesValues;\n  contextVariant?: ProviderVariantBase;\n  dictionaryKey: string;\n}): LocalesValues | DictionarySelector | undefined => {\n  const { localeOrSelector, contextLocale, contextVariant, dictionaryKey } =\n    params;\n\n  const callSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector\n      : undefined;\n\n  const callLocale = callSelector\n    ? callSelector.locale\n    : (localeOrSelector as LocalesValues | undefined);\n\n  // The context locale is typed as widely as the runtime allows, while a\n  // selector narrows `locale` to the declared ones — the value is the same.\n  const locale = (callLocale ?? contextLocale) as DictionarySelector['locale'];\n\n  // A call-site variant is authoritative; the provider only fills the gap.\n  const variant =\n    callSelector?.variant ??\n    resolveProviderVariant(contextVariant, dictionaryKey);\n\n  if (variant === undefined) {\n    // Nothing to add: keep the argument in its original shape so the identity\n    // built from it stays byte-identical to the pre-variant behaviour.\n    return callSelector\n      ? { ...callSelector, locale }\n      : (locale as LocalesValues | undefined);\n  }\n\n  return { ...callSelector, locale, variant };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariantChain(\n              value as DictionaryVariantChain | undefined\n            ).join(',')\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n"],"mappings":"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"}
+{"version":3,"file":"qualifiedDictionary.cjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n  DictionaryVariantChain,\n  DictionaryVariantValue,\n  ProviderVariantBase,\n  ProviderVariantMap,\n  QualifiedDictionaryGroup,\n} from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Separator joining per-dimension ids into a composite entry id. Also used as\n * the chunk path separator in dynamic mode.\n */\nexport const COMPOSITE_ID_SEPARATOR = '/';\n\n/**\n * Identity of the implicit fallback variant. A selector that pins no variant\n * resolves to it, and a variant that declares no entry of its own falls back to\n * it — so a key only has to ship the entries that actually differ.\n */\nexport const DEFAULT_VARIANT_ID = 'default';\n\n/**\n * Characters kept verbatim in an encoded qualifier segment. Everything else is\n * percent-encoded so a segment can never contain the composite-id separator\n * (`/`), path-hostile characters (`\\` `:` `*` `?` `\"` `<` `>` `|`, control\n * chars), or characters that would break the generated loader modules (`'`).\n */\nconst SEGMENT_UNSAFE_CHARS = /[^A-Za-z0-9._&=-]/g;\n\n/**\n * Stricter set for the components of an object variant: also encodes `&` and\n * `=` so the `field=value&field=value` serialization stays unambiguous.\n */\nconst COMPONENT_UNSAFE_CHARS = /[^A-Za-z0-9._-]/g;\n\n/** Percent-encodes one UTF-16 code unit as a fixed-width `%XXXX` run. */\nconst percentEncodeChar = (char: string): string =>\n  `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n\nconst encodeSegmentText = (raw: string, unsafeChars: RegExp): string => {\n  // Bare '%' cannot be produced by encoding (every encoded run is %XXXX),\n  // so it is a safe stand-in for the empty string.\n  if (raw === '') return '%';\n\n  const encoded = raw.replace(unsafeChars, percentEncodeChar);\n\n  // '.' and '..' are path navigation on every filesystem — encode the dots.\n  if (encoded === '.' || encoded === '..') {\n    return encoded.replace(/\\./g, '%002E');\n  }\n\n  return encoded;\n};\n\n/**\n * Canonical serialization of a single variant value into its identity string —\n * the variant segment of a composite id, the chunk directory name in dynamic\n * mode, and the runtime matching key.\n *\n * - `undefined` → `'default'` (the implicit fallback variant)\n * - a string → the string itself (a named variant)\n * - an object → its sorted `key=value` pairs joined by `&`\n *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)\n *\n * Characters that are unsafe in file paths or generated code are\n * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —\n * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and\n * the selector go through this function, so encoding never affects matching.\n *\n * Two variants resolve to the same entry iff their serializations are equal, so\n * an object variant in a selector must equal the one declared on the dictionary.\n */\nexport const serializeVariant = (\n  variant: DictionaryVariantValue | undefined\n): string => {\n  if (variant === undefined) return DEFAULT_VARIANT_ID;\n  if (typeof variant === 'string') {\n    return encodeSegmentText(variant, SEGMENT_UNSAFE_CHARS);\n  }\n\n  return Object.keys(variant)\n    .sort()\n    .map(\n      (field) =>\n        `${encodeSegmentText(field, COMPONENT_UNSAFE_CHARS)}=${encodeSegmentText(String(variant[field]), COMPONENT_UNSAFE_CHARS)}`\n    )\n    .join('&');\n};\n\n/**\n * Serializes the variant coordinate of a selector into the ordered list of\n * candidate ids to try, so a single value and a preference chain share one code\n * path downstream.\n *\n * - `undefined` → `['default']`\n * - a single value → its one serialization\n * - a chain → one serialization per entry, order preserved\n *\n * An empty chain is treated as \"no variant pinned\" (`['default']`) rather than\n * as an unsatisfiable request.\n */\nexport const serializeVariantChain = (\n  variant: DictionaryVariantChain | undefined\n): string[] => {\n  if (!Array.isArray(variant)) {\n    return [serializeVariant(variant as DictionaryVariantValue | undefined)];\n  }\n\n  if (variant.length === 0) return [DEFAULT_VARIANT_ID];\n\n  return variant.map(serializeVariant);\n};\n\n/**\n * Resolves the variant id a selector actually targets among the ids a key\n * declares — the sparse-override fallback.\n *\n * Candidates are tried in order and the first one the key declares wins.\n * Otherwise the key falls back to its `default` entry, so a variant only has to\n * be declared where its wording differs. When the key declares no `default`\n * either, the first candidate is returned unchanged and the caller resolves to\n * `null` / `[]`.\n *\n * @param requestedVariantIds - The serialized ids the selector asks for, in\n *                              preference order (a single value is a 1-element\n *                              list).\n * @param isVariantIdDeclared - Whether the key declares an entry for an id.\n */\nexport const resolveEffectiveVariantId = (\n  requestedVariantIds: string[],\n  isVariantIdDeclared: (variantId: string) => boolean\n): string => {\n  for (const requestedVariantId of requestedVariantIds) {\n    if (isVariantIdDeclared(requestedVariantId)) return requestedVariantId;\n  }\n\n  return isVariantIdDeclared(DEFAULT_VARIANT_ID)\n    ? DEFAULT_VARIANT_ID\n    : (requestedVariantIds[0] ?? DEFAULT_VARIANT_ID);\n};\n\n/**\n * Tests whether a composite entry id matches a selector across every declared\n * dimension. Segments are compared in their encoded form (both the stored id\n * and the selector go through {@link serializeVariant}). The `item` dimension\n * matches any value when the selector does not provide one (open collection\n * axis); the `variant` dimension is compared against the already-resolved\n * effective id, so the fallback is applied consistently across dimensions.\n */\nconst compositeIdMatchesSelector = (\n  compositeId: string,\n  qualifierTypes: DictionaryQualifierType[],\n  selector: DictionarySelector | undefined,\n  effectiveVariantId: string\n): boolean => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  return qualifierTypes.every((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      return segments[index] === effectiveVariantId;\n    }\n\n    // qualifierType === 'item'\n    return (\n      selector?.item === undefined || segments[index] === String(selector.item)\n    );\n  });\n};\n\n/**\n * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a\n * qualified key) from a plain `Dictionary`. Both carry a `content` field; only\n * the group declares `qualifierTypes`, which is therefore the discriminator.\n */\nexport const isQualifiedDictionaryGroup = (\n  value: unknown\n): value is QualifiedDictionaryGroup =>\n  typeof value === 'object' &&\n  value !== null &&\n  'qualifierTypes' in value &&\n  Array.isArray((value as { qualifierTypes: unknown }).qualifierTypes) &&\n  'content' in value;\n\n/**\n * Reconstructs a resolvable {@link Dictionary} from a single entry of a\n * qualified group: the content node stored under its composite id, plus the\n * qualifier coordinates decoded from that id (`variant`, `item`).\n *\n * This keeps the resolver's transform code unchanged: it still sees a\n * `{ key, content, variant?, item? }` shape, even though the stored format no\n * longer duplicates those fields per entry. The `variant` coordinate stays in\n * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens\n * on the composite id segments, never on this reconstructed field.\n */\nexport const reconstructQualifiedEntry = (\n  group: QualifiedDictionaryGroup,\n  compositeId: string\n): Dictionary => {\n  const segments = compositeId.split(COMPOSITE_ID_SEPARATOR);\n\n  const entry = {\n    key: group.key,\n    content: group.content[compositeId],\n  } as Dictionary;\n\n  group.qualifierTypes.forEach((qualifierType, index) => {\n    if (qualifierType === 'variant') {\n      entry.variant = segments[index];\n    } else if (qualifierType === 'item') {\n      entry.item = Number(segments[index]);\n    }\n  });\n\n  return entry;\n};\n\n/**\n * Resolves a dictionary (or qualified dictionary group) against a selector,\n * across every declared dimension.\n *\n * - Plain dictionary → returned as-is (selector ignored)\n * - `item` declared but not selected → every matching entry ordered by index\n * - `item` selected → the matching entry or null\n * - `variant` defaults to the `default` entry when not selected, and falls back\n *   to it when the selected variant declares no entry of its own; an object\n *   variant resolves only when the selector provides an equal object (or, again,\n *   through the `default` fallback)\n *\n * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`\n * returns every promo item as an array; adding `{ item: 2 }` narrows to one.\n */\nexport const resolveQualifiedDictionary = (\n  dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup,\n  selector?: DictionarySelector\n): Dictionary | Dictionary[] | null => {\n  if (!isQualifiedDictionaryGroup(dictionaryOrGroup)) {\n    return dictionaryOrGroup;\n  }\n\n  const { qualifierTypes, content } = dictionaryOrGroup;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  const compositeIds = Object.keys(content);\n  const variantIndex = qualifierTypes.indexOf('variant');\n\n  const effectiveVariantId =\n    variantIndex === -1\n      ? DEFAULT_VARIANT_ID\n      : resolveEffectiveVariantId(\n          serializeVariantChain(selector?.variant),\n          (variantId) =>\n            compositeIds.some(\n              (compositeId) =>\n                compositeId.split(COMPOSITE_ID_SEPARATOR)[variantIndex] ===\n                variantId\n            )\n        );\n\n  const matchedEntries = compositeIds\n    .filter((compositeId) =>\n      compositeIdMatchesSelector(\n        compositeId,\n        qualifierTypes,\n        selector,\n        effectiveVariantId\n      )\n    )\n    .map((compositeId) =>\n      reconstructQualifiedEntry(dictionaryOrGroup, compositeId)\n    );\n\n  if (itemAxisOpen) {\n    return matchedEntries.sort(\n      (left, right) => (left.item ?? 0) - (right.item ?? 0)\n    );\n  }\n\n  return matchedEntries[0] ?? null;\n};\n\n/**\n * Splits the second argument of `getIntlayer` / `getDictionary` into the\n * effective locale and the selector object (if any).\n */\nexport const parseDictionarySelector = <L extends LocalesValues>(\n  localeOrSelector?: L | DictionarySelector\n): { locale?: L; selector?: DictionarySelector } => {\n  if (typeof localeOrSelector === 'object' && localeOrSelector !== null) {\n    return {\n      locale: localeOrSelector.locale as L | undefined,\n      selector: localeOrSelector,\n    };\n  }\n\n  return { locale: localeOrSelector as L | undefined };\n};\n\n/**\n * Resolves the variant a provider pins for one dictionary key.\n *\n * A string or a chain applies to every key as-is. A plain object is the per-key\n * map: the entry for `dictionaryKey` wins, falling back to the reserved\n * `default` entry, and `undefined` when neither is present (the key then\n * resolves to its own `default` variant, i.e. the behaviour without a provider\n * variant at all).\n *\n * A plain object is **always** the map here — never a structured variant value,\n * which is why a structured variant has to be nested (`{ default: { id } }`).\n *\n * @param providerVariant - The `variant` prop of the surrounding provider.\n * @param dictionaryKey - The key being read.\n */\nexport const resolveProviderVariant = (\n  providerVariant: ProviderVariantBase | undefined,\n  dictionaryKey: string\n): DictionaryVariantChain | undefined => {\n  if (providerVariant === undefined) return undefined;\n\n  if (typeof providerVariant === 'string' || Array.isArray(providerVariant)) {\n    return providerVariant as DictionaryVariantChain;\n  }\n\n  const variantMap = providerVariant as ProviderVariantMap;\n\n  return variantMap[dictionaryKey] ?? variantMap[DEFAULT_VARIANT_ID];\n};\n\n/**\n * Builds the effective second argument of a dictionary read by layering the\n * provider defaults under the call-site one — the single place the `locale` and\n * `variant` context defaults are applied, shared by every framework binding.\n *\n * Precedence, per dimension independently:\n * - a call-site selector always wins; `{ variant: 'x' }` **replaces** the\n *   provider chain rather than extending it\n * - otherwise the provider value applies\n *\n * Returns a bare locale (not a selector object) whenever no variant is in play,\n * so the existing fast path — and the cache keys built from it — are unchanged\n * for projects that never use variants.\n */\nexport const resolveDictionaryArgument = (params: {\n  localeOrSelector?: LocalesValues | DictionarySelector;\n  contextLocale?: LocalesValues;\n  contextVariant?: ProviderVariantBase;\n  dictionaryKey: string;\n}): LocalesValues | DictionarySelector | undefined => {\n  const { localeOrSelector, contextLocale, contextVariant, dictionaryKey } =\n    params;\n\n  const callSelector =\n    typeof localeOrSelector === 'object' && localeOrSelector !== null\n      ? localeOrSelector\n      : undefined;\n\n  const callLocale = callSelector\n    ? callSelector.locale\n    : (localeOrSelector as LocalesValues | undefined);\n\n  // The context locale is typed as widely as the runtime allows, while a\n  // selector narrows `locale` to the declared ones — the value is the same.\n  const locale = (callLocale ?? contextLocale) as DictionarySelector['locale'];\n\n  // A call-site variant is authoritative; the provider only fills the gap.\n  const variant =\n    callSelector?.variant ??\n    resolveProviderVariant(contextVariant, dictionaryKey);\n\n  if (variant === undefined) {\n    // Nothing to add: keep the argument in its original shape so the identity\n    // built from it stays byte-identical to the pre-variant behaviour.\n    return callSelector\n      ? { ...callSelector, locale }\n      : (locale as LocalesValues | undefined);\n  }\n\n  return { ...callSelector, locale, variant };\n};\n\n/**\n * Builds a stable string identity of a selector (excluding `locale`), suitable\n * for cache keys and memoization dependencies.\n */\nexport const getDictionarySelectorCacheKey = (\n  selector?: DictionarySelector\n): string => {\n  if (!selector) return '';\n\n  return Object.keys(selector)\n    .filter((selectorKey) => selectorKey !== 'locale')\n    .sort()\n    .map((selectorKey) => {\n      const value = selector[selectorKey as keyof DictionarySelector];\n      const serialized =\n        selectorKey === 'variant'\n          ? serializeVariantChain(\n              value as DictionaryVariantChain | undefined\n            ).join(',')\n          : String(value);\n      return `${selectorKey}:${serialized}`;\n    })\n    .join('|');\n};\n"],"mappings":"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"}

package/dist/cjs/index.cjs

@@ -112,11 +112,13 @@ const require_messageFormat_navigatePath = require('./messageFormat/navigatePath
 const require_messageFormat_po = require('./messageFormat/po.cjs');
 const require_messageFormat_vue_i18n = require('./messageFormat/vue-i18n.cjs');
 const require_messageFormat_resolveMessage = require('./messageFormat/resolveMessage.cjs');
+const require_utils_intlayerNodePrototype = require('./utils/intlayerNodePrototype.cjs');
 const require_utils_isSameKeyPath = require('./utils/isSameKeyPath.cjs');
 const require_utils_stringifyYaml = require('./utils/stringifyYaml.cjs');
 let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
 
 exports.ATTRIBUTES_TO_SANITIZE = require_markdown_constants.ATTRIBUTES_TO_SANITIZE;
+exports.ATTRIBUTE_NAME_START_R = require_markdown_constants.ATTRIBUTE_NAME_START_R;
 exports.ATTRIBUTE_TO_NODE_PROP_MAP = require_markdown_constants.ATTRIBUTE_TO_NODE_PROP_MAP;
 exports.ATTR_EXTRACTOR_R = require_markdown_constants.ATTR_EXTRACTOR_R;
 exports.BLOCKQUOTE_ALERT_R = require_markdown_constants.BLOCKQUOTE_ALERT_R;
@@ -245,6 +247,7 @@ exports.get = require_markdown_utils.get;
 exports.getBasePlugins = require_interpreter_getContent_getContent.getBasePlugins;
 exports.getBrowserLocale = require_localization_getBrowserLocale.getBrowserLocale;
 exports.getCachedIntl = require_utils_intl.getCachedIntl;
+exports.getCachedLocaleFromStorageClient = require_utils_localeStorage.getCachedLocaleFromStorageClient;
 exports.getCanonicalPath = require_localization_getCanonicalPath.getCanonicalPath;
 exports.getCondition = require_interpreter_getCondition.getCondition;
 exports.getContent = require_interpreter_getContent_getContent.getContent;
@@ -279,6 +282,7 @@ exports.getInternalPath = require_localization_rewriteUtils.getInternalPath;
 exports.getInterpolableContent = require_interpreter_interpolableNode.getInterpolableContent;
 exports.getIntlayer = require_interpreter_getIntlayer.getIntlayer;
 exports.getIntlayerAsync = require_interpreter_getIntlayerAsync.getIntlayerAsync;
+exports.getIntlayerNodePrototype = require_utils_intlayerNodePrototype.getIntlayerNodePrototype;
 exports.getLocale = require_localization_getLocale.getLocale;
 exports.getLocaleFromDomain = require_localization_domainUtils.getLocaleFromDomain;
 exports.getLocaleFromPath = require_localization_getLocaleFromPath.getLocaleFromPath;

package/dist/cjs/interpreter/getContent/deepTransform.cjs

@@ -4,45 +4,40 @@ let _intlayer_types_nodeType = require("@intlayer/types/nodeType");
 _intlayer_types_nodeType = require_runtime.__toESM(_intlayer_types_nodeType);
 
 //#region src/interpreter/getContent/deepTransform.ts
+/** Props of a child node: same context, one more key path segment. */
+const getChildProps = (props, children, keyPathSegment) => ({
+	...props,
+	children,
+	keyPath: [...props.keyPath, keyPathSegment]
+});
 /**
 * Recursively traverses a node (object/array/primitive).
 * Applies the *first* plugin that can transform a node, then stops descending further.
 * If no plugin transforms it, it recurses into its children.
 */
 const deepTransformNode = (node, props) => {
-	for (const plugin of props.plugins ?? []) if (plugin.canHandle(node)) return plugin.transform(node, props, (node, props) => deepTransformNode(node, props));
+	for (const plugin of props.plugins ?? []) if (plugin.canHandle(node)) return plugin.transform(node, props, deepTransformNode);
 	if (node === null || typeof node !== "object") return node;
-	if (node.$$typeof !== void 0 || node.__v_isVNode !== void 0 || node._isVNode !== void 0 || node.isJSX !== void 0 || typeof node === "function") return node;
-	if (Array.isArray(node)) return node.map((child, index) => {
-		const childProps = {
-			...props,
-			children: child,
-			keyPath: [...props.keyPath, {
-				type: _intlayer_types_nodeType.ARRAY,
-				key: index
-			}]
-		};
-		return deepTransformNode(child, childProps);
-	});
+	if (node.$$typeof !== void 0 || node.__v_isVNode !== void 0 || node._isVNode !== void 0 || node.isJSX !== void 0) return node;
+	if (Array.isArray(node)) return node.map((child, index) => deepTransformNode(child, getChildProps(props, child, {
+		type: _intlayer_types_nodeType.ARRAY,
+		key: index
+	})));
 	const result = {};
 	for (const key in node) {
-		const childProps = {
-			...props,
-			children: node[key],
-			keyPath: [...props.keyPath, {
-				type: _intlayer_types_nodeType.OBJECT,
-				key
-			}]
+		const keyPathSegment = {
+			type: _intlayer_types_nodeType.OBJECT,
+			key
 		};
 		if (props.eager) {
-			result[key] = deepTransformNode(node[key], childProps);
+			result[key] = deepTransformNode(node[key], getChildProps(props, node[key], keyPathSegment));
 			continue;
 		}
 		Object.defineProperty(result, key, {
 			enumerable: true,
 			configurable: true,
 			get: function() {
-				const transformed = deepTransformNode(node[key], childProps);
+				const transformed = deepTransformNode(node[key], getChildProps(props, node[key], keyPathSegment));
 				Object.defineProperty(this, key, {
 					value: transformed,
 					enumerable: true,

package/dist/cjs/interpreter/getContent/deepTransform.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"deepTransform.cjs","names":["NodeTypes"],"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"sourcesContent":["import type { KeyPath } from '@intlayer/types/keyPath';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport type { NodeProps } from './plugins';\n\n/**\n * Recursively traverses a node (object/array/primitive).\n * Applies the *first* plugin that can transform a node, then stops descending further.\n * If no plugin transforms it, it recurses into its children.\n */\nexport const deepTransformNode = (node: any, props: NodeProps): any => {\n  // Otherwise, if it's an object, check if any plugin can handle it:\n  for (const plugin of props.plugins ?? []) {\n    if (plugin.canHandle(node)) {\n      // Return the transformed node => do NOT recurse further\n      return plugin.transform(node, props, (node: any, props: any) =>\n        deepTransformNode(node, props)\n      );\n    }\n  }\n\n  // If it's null/undefined or not an object, just return it directly:\n  if (node === null || typeof node !== 'object') {\n    return node;\n  }\n\n  // If it's a framework-specific virtual node or already a transformed Proxy,\n  // return it directly to avoid re-transforming its internal properties.\n  if (\n    (node as any).$$typeof !== undefined ||\n    (node as any).__v_isVNode !== undefined ||\n    (node as any)._isVNode !== undefined ||\n    (node as any).isJSX !== undefined ||\n    typeof node === 'function' // Proxies for html/markdown are functions\n  ) {\n    return node;\n  }\n\n  // If it's an array, transform each element:\n  if (Array.isArray(node)) {\n    return node.map((child, index) => {\n      const childProps = {\n        ...props,\n        children: child,\n        keyPath: [\n          ...props.keyPath,\n          { type: NodeTypes.ARRAY, key: index } as KeyPath,\n        ],\n      };\n      return deepTransformNode(child, childProps);\n    });\n  }\n\n  // If no plugin transforms it, we keep traversing its properties.\n  const result: Record<string, any> = {};\n  for (const key in node) {\n    const childProps = {\n      ...props,\n      children: node[key],\n      keyPath: [...props.keyPath, { type: NodeTypes.OBJECT, key } as KeyPath],\n    };\n\n    if (props.eager) {\n      // Eager mode: recurse immediately so plugins fire on every node, even\n      // when the caller discards the returned tree (e.g. side-effect-only\n      // plugins like missing-locale detection).\n      result[key] = deepTransformNode(node[key], childProps);\n      continue;\n    }\n\n    Object.defineProperty(result, key, {\n      enumerable: true,\n      configurable: true,\n      get: function () {\n        const transformed = deepTransformNode(node[key], childProps);\n\n        // Memoize the result onto the property to avoid re-calculating on next read\n        Object.defineProperty(this, key, {\n          value: transformed,\n          enumerable: true,\n          configurable: true,\n        });\n        return transformed;\n      },\n    });\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;AASA,MAAa,qBAAqB,MAAW,UAA0B;CAErE,KAAK,MAAM,UAAU,MAAM,WAAW,CAAC,GACrC,IAAI,OAAO,UAAU,IAAI,GAEvB,OAAO,OAAO,UAAU,MAAM,QAAQ,MAAW,UAC/C,kBAAkB,MAAM,KAAK,CAC/B;CAKJ,IAAI,SAAS,QAAQ,OAAO,SAAS,UACnC,OAAO;CAKT,IACG,KAAa,aAAa,UAC1B,KAAa,gBAAgB,UAC7B,KAAa,aAAa,UAC1B,KAAa,UAAU,UACxB,OAAO,SAAS,YAEhB,OAAO;CAIT,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,KAAK,KAAK,OAAO,UAAU;EAChC,MAAM,aAAa;GACjB,GAAG;GACH,UAAU;GACV,SAAS,CACP,GAAG,MAAM,SACT;IAAE,MAAMA,yBAAU;IAAO,KAAK;GAAM,CACtC;EACF;EACA,OAAO,kBAAkB,OAAO,UAAU;CAC5C,CAAC;CAIH,MAAM,SAA8B,CAAC;CACrC,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,aAAa;GACjB,GAAG;GACH,UAAU,KAAK;GACf,SAAS,CAAC,GAAG,MAAM,SAAS;IAAE,MAAMA,yBAAU;IAAQ;GAAI,CAAY;EACxE;EAEA,IAAI,MAAM,OAAO;GAIf,OAAO,OAAO,kBAAkB,KAAK,MAAM,UAAU;GACrD;EACF;EAEA,OAAO,eAAe,QAAQ,KAAK;GACjC,YAAY;GACZ,cAAc;GACd,KAAK,WAAY;IACf,MAAM,cAAc,kBAAkB,KAAK,MAAM,UAAU;IAG3D,OAAO,eAAe,MAAM,KAAK;KAC/B,OAAO;KACP,YAAY;KACZ,cAAc;IAChB,CAAC;IACD,OAAO;GACT;EACF,CAAC;CACH;CAEA,OAAO;AACT"}
+{"version":3,"file":"deepTransform.cjs","names":["NodeTypes"],"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"sourcesContent":["import type { KeyPath } from '@intlayer/types/keyPath';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport type { NodeProps } from './plugins';\n\n/** Props of a child node: same context, one more key path segment. */\nconst getChildProps = (\n  props: NodeProps,\n  children: unknown,\n  keyPathSegment: KeyPath\n): NodeProps => ({\n  ...props,\n  children,\n  keyPath: [...props.keyPath, keyPathSegment],\n});\n\n/**\n * Recursively traverses a node (object/array/primitive).\n * Applies the *first* plugin that can transform a node, then stops descending further.\n * If no plugin transforms it, it recurses into its children.\n */\nexport const deepTransformNode = (node: any, props: NodeProps): any => {\n  for (const plugin of props.plugins ?? []) {\n    if (plugin.canHandle(node)) {\n      // Return the transformed node => do NOT recurse further\n      return plugin.transform(node, props, deepTransformNode);\n    }\n  }\n\n  // Primitives, and functions such as html/markdown node renderers\n  if (node === null || typeof node !== 'object') {\n    return node;\n  }\n\n  // Framework virtual nodes and already-transformed nodes are final\n  if (\n    node.$$typeof !== undefined ||\n    node.__v_isVNode !== undefined ||\n    node._isVNode !== undefined ||\n    node.isJSX !== undefined\n  ) {\n    return node;\n  }\n\n  if (Array.isArray(node)) {\n    return node.map((child, index) =>\n      deepTransformNode(\n        child,\n        getChildProps(props, child, {\n          type: NodeTypes.ARRAY,\n          key: index,\n        } as KeyPath)\n      )\n    );\n  }\n\n  const result: Record<string, any> = {};\n\n  for (const key in node) {\n    const keyPathSegment = { type: NodeTypes.OBJECT, key } as KeyPath;\n\n    if (props.eager) {\n      result[key] = deepTransformNode(\n        node[key],\n        getChildProps(props, node[key], keyPathSegment)\n      );\n      continue;\n    }\n\n    // Lazy mode: transform on first read, then memoize onto the property\n    Object.defineProperty(result, key, {\n      enumerable: true,\n      configurable: true,\n      get: function () {\n        const transformed = deepTransformNode(\n          node[key],\n          getChildProps(props, node[key], keyPathSegment)\n        );\n\n        Object.defineProperty(this, key, {\n          value: transformed,\n          enumerable: true,\n          configurable: true,\n        });\n        return transformed;\n      },\n    });\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;AAKA,MAAM,iBACJ,OACA,UACA,oBACe;CACf,GAAG;CACH;CACA,SAAS,CAAC,GAAG,MAAM,SAAS,cAAc;AAC5C;;;;;;AAOA,MAAa,qBAAqB,MAAW,UAA0B;CACrE,KAAK,MAAM,UAAU,MAAM,WAAW,CAAC,GACrC,IAAI,OAAO,UAAU,IAAI,GAEvB,OAAO,OAAO,UAAU,MAAM,OAAO,iBAAiB;CAK1D,IAAI,SAAS,QAAQ,OAAO,SAAS,UACnC,OAAO;CAIT,IACE,KAAK,aAAa,UAClB,KAAK,gBAAgB,UACrB,KAAK,aAAa,UAClB,KAAK,UAAU,QAEf,OAAO;CAGT,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,KAAK,KAAK,OAAO,UACtB,kBACE,OACA,cAAc,OAAO,OAAO;EAC1B,MAAMA,yBAAU;EAChB,KAAK;CACP,CAAY,CACd,CACF;CAGF,MAAM,SAA8B,CAAC;CAErC,KAAK,MAAM,OAAO,MAAM;EACtB,MAAM,iBAAiB;GAAE,MAAMA,yBAAU;GAAQ;EAAI;EAErD,IAAI,MAAM,OAAO;GACf,OAAO,OAAO,kBACZ,KAAK,MACL,cAAc,OAAO,KAAK,MAAM,cAAc,CAChD;GACA;EACF;EAGA,OAAO,eAAe,QAAQ,KAAK;GACjC,YAAY;GACZ,cAAc;GACd,KAAK,WAAY;IACf,MAAM,cAAc,kBAClB,KAAK,MACL,cAAc,OAAO,KAAK,MAAM,cAAc,CAChD;IAEA,OAAO,eAAe,MAAM,KAAK;KAC/B,OAAO;KACP,YAAY;KACZ,cAAc;IAChB,CAAC;IACD,OAAO;GACT;EACF,CAAC;CACH;CAEA,OAAO;AACT"}

package/dist/cjs/interpreter/getContent/getContent.cjs

@@ -7,13 +7,14 @@ let _intlayer_config_built = require("@intlayer/config/built");
 const getBasePlugins = (locale, fallback = true) => [
 	require_interpreter_getContent_plugins.translationPlugin(locale ?? _intlayer_config_built.internationalization.defaultLocale, fallback ? _intlayer_config_built.internationalization.defaultLocale : void 0),
 	require_interpreter_getContent_plugins.enumerationPlugin,
+	require_interpreter_getContent_plugins.pluralPlugin(locale ?? _intlayer_config_built.internationalization.defaultLocale),
 	require_interpreter_getContent_plugins.conditionPlugin,
 	require_interpreter_getContent_plugins.insertionPlugin,
 	require_interpreter_getContent_plugins.nestedPlugin(locale ?? _intlayer_config_built.internationalization.defaultLocale),
 	require_interpreter_getContent_plugins.filePlugin,
 	require_interpreter_getContent_plugins.genderPlugin,
 	require_interpreter_getContent_plugins.selectPlugin
-];
+].filter((plugin) => plugin !== require_interpreter_getContent_plugins.fallbackPlugin);
 /**
 * Transforms a node in a single pass, applying each plugin as needed.
 *

package/dist/cjs/interpreter/getContent/getContent.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getContent.cjs","names":["translationPlugin","internationalization","enumerationPlugin","conditionPlugin","insertionPlugin","nestedPlugin","filePlugin","genderPlugin","selectPlugin","deepTransformNode"],"sources":["../../../../src/interpreter/getContent/getContent.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { ContentNode } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { deepTransformNode } from './deepTransform';\nimport {\n  conditionPlugin,\n  type DeepTransformContent,\n  enumerationPlugin,\n  filePlugin,\n  genderPlugin,\n  type IInterpreterPluginState,\n  insertionPlugin,\n  type NodeProps,\n  nestedPlugin,\n  type Plugins,\n  selectPlugin,\n  translationPlugin,\n} from './plugins';\n\nexport const getBasePlugins = (\n  locale?: LocalesValues,\n  fallback: boolean = true\n): Plugins[] =>\n  [\n    translationPlugin(\n      locale ?? internationalization.defaultLocale,\n      fallback ? internationalization.defaultLocale : undefined\n    ),\n    enumerationPlugin,\n    conditionPlugin,\n    insertionPlugin,\n    nestedPlugin(locale ?? internationalization.defaultLocale),\n    filePlugin,\n    genderPlugin,\n    selectPlugin,\n  ] as Plugins[];\n\n/**\n * Transforms a node in a single pass, applying each plugin as needed.\n *\n * @param node The node to transform.\n * @param locale The locale to use if your transformers need it (e.g. for translations).\n */\nexport const getContent = <\n  const T extends ContentNode,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  node: T,\n  nodeProps: NodeProps,\n  plugins: Plugins[] = []\n) =>\n  deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T, IInterpreterPluginState, L>;\n"],"mappings":";;;;;;AAsBA,MAAa,kBACX,QACA,WAAoB,SAEpB;CACEA,yDACE,UAAUC,4CAAqB,eAC/B,WAAWA,4CAAqB,gBAAgB,MAClD;CACAC;CACAC;CACAC;CACAC,oDAAa,UAAUJ,4CAAqB,aAAa;CACzDK;CACAC;CACAC;AACF;;;;;;;AAQF,MAAa,cAIX,MACA,WACA,UAAqB,CAAC,MAEtBC,+DAAkB,MAAM;CACtB,GAAG;CACH;AACF,CAAC"}
+{"version":3,"file":"getContent.cjs","names":["translationPlugin","internationalization","enumerationPlugin","pluralPlugin","conditionPlugin","insertionPlugin","nestedPlugin","filePlugin","genderPlugin","selectPlugin","fallbackPlugin","deepTransformNode"],"sources":["../../../../src/interpreter/getContent/getContent.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { ContentNode } from '@intlayer/types/dictionary';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { deepTransformNode } from './deepTransform';\nimport {\n  conditionPlugin,\n  type DeepTransformContent,\n  enumerationPlugin,\n  fallbackPlugin,\n  filePlugin,\n  genderPlugin,\n  type IInterpreterPluginState,\n  insertionPlugin,\n  type NodeProps,\n  nestedPlugin,\n  type Plugins,\n  pluralPlugin,\n  selectPlugin,\n  translationPlugin,\n} from './plugins';\n\nexport const getBasePlugins = (\n  locale?: LocalesValues,\n  fallback: boolean = true\n): Plugins[] =>\n  [\n    translationPlugin(\n      locale ?? internationalization.defaultLocale,\n      fallback ? internationalization.defaultLocale : undefined\n    ),\n    enumerationPlugin,\n    pluralPlugin(locale ?? internationalization.defaultLocale),\n    conditionPlugin,\n    insertionPlugin,\n    nestedPlugin(locale ?? internationalization.defaultLocale),\n    filePlugin,\n    genderPlugin,\n    selectPlugin,\n  ].filter(\n    // Plugins disabled at build time never match: skip them on every node\n    (plugin) => plugin !== fallbackPlugin\n  ) as Plugins[];\n\n/**\n * Transforms a node in a single pass, applying each plugin as needed.\n *\n * @param node The node to transform.\n * @param locale The locale to use if your transformers need it (e.g. for translations).\n */\nexport const getContent = <\n  const T extends ContentNode,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  node: T,\n  nodeProps: NodeProps,\n  plugins: Plugins[] = []\n) =>\n  deepTransformNode(node, {\n    ...nodeProps,\n    plugins,\n  }) as DeepTransformContent<T, IInterpreterPluginState, L>;\n"],"mappings":";;;;;;AAwBA,MAAa,kBACX,QACA,WAAoB,SAEpB;CACEA,yDACE,UAAUC,4CAAqB,eAC/B,WAAWA,4CAAqB,gBAAgB,MAClD;CACAC;CACAC,oDAAa,UAAUF,4CAAqB,aAAa;CACzDG;CACAC;CACAC,oDAAa,UAAUL,4CAAqB,aAAa;CACzDM;CACAC;CACAC;AACF,CAAC,CAAC,QAEC,WAAW,WAAWC,qDACzB;;;;;;;AAQF,MAAa,cAIX,MACA,WACA,UAAqB,CAAC,MAEtBC,+DAAkB,MAAM;CACtB,GAAG;CACH;AACF,CAAC"}

package/dist/cjs/interpreter/getContent/plugins.cjs

@@ -24,25 +24,33 @@ const fallbackPlugin = {
 	canHandle: () => false,
 	transform: (node) => node
 };
+/**
+* Whether a resolved branch still expects insertion values.
+*
+* Some renderers return callable nodes (Svelte components, Angular proxies)
+* exposing their content on `.value`: those are final and must not be called
+* with the values. A pending insertion either has no `.value` or a function
+* one.
+*/
+const isAwaitingValues = (branch) => {
+	if (typeof branch !== "function") return false;
+	const { value } = branch;
+	return value === void 0 || typeof value === "function";
+};
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
 const translationPlugin = (locale, fallback) => process.env.INTLAYER_NODE_TYPE_TRANSLATION === "false" ? fallbackPlugin : {
 	id: "translation-plugin",
 	canHandle: (node) => typeof node === "object" && node?.nodeType === _intlayer_types_nodeType.TRANSLATION,
 	transform: (node, props, deepTransformNode) => {
-		const original = node[_intlayer_types_nodeType.TRANSLATION] ?? {};
-		const result = {};
-		for (const key in original) {
-			const childProps = {
-				...props,
-				children: original[key],
-				keyPath: [...props.keyPath, {
-					type: _intlayer_types_nodeType.TRANSLATION,
-					key
-				}]
-			};
-			result[key] = deepTransformNode(original[key], childProps);
-		}
-		return require_interpreter_getTranslation.getTranslation(result, locale, fallback);
+		const content = require_interpreter_getTranslation.getTranslation(node[_intlayer_types_nodeType.TRANSLATION] ?? {}, locale, fallback);
+		return deepTransformNode(content, {
+			...props,
+			children: content,
+			keyPath: [...props.keyPath, {
+				type: _intlayer_types_nodeType.TRANSLATION,
+				key: locale
+			}]
+		});
 	}
 };
 /** Enumeration plugin. Replaces node with a function that takes quantity => string. */
@@ -66,7 +74,7 @@ const enumerationPlugin = process.env.INTLAYER_NODE_TYPE_ENUMERATION === "false"
 		return (arg) => {
 			const quantity = typeof arg === "number" ? arg : arg.count;
 			const subResult = require_interpreter_getEnumeration.getEnumeration(result, quantity);
-			if (typeof subResult === "function" && typeof arg === "object") return subResult(arg);
+			if (isAwaitingValues(subResult) && typeof arg === "object") return subResult(arg);
 			return subResult;
 		};
 	}
@@ -125,7 +133,7 @@ const pluralPlugin = (locale) => process.env.INTLAYER_NODE_TYPE_PLURAL === "fals
 			const count = typeof arg === "number" ? arg : arg.count;
 			const values = typeof arg === "number" ? { count: arg } : arg;
 			const subResult = require_interpreter_getPlural.getPlural(result, count, effectiveLocale);
-			if (typeof subResult === "function") return subResult(values);
+			if (isAwaitingValues(subResult)) return subResult(values);
 			return subResult;
 		};
 	}
@@ -151,7 +159,7 @@ const conditionPlugin = process.env.INTLAYER_NODE_TYPE_CONDITION === "false" ? f
 		return (arg) => {
 			const value = typeof arg === "boolean" ? arg : arg.value;
 			const subResult = require_interpreter_getCondition.getCondition(result, value);
-			if (typeof subResult === "function" && typeof arg === "object") return subResult(arg);
+			if (isAwaitingValues(subResult) && typeof arg === "object") return subResult(arg);
 			return subResult;
 		};
 	}
@@ -201,11 +209,6 @@ const selectorNodeTypes = [
 	_intlayer_types_nodeType.GENDER,
 	_intlayer_types_nodeType.SELECT
 ];
-/** Whether `insert()` wraps a selector node that resolved to a function. */
-const isInsertedSelector = (children, result) => {
-	const nodeType = typeof children === "object" && children !== null ? children.nodeType : void 0;
-	return typeof result === "function" && typeof nodeType === "string" && selectorNodeTypes.includes(nodeType);
-};
 /**
 * Binds the values of an `insert()` to the selector node it wraps, returning
 * `(selector) => content`. Any other child result is returned unchanged.
@@ -215,28 +218,20 @@ const isInsertedSelector = (children, result) => {
 * content and is never called with the values.
 */
 const bindInsertedValues = (children, result, values, areBranchesInterpolated = false) => {
-	if (!isInsertedSelector(children, result)) return result;
-	const isPlural = children.nodeType === _intlayer_types_nodeType.PLURAL;
-	const isEnumeration = children.nodeType === _intlayer_types_nodeType.ENUMERATION;
+	const nodeType = children?.nodeType;
+	if (typeof result !== "function" || !nodeType || !selectorNodeTypes.includes(nodeType)) return result;
+	const isCountSelector = nodeType === _intlayer_types_nodeType.PLURAL || nodeType === _intlayer_types_nodeType.ENUMERATION;
 	return (selector) => {
 		if (typeof selector === "object" && selector !== null) return result({
 			...values,
 			...selector
 		});
-		if (isPlural) return result({
+		if (isCountSelector) return result({
 			...values,
 			count: selector
 		});
-		if (isEnumeration && typeof selector === "number") {
-			const mergedValues = {
-				count: selector,
-				...values
-			};
-			const selected = result(mergedValues);
-			return !areBranchesInterpolated && typeof selected === "function" ? selected(mergedValues) : selected;
-		}
 		const selected = result(selector);
-		return !areBranchesInterpolated && typeof selected === "function" ? selected(values) : selected;
+		return !areBranchesInterpolated && isAwaitingValues(selected) ? selected(values) : selected;
 	};
 };
 /**
@@ -244,7 +239,7 @@ const bindInsertedValues = (children, result, values, areBranchesInterpolated =
 * `(values) => (selector) => content`, so the values reach the selected
 * branch. Any other child result is returned unchanged.
 */
-const resolveInsertedSelector = (children, result) => isInsertedSelector(children, result) ? (values) => bindInsertedValues(children, result, values) : result;
+const resolveInsertedSelector = (children, result) => typeof result === "function" && selectorNodeTypes.includes(children?.nodeType ?? "") ? (values) => bindInsertedValues(children, result, values) : result;
 /** Gender plugin. Replaces node with a function that takes gender => string. */
 const genderPlugin = process.env.INTLAYER_NODE_TYPE_GENDER === "false" ? fallbackPlugin : {
 	id: "gender-plugin",
@@ -287,7 +282,7 @@ const selectPlugin = process.env.INTLAYER_NODE_TYPE_SELECT === "false" ? fallbac
 		return (arg) => {
 			const value = typeof arg === "string" ? arg : arg?.value;
 			const subResult = require_interpreter_getSelect.getSelect(result, value);
-			if (typeof subResult === "function" && typeof arg === "object") return subResult(arg);
+			if (isAwaitingValues(subResult) && typeof arg === "object") return subResult(arg);
 			return subResult;
 		};
 	}

package/dist/cjs/interpreter/getContent/plugins.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.cjs","names":["NodeTypes","getTranslation","getEnumeration","isInterpolableWrapperNode","transformInterpolableNode","getInsertion","getPlural","getCondition","getGender","getSelect","getNestingOptimized","getNesting"],"sources":["../../../../src/interpreter/getContent/plugins.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  FileContent,\n  Gender,\n  GenderContent,\n  InsertionContent,\n  NestedContent,\n  PluralContent,\n  PluralContentState,\n  SelectContent,\n  TranslationContent,\n} from '../../transpiler';\nimport { getCondition } from '../getCondition';\nimport { getEnumeration } from '../getEnumeration';\nimport { getGender } from '../getGender';\nimport { getInsertion } from '../getInsertion';\nimport { type GetNestingResult, getNesting } from '../getNesting';\nimport { getNesting as getNestingOptimized } from '../getNesting.optimized';\nimport { getPlural } from '../getPlural';\nimport { getSelect } from '../getSelect';\nimport { getTranslation } from '../getTranslation';\nimport {\n  isInterpolableWrapperNode,\n  transformInterpolableNode,\n} from '../interpolableNode';\n\n// ── Tree-shake constants ──────────────────────────────────────────────────────\n// When these env vars are injected at build time, bundlers eliminate the\n// branches guarded by these constants.\n\n/** ---------------------------------------------\n * PLUGIN DEFINITION\n * --------------------------------------------- */\n\n/**\n * A plugin/transformer that can optionally transform a node during a single DFS pass.\n * - `canHandle` decides if the node is transformable by this plugin.\n * - `transform` returns the transformed node (and does not recurse further).\n *\n * > `transformFn` is a function that can be used to deeply transform inside the plugin.\n */\nexport type Plugins = {\n  id: string;\n  canHandle: (node: any) => boolean;\n  transform: (\n    node: any,\n    props: NodeProps,\n    transformFn: (node: any, props: NodeProps) => any\n  ) => any;\n};\n\n/** ---------------------------------------------\n * FALLBACK PLUGIN\n *\n * Used to fallback a tree-shaken plugin\n * --------------------------------------------- */\n\nexport const fallbackPlugin: Plugins = {\n  id: 'fallback-plugin',\n  canHandle: () => false,\n  transform: (node) => node,\n};\n\n/** ---------------------------------------------\n * TRANSLATION PLUGIN\n * --------------------------------------------- */\n\nexport type UnionKeys<T> = T extends unknown ? keyof T : never;\nexport type ValueAtKey<T, K> = T extends unknown\n  ? K extends keyof T\n    ? T[K]\n    : never\n  : never;\n\nexport type TranslationCond<T, S, L extends LocalesValues> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.TRANSLATION]: infer U;\n}\n  ? U extends Record<PropertyKey, unknown>\n    ? U[keyof U] extends Record<PropertyKey, unknown>\n      ? {\n          [K in UnionKeys<U[keyof U]>]: L extends keyof U\n            ? K extends keyof U[L]\n              ? U[L][K]\n              : ValueAtKey<U[keyof U], K>\n            : ValueAtKey<U[keyof U], K>;\n        } extends infer Content\n        ? DeepTransformContent<Content, S>\n        : never\n      : (L extends keyof U ? U[L] : U[keyof U]) extends infer Content\n        ? DeepTransformContent<Content, S>\n        : never\n    : never\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const translationPlugin = (\n  locale: LocalesValues,\n  fallback?: LocalesValues\n): Plugins =>\n  process.env.INTLAYER_NODE_TYPE_TRANSLATION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'translation-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.TRANSLATION,\n        transform: (node: TranslationContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.TRANSLATION] ?? {};\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const childProps = {\n              ...props,\n              children: original[key as keyof typeof original],\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.TRANSLATION, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(\n              original[key as keyof typeof original],\n              childProps\n            );\n          }\n\n          return getTranslation(result, locale, fallback);\n        },\n      };\n\n/** ---------------------------------------------\n * ENUMERATION PLUGIN\n * --------------------------------------------- */\n\nexport type EnumerationCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.ENUMERATION]: object;\n}\n  ? (\n      quantity: number\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.ENUMERATION][keyof T[typeof NodeTypes.ENUMERATION]],\n      S\n    >\n  : never;\n\n/** Enumeration plugin. Replaces node with a function that takes quantity => string. */\nexport const enumerationPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_ENUMERATION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'enumeration-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.ENUMERATION,\n        transform: (node: EnumerationContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.ENUMERATION];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as unknown as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.ENUMERATION, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (arg: number | { count: number }) => {\n            const quantity = typeof arg === 'number' ? arg : arg.count;\n            const subResult = getEnumeration(result, quantity);\n\n            if (typeof subResult === 'function' && typeof arg === 'object') {\n              return subResult(arg);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n * PLURAL PLUGIN\n * --------------------------------------------- */\n\n/**\n * A plural branch wrapped in an `insertion` node (auto-transformed\n * `{{count}}`) resolves to its inner content: the plural applies the values.\n */\ntype PluralBranch<Branch> = Branch extends {\n  nodeType: NodeType | string;\n  [NodeTypes.INSERTION]: infer InsertionContent;\n  fields: readonly string[];\n}\n  ? InsertionContent\n  : Branch;\n\nexport type PluralCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.PLURAL]: object;\n}\n  ? (\n      arg: number | { count: number; [key: string]: unknown }\n    ) => DeepTransformContent<\n      PluralBranch<\n        T[typeof NodeTypes.PLURAL][keyof T[typeof NodeTypes.PLURAL]]\n      >,\n      S\n    >\n  : never;\n\ntype SubResultFunction = (values: Record<string, string | number>) => string;\n\n/**\n * Plural plugin. Replaces node with a function that takes a count (or\n * `{ count, ...values }`) => string, picking the matching CLDR plural form\n * for the active locale and interpolating `{{count}}` (and other values).\n */\nexport const pluralPlugin = (locale?: LocalesValues): Plugins =>\n  process.env.INTLAYER_NODE_TYPE_PLURAL === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'plural-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.PLURAL,\n        transform: (node: PluralContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.PLURAL];\n          const result: Record<string, any> = {};\n          // The plural interpolates its own branches. A string plugin from an\n          // enclosing `insert()` would turn them into functions first.\n          const branchPlugins = (props.plugins ?? []).filter(\n            (plugin) => plugin.id !== 'insertion-string-plugin'\n          );\n\n          /** String plugin for plural. Replaces string node with a component that renders the insertion. */\n          const pluralStringPlugin: Plugins = {\n            id: 'plural-string-plugin',\n            canHandle: (node) =>\n              typeof node === 'string' || isInterpolableWrapperNode(node),\n            transform: (node, subProps, deepTransformNode) => {\n              // An `insertion` node below the plural (e.g. auto-transformed\n              // `{{count}}` branches) already returns `(values) => …`. Leave its\n              // strings untouched, or its template would become a function.\n              const isInsideInsertion = subProps.keyPath\n                .slice(props.keyPath.length)\n                .some((keyPath) => keyPath.type === NodeTypes.INSERTION);\n\n              if (isInsideInsertion) {\n                return deepTransformNode(node, {\n                  ...subProps,\n                  plugins: subProps.plugins?.filter(\n                    (plugin) => plugin.id !== 'plural-string-plugin'\n                  ),\n                });\n              }\n\n              // `html()`/`markdown()` nodes carry their `{{count}}` placeholders\n              // inside a raw string. Interpolate into that string, then re-run\n              // the transform so the html/markdown renderer applies afterwards.\n              if (isInterpolableWrapperNode(node)) {\n                return (values: { [k: string]: string | number }) =>\n                  transformInterpolableNode(\n                    node,\n                    values,\n                    subProps,\n                    branchPlugins,\n                    deepTransformNode\n                  );\n              }\n\n              const transformedResult = deepTransformNode(node, {\n                ...subProps,\n                children: node,\n                plugins: [\n                  ...branchPlugins.filter(\n                    (plugin) => plugin.id !== 'intlayer-node-plugin'\n                  ),\n                ],\n              });\n\n              return (values: { [k: string]: string | number }) => {\n                const children = getInsertion(transformedResult, values);\n\n                return deepTransformNode(children, {\n                  ...subProps,\n                  plugins: branchPlugins,\n                  children,\n                });\n              };\n            },\n          };\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.PLURAL, key } as KeyPath,\n              ],\n              plugins: [pluralStringPlugin, ...branchPlugins],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          const effectiveLocale = String(locale ?? props.locale ?? 'en');\n\n          return (arg: number | { count: number; [key: string]: unknown }) => {\n            const count = typeof arg === 'number' ? arg : arg.count;\n            const values =\n              typeof arg === 'number'\n                ? { count: arg }\n                : (arg as { count: number; [key: string]: unknown });\n\n            const subResult: string | SubResultFunction = getPlural(\n              result as PluralContent['plural'] as PluralContentState<string>,\n              count,\n              effectiveLocale\n            );\n\n            if (typeof subResult === 'function') {\n              return (subResult as SubResultFunction)(values);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n * CONDITION PLUGIN\n * --------------------------------------------- */\n\nexport type ConditionCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.CONDITION]: object;\n}\n  ? (\n      value: boolean | { value: boolean }\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.CONDITION][keyof T[typeof NodeTypes.CONDITION]],\n      S\n    >\n  : never;\n\n/** Condition plugin. Replaces node with a function that takes boolean => string. */\nexport const conditionPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_CONDITION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'condition-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.CONDITION,\n        transform: (node: ConditionContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.CONDITION];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.CONDITION, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (arg: boolean | { value: boolean }) => {\n            const value = typeof arg === 'boolean' ? arg : arg.value;\n            const subResult = getCondition(result as any, value);\n\n            if (typeof subResult === 'function' && typeof arg === 'object') {\n              return subResult(arg);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n *  INSERTION PLUGIN\n *  --------------------------------------------- */\n\nexport type InsertionCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.INSERTION]: infer I;\n  fields: readonly string[];\n}\n  ? (\n      values: {\n        [K in T['fields'][number]]: string | number;\n      }\n    ) => I extends string\n      ? DeepTransformContent<string, S>\n      : DeepTransformContent<I, S>\n  : never;\n\n/** Insertion plugin. Replaces node with a function that takes quantity => string. */\nexport const insertionPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_INSERTION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'insertion-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.INSERTION,\n        transform: (node: InsertionContent, props, deepTransformNode) => {\n          const newKeyPath: KeyPath[] = [\n            ...props.keyPath,\n            {\n              type: NodeTypes.INSERTION,\n            },\n          ];\n\n          const children = node[NodeTypes.INSERTION];\n\n          /** Insertion string plugin. Replaces string node with a component that render the insertion. */\n          const insertionStringPlugin: Plugins = {\n            id: 'insertion-string-plugin',\n            canHandle: (node) =>\n              typeof node === 'string' || isInterpolableWrapperNode(node),\n            transform: (node, subProps, deepTransformNode) => {\n              // `html()`/`markdown()` nodes carry their `{{ … }}` placeholders\n              // inside a raw string. Interpolate into that string, then re-run\n              // the transform so the html/markdown renderer applies afterwards.\n              if (isInterpolableWrapperNode(node)) {\n                return (\n                  values: {\n                    [K in InsertionContent['fields'][number]]: string | number;\n                  }\n                ) =>\n                  transformInterpolableNode(\n                    node,\n                    values,\n                    subProps,\n                    props.plugins,\n                    deepTransformNode\n                  );\n              }\n\n              const transformedResult = deepTransformNode(node, {\n                ...subProps,\n                children: node,\n                plugins: [\n                  ...(props.plugins ?? ([] as Plugins[])).filter(\n                    (plugin) => plugin.id !== 'intlayer-node-plugin'\n                  ),\n                ],\n              });\n\n              return (\n                values: {\n                  [K in InsertionContent['fields'][number]]: string | number;\n                }\n              ) => {\n                const children = getInsertion(transformedResult, values);\n\n                return deepTransformNode(children, {\n                  ...subProps,\n                  plugins: props.plugins,\n                  children,\n                });\n              };\n            },\n          };\n\n          const result = deepTransformNode(children, {\n            ...props,\n            children,\n            keyPath: newKeyPath,\n            plugins: [insertionStringPlugin, ...(props.plugins ?? [])],\n          });\n\n          return resolveInsertedSelector(children, result);\n        },\n      };\n\n/** Container nodes resolved by a selector call: `enu(3)`, `cond(true)`, … */\nconst selectorNodeTypes: string[] = [\n  NodeTypes.ENUMERATION,\n  NodeTypes.CONDITION,\n  NodeTypes.PLURAL,\n  NodeTypes.GENDER,\n  NodeTypes.SELECT,\n];\n\n/** Whether `insert()` wraps a selector node that resolved to a function. */\nconst isInsertedSelector = (\n  children: unknown,\n  result: unknown\n): result is (selector: unknown) => unknown => {\n  const nodeType =\n    typeof children === 'object' && children !== null\n      ? (children as { nodeType?: unknown }).nodeType\n      : undefined;\n\n  return (\n    typeof result === 'function' &&\n    typeof nodeType === 'string' &&\n    selectorNodeTypes.includes(nodeType)\n  );\n};\n\n/**\n * Binds the values of an `insert()` to the selector node it wraps, returning\n * `(selector) => content`. Any other child result is returned unchanged.\n *\n * `areBranchesInterpolated` is set by frameworks that interpolate the branch\n * strings as soon as the values are known: the selected branch is then final\n * content and is never called with the values.\n */\nexport const bindInsertedValues = (\n  children: unknown,\n  result: unknown,\n  values: Record<string, unknown>,\n  areBranchesInterpolated = false\n): unknown => {\n  if (!isInsertedSelector(children, result)) {\n    return result;\n  }\n\n  const isPlural =\n    (children as { nodeType: string }).nodeType === NodeTypes.PLURAL;\n  const isEnumeration =\n    (children as { nodeType: string }).nodeType === NodeTypes.ENUMERATION;\n\n  return (selector: unknown) => {\n    // Object selectors (`{ count }`, `{ value }`) carry the values along.\n    if (typeof selector === 'object' && selector !== null) {\n      return result({ ...values, ...selector });\n    }\n\n    // Plural interpolates its own branches, `{{count}}` included.\n    if (isPlural) {\n      return result({ ...values, count: selector });\n    }\n\n    // Enumeration selector is a numeric count (or count range)\n    if (isEnumeration && typeof selector === 'number') {\n      const mergedValues = { count: selector, ...values };\n      const selected = result(mergedValues);\n\n      return !areBranchesInterpolated && typeof selected === 'function'\n        ? selected(mergedValues)\n        : selected;\n    }\n\n    const selected = result(selector);\n\n    return !areBranchesInterpolated && typeof selected === 'function'\n      ? selected(values)\n      : selected;\n  };\n};\n\n/**\n * Shapes the result of `insert()` wrapping a selector node as\n * `(values) => (selector) => content`, so the values reach the selected\n * branch. Any other child result is returned unchanged.\n */\nexport const resolveInsertedSelector = (\n  children: unknown,\n  result: unknown\n): unknown =>\n  isInsertedSelector(children, result)\n    ? (values: Record<string, unknown>) =>\n        bindInsertedValues(children, result, values)\n    : result;\n\n/** ---------------------------------------------\n * GENDER PLUGIN\n * --------------------------------------------- */\n\nexport type GenderCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.GENDER]: object;\n}\n  ? (\n      value: Gender\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.GENDER][keyof T[typeof NodeTypes.GENDER]],\n      S\n    >\n  : never;\n\n/** Gender plugin. Replaces node with a function that takes gender => string. */\nexport const genderPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_GENDER === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'gender-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.GENDER,\n        transform: (node: GenderContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.GENDER];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.GENDER, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (value: Gender) => getGender(result as any, value);\n        },\n      };\n\n/** ---------------------------------------------\n * SELECT PLUGIN\n * --------------------------------------------- */\n\n/**\n * Accepted selector for a select node.\n *\n * When the node declares a `fallback` case, any string is accepted (the\n * fallback covers the unmatched values) while the declared cases still\n * autocomplete. Without a `fallback`, only the declared cases are accepted.\n */\nexport type SelectSelector<States> = 'fallback' extends keyof States\n  ? Exclude<keyof States & string, 'fallback'> | (string & {})\n  : keyof States & string;\n\nexport type SelectCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.SELECT]: object;\n}\n  ? (\n      value:\n        | SelectSelector<T[typeof NodeTypes.SELECT]>\n        | { value: SelectSelector<T[typeof NodeTypes.SELECT]> }\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.SELECT][keyof T[typeof NodeTypes.SELECT]],\n      S\n    >\n  : never;\n\n/** Select plugin. Replaces node with a function that takes a string => content. */\nexport const selectPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_SELECT === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'select-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.SELECT,\n        transform: (node: SelectContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.SELECT];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.SELECT, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (arg: string | { value: string }) => {\n            const value = typeof arg === 'string' ? arg : arg?.value;\n            const subResult = getSelect(result, value);\n\n            if (typeof subResult === 'function' && typeof arg === 'object') {\n              return subResult(arg);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n * NESTED PLUGIN\n * --------------------------------------------- */\n\nexport type NestedCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.NESTED]: infer U;\n}\n  ? U extends {\n      dictionaryKey: infer K extends DictionaryKeys;\n      path?: infer P;\n    }\n    ? GetNestingResult<K, P, S>\n    : never\n  : never;\n\n/**\n * Resolver used to turn a nested node into content.\n *\n * Optimized builds set `INTLAYER_OPTIMIZED_NESTING` so bundlers fold this to\n * the local resolver and dead-code-eliminate the registry-based one — together\n * with its `getIntlayer` import, and therefore the whole\n * `@intlayer/dictionaries-entry` module. That is what allows the dictionaries\n * entry to be emptied while `nest()` keeps working.\n */\nconst resolveNesting =\n  process.env.INTLAYER_OPTIMIZED_NESTING === 'true'\n    ? getNestingOptimized\n    : getNesting;\n\n/** Nested plugin. Replaces node with the result of `getNesting`. */\nexport const nestedPlugin = (locale?: LocalesValues): Plugins =>\n  process.env.INTLAYER_NODE_TYPE_NESTED === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'nested-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' &&\n          (node?.nodeType === NodeTypes.NESTED || node?.nodeType === 'n'),\n        transform: (node: NestedContent, props) =>\n          resolveNesting(\n            node[NodeTypes.NESTED].dictionaryKey,\n            node[NodeTypes.NESTED].path,\n            {\n              ...props,\n              locale: (locale ?? props.locale) as Locale,\n            }\n          ),\n      };\n\n/** ---------------------------------------------\n * FILE PLUGIN\n * --------------------------------------------- */\n\nexport type FileCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.FILE]: string;\n  content?: string;\n}\n  ? DeepTransformContent<string, S>\n  : never;\n\n/** File plugin. Replaces node with the result of `getNesting`. */\nexport const filePlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_FILE === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'file-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.FILE,\n        transform: (node: FileContent, props, deepTransform) =>\n          deepTransform(node.content, {\n            ...props,\n            children: node.content,\n          }),\n      };\n\n/**\n * PLUGIN RESULT\n */\n\n/**\n * Interface that defines the properties of a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface NodeProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  plugins?: Plugins[];\n  locale?: Locale;\n  dictionaryPath?: string;\n  children?: any;\n  /**\n   * Dictionaries referenced through `nest()`, attached to the consuming\n   * dictionary by the build optimization and threaded down by\n   * `deepTransformNode`.\n   *\n   * Present only in optimized builds, where the global dictionary registry is\n   * stripped and `getNesting` resolves from this map instead. See\n   * `getNesting.optimized.ts`.\n   */\n  nestedDictionaries?: Record<string, unknown>;\n  /**\n   * Forces eager traversal of plain objects in `deepTransformNode`. By default\n   * traversal is lazy (property getters), so callers that discard the returned\n   * value never trigger plugins on nested nodes. Set this when running plugins\n   * for their side effects only (e.g. missing-locale detection).\n   */\n  eager?: boolean;\n}\n\n/**\n * Interface that defines the plugins that can be used to transform a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface IInterpreterPlugin<T, S, L extends LocalesValues> {\n  translation: TranslationCond<T, S, L>;\n  enumeration: EnumerationCond<T, S, L>;\n  plural: PluralCond<T, S, L>;\n  condition: ConditionCond<T, S, L>;\n  insertion: InsertionCond<T, S, L>;\n  gender: GenderCond<T, S, L>;\n  select: SelectCond<T, S, L>;\n  nested: NestedCond<T, S, L>;\n  file: FileCond<T, S, L>;\n}\n\n/**\n * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.\n */\nexport type IInterpreterPluginState = {\n  translation: true;\n  enumeration: true;\n  plural: true;\n  condition: true;\n  insertion: true;\n  gender: true;\n  select: true;\n  nested: true;\n  file: true;\n};\n\n/**\n * Utility type to check if a plugin can be applied to a node.\n */\ntype CheckApplyPlugin<\n  T,\n  K extends keyof IInterpreterPlugin<T, S, L>,\n  S,\n  L extends LocalesValues = DeclaredLocales,\n> = K extends keyof S // Test if the key is a key of S.\n  ? // Test if the key of S is true. Then the plugin can be applied.\n    S[K] extends true\n    ? // Test if the key of S exist\n      IInterpreterPlugin<T, S, L>[K] extends never\n      ? never\n      : // Test if the plugin condition is true (if it's not, the plugin is skipped for this node)\n        IInterpreterPlugin<T, S, L>[K]\n    : never\n  : never;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\ntype Traverse<T, S, L extends LocalesValues = DeclaredLocales> =\n  T extends ReadonlyArray<infer U> // Turn any read-only array into a plain mutable array\n    ? Array<DeepTransformContent<U, S, L>>\n    : T extends object\n      ? { [K in keyof T]: DeepTransformContent<T[K], S, L> }\n      : T;\n\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\nexport type DeepTransformContent<\n  T,\n  S = IInterpreterPluginState,\n  L extends LocalesValues = DeclaredLocales,\n> =\n  IsAny<T> extends true\n    ? T\n    : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L> extends never // Check if there is a plugin for T:\n      ? // No plugin was found, so try to transform T recursively:\n        Traverse<T, S, L>\n      : // A plugin was found – use the plugin's transformation.\n        CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L>;\n"],"mappings":"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"}
+{"version":3,"file":"plugins.cjs","names":["NodeTypes","getTranslation","getEnumeration","isInterpolableWrapperNode","transformInterpolableNode","getInsertion","getPlural","getCondition","getGender","getSelect","getNestingOptimized","getNesting"],"sources":["../../../../src/interpreter/getContent/plugins.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { KeyPath } from '@intlayer/types/keyPath';\nimport type {\n  DeclaredLocales,\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport type { NodeType } from '@intlayer/types/nodeType';\nimport * as NodeTypes from '@intlayer/types/nodeType';\nimport type {\n  ConditionContent,\n  EnumerationContent,\n  FileContent,\n  Gender,\n  GenderContent,\n  InsertionContent,\n  NestedContent,\n  PluralContent,\n  PluralContentState,\n  SelectContent,\n  TranslationContent,\n} from '../../transpiler';\nimport { getCondition } from '../getCondition';\nimport { getEnumeration } from '../getEnumeration';\nimport { getGender } from '../getGender';\nimport { getInsertion } from '../getInsertion';\nimport { type GetNestingResult, getNesting } from '../getNesting';\nimport { getNesting as getNestingOptimized } from '../getNesting.optimized';\nimport { getPlural } from '../getPlural';\nimport { getSelect } from '../getSelect';\nimport { getTranslation } from '../getTranslation';\nimport {\n  isInterpolableWrapperNode,\n  transformInterpolableNode,\n} from '../interpolableNode';\n\n// ── Tree-shake constants ──────────────────────────────────────────────────────\n// When these env vars are injected at build time, bundlers eliminate the\n// branches guarded by these constants.\n\n/** ---------------------------------------------\n * PLUGIN DEFINITION\n * --------------------------------------------- */\n\n/**\n * A plugin/transformer that can optionally transform a node during a single DFS pass.\n * - `canHandle` decides if the node is transformable by this plugin.\n * - `transform` returns the transformed node (and does not recurse further).\n *\n * > `transformFn` is a function that can be used to deeply transform inside the plugin.\n */\nexport type Plugins = {\n  id: string;\n  canHandle: (node: any) => boolean;\n  transform: (\n    node: any,\n    props: NodeProps,\n    transformFn: (node: any, props: NodeProps) => any\n  ) => any;\n};\n\n/** ---------------------------------------------\n * FALLBACK PLUGIN\n *\n * Used to fallback a tree-shaken plugin\n * --------------------------------------------- */\n\nexport const fallbackPlugin: Plugins = {\n  id: 'fallback-plugin',\n  canHandle: () => false,\n  transform: (node) => node,\n};\n\n/**\n * Whether a resolved branch still expects insertion values.\n *\n * Some renderers return callable nodes (Svelte components, Angular proxies)\n * exposing their content on `.value`: those are final and must not be called\n * with the values. A pending insertion either has no `.value` or a function\n * one.\n */\nconst isAwaitingValues = (\n  branch: unknown\n): branch is (values: Record<string, unknown>) => unknown => {\n  if (typeof branch !== 'function') return false;\n\n  const { value } = branch as { value?: unknown };\n\n  return value === undefined || typeof value === 'function';\n};\n\n/** ---------------------------------------------\n * TRANSLATION PLUGIN\n * --------------------------------------------- */\n\nexport type UnionKeys<T> = T extends unknown ? keyof T : never;\nexport type ValueAtKey<T, K> = T extends unknown\n  ? K extends keyof T\n    ? T[K]\n    : never\n  : never;\n\nexport type TranslationCond<T, S, L extends LocalesValues> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.TRANSLATION]: infer U;\n}\n  ? U extends Record<PropertyKey, unknown>\n    ? U[keyof U] extends Record<PropertyKey, unknown>\n      ? {\n          [K in UnionKeys<U[keyof U]>]: L extends keyof U\n            ? K extends keyof U[L]\n              ? U[L][K]\n              : ValueAtKey<U[keyof U], K>\n            : ValueAtKey<U[keyof U], K>;\n        } extends infer Content\n        ? DeepTransformContent<Content, S>\n        : never\n      : (L extends keyof U ? U[L] : U[keyof U]) extends infer Content\n        ? DeepTransformContent<Content, S>\n        : never\n    : never\n  : never;\n\n/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */\nexport const translationPlugin = (\n  locale: LocalesValues,\n  fallback?: LocalesValues\n): Plugins =>\n  process.env.INTLAYER_NODE_TYPE_TRANSLATION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'translation-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.TRANSLATION,\n        transform: (node: TranslationContent, props, deepTransformNode) => {\n          // Resolve on the raw content first: only the displayed locale (and\n          // the fallback keys it lacks) is ever transformed\n          const content = getTranslation(\n            node[NodeTypes.TRANSLATION] ?? {},\n            locale,\n            fallback\n          );\n\n          return deepTransformNode(content, {\n            ...props,\n            children: content,\n            keyPath: [\n              ...props.keyPath,\n              { type: NodeTypes.TRANSLATION, key: locale } as KeyPath,\n            ],\n          });\n        },\n      };\n\n/** ---------------------------------------------\n * ENUMERATION PLUGIN\n * --------------------------------------------- */\n\nexport type EnumerationCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.ENUMERATION]: object;\n}\n  ? (\n      quantity: number\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.ENUMERATION][keyof T[typeof NodeTypes.ENUMERATION]],\n      S\n    >\n  : never;\n\n/** Enumeration plugin. Replaces node with a function that takes quantity => string. */\nexport const enumerationPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_ENUMERATION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'enumeration-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.ENUMERATION,\n        transform: (node: EnumerationContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.ENUMERATION];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as unknown as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.ENUMERATION, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (arg: number | { count: number }) => {\n            const quantity = typeof arg === 'number' ? arg : arg.count;\n            const subResult = getEnumeration(result, quantity);\n\n            if (isAwaitingValues(subResult) && typeof arg === 'object') {\n              return subResult(arg);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n * PLURAL PLUGIN\n * --------------------------------------------- */\n\n/**\n * A plural branch wrapped in an `insertion` node (auto-transformed\n * `{{count}}`) resolves to its inner content: the plural applies the values.\n */\ntype PluralBranch<Branch> = Branch extends {\n  nodeType: NodeType | string;\n  [NodeTypes.INSERTION]: infer InsertionContent;\n  fields: readonly string[];\n}\n  ? InsertionContent\n  : Branch;\n\nexport type PluralCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.PLURAL]: object;\n}\n  ? (\n      arg: number | { count: number; [key: string]: unknown }\n    ) => DeepTransformContent<\n      PluralBranch<\n        T[typeof NodeTypes.PLURAL][keyof T[typeof NodeTypes.PLURAL]]\n      >,\n      S\n    >\n  : never;\n\ntype SubResultFunction = (values: Record<string, string | number>) => string;\n\n/**\n * Plural plugin. Replaces node with a function that takes a count (or\n * `{ count, ...values }`) => string, picking the matching CLDR plural form\n * for the active locale and interpolating `{{count}}` (and other values).\n */\nexport const pluralPlugin = (locale?: LocalesValues): Plugins =>\n  process.env.INTLAYER_NODE_TYPE_PLURAL === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'plural-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.PLURAL,\n        transform: (node: PluralContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.PLURAL];\n          const result: Record<string, any> = {};\n          // The plural interpolates its own branches. A string plugin from an\n          // enclosing `insert()` would turn them into functions first.\n          const branchPlugins = (props.plugins ?? []).filter(\n            (plugin) => plugin.id !== 'insertion-string-plugin'\n          );\n\n          /** String plugin for plural. Replaces string node with a component that renders the insertion. */\n          const pluralStringPlugin: Plugins = {\n            id: 'plural-string-plugin',\n            canHandle: (node) =>\n              typeof node === 'string' || isInterpolableWrapperNode(node),\n            transform: (node, subProps, deepTransformNode) => {\n              // An `insertion` node below the plural (e.g. auto-transformed\n              // `{{count}}` branches) already returns `(values) => …`. Leave its\n              // strings untouched, or its template would become a function.\n              const isInsideInsertion = subProps.keyPath\n                .slice(props.keyPath.length)\n                .some((keyPath) => keyPath.type === NodeTypes.INSERTION);\n\n              if (isInsideInsertion) {\n                return deepTransformNode(node, {\n                  ...subProps,\n                  plugins: subProps.plugins?.filter(\n                    (plugin) => plugin.id !== 'plural-string-plugin'\n                  ),\n                });\n              }\n\n              // `html()`/`markdown()` nodes carry their `{{count}}` placeholders\n              // inside a raw string. Interpolate into that string, then re-run\n              // the transform so the html/markdown renderer applies afterwards.\n              if (isInterpolableWrapperNode(node)) {\n                return (values: { [k: string]: string | number }) =>\n                  transformInterpolableNode(\n                    node,\n                    values,\n                    subProps,\n                    branchPlugins,\n                    deepTransformNode\n                  );\n              }\n\n              const transformedResult = deepTransformNode(node, {\n                ...subProps,\n                children: node,\n                plugins: [\n                  ...branchPlugins.filter(\n                    (plugin) => plugin.id !== 'intlayer-node-plugin'\n                  ),\n                ],\n              });\n\n              return (values: { [k: string]: string | number }) => {\n                const children = getInsertion(transformedResult, values);\n\n                return deepTransformNode(children, {\n                  ...subProps,\n                  plugins: branchPlugins,\n                  children,\n                });\n              };\n            },\n          };\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.PLURAL, key } as KeyPath,\n              ],\n              plugins: [pluralStringPlugin, ...branchPlugins],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          const effectiveLocale = String(locale ?? props.locale ?? 'en');\n\n          return (arg: number | { count: number; [key: string]: unknown }) => {\n            const count = typeof arg === 'number' ? arg : arg.count;\n            const values =\n              typeof arg === 'number'\n                ? { count: arg }\n                : (arg as { count: number; [key: string]: unknown });\n\n            const subResult: string | SubResultFunction = getPlural(\n              result as PluralContent['plural'] as PluralContentState<string>,\n              count,\n              effectiveLocale\n            );\n\n            if (isAwaitingValues(subResult)) {\n              return (subResult as SubResultFunction)(values);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n * CONDITION PLUGIN\n * --------------------------------------------- */\n\nexport type ConditionCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.CONDITION]: object;\n}\n  ? (\n      value: boolean | { value: boolean }\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.CONDITION][keyof T[typeof NodeTypes.CONDITION]],\n      S\n    >\n  : never;\n\n/** Condition plugin. Replaces node with a function that takes boolean => string. */\nexport const conditionPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_CONDITION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'condition-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.CONDITION,\n        transform: (node: ConditionContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.CONDITION];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.CONDITION, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (arg: boolean | { value: boolean }) => {\n            const value = typeof arg === 'boolean' ? arg : arg.value;\n            const subResult = getCondition(result as any, value);\n\n            if (isAwaitingValues(subResult) && typeof arg === 'object') {\n              return subResult(arg);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n *  INSERTION PLUGIN\n *  --------------------------------------------- */\n\nexport type InsertionCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.INSERTION]: infer I;\n  fields: readonly string[];\n}\n  ? (\n      values: {\n        [K in T['fields'][number]]: string | number;\n      }\n    ) => I extends string\n      ? DeepTransformContent<string, S>\n      : DeepTransformContent<I, S>\n  : never;\n\n/** Insertion plugin. Replaces node with a function that takes quantity => string. */\nexport const insertionPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_INSERTION === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'insertion-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.INSERTION,\n        transform: (node: InsertionContent, props, deepTransformNode) => {\n          const newKeyPath: KeyPath[] = [\n            ...props.keyPath,\n            {\n              type: NodeTypes.INSERTION,\n            },\n          ];\n\n          const children = node[NodeTypes.INSERTION];\n\n          /** Insertion string plugin. Replaces string node with a component that render the insertion. */\n          const insertionStringPlugin: Plugins = {\n            id: 'insertion-string-plugin',\n            canHandle: (node) =>\n              typeof node === 'string' || isInterpolableWrapperNode(node),\n            transform: (node, subProps, deepTransformNode) => {\n              // `html()`/`markdown()` nodes carry their `{{ … }}` placeholders\n              // inside a raw string. Interpolate into that string, then re-run\n              // the transform so the html/markdown renderer applies afterwards.\n              if (isInterpolableWrapperNode(node)) {\n                return (\n                  values: {\n                    [K in InsertionContent['fields'][number]]: string | number;\n                  }\n                ) =>\n                  transformInterpolableNode(\n                    node,\n                    values,\n                    subProps,\n                    props.plugins,\n                    deepTransformNode\n                  );\n              }\n\n              const transformedResult = deepTransformNode(node, {\n                ...subProps,\n                children: node,\n                plugins: [\n                  ...(props.plugins ?? ([] as Plugins[])).filter(\n                    (plugin) => plugin.id !== 'intlayer-node-plugin'\n                  ),\n                ],\n              });\n\n              return (\n                values: {\n                  [K in InsertionContent['fields'][number]]: string | number;\n                }\n              ) => {\n                const children = getInsertion(transformedResult, values);\n\n                return deepTransformNode(children, {\n                  ...subProps,\n                  plugins: props.plugins,\n                  children,\n                });\n              };\n            },\n          };\n\n          const result = deepTransformNode(children, {\n            ...props,\n            children,\n            keyPath: newKeyPath,\n            plugins: [insertionStringPlugin, ...(props.plugins ?? [])],\n          });\n\n          return resolveInsertedSelector(children, result);\n        },\n      };\n\n/** Container nodes resolved by a selector call: `enu(3)`, `cond(true)`, … */\nconst selectorNodeTypes: string[] = [\n  NodeTypes.ENUMERATION,\n  NodeTypes.CONDITION,\n  NodeTypes.PLURAL,\n  NodeTypes.GENDER,\n  NodeTypes.SELECT,\n];\n\n/**\n * Binds the values of an `insert()` to the selector node it wraps, returning\n * `(selector) => content`. Any other child result is returned unchanged.\n *\n * `areBranchesInterpolated` is set by frameworks that interpolate the branch\n * strings as soon as the values are known: the selected branch is then final\n * content and is never called with the values.\n */\nexport const bindInsertedValues = (\n  children: unknown,\n  result: unknown,\n  values: Record<string, unknown>,\n  areBranchesInterpolated = false\n): unknown => {\n  const nodeType = (children as { nodeType?: string })?.nodeType;\n  if (\n    typeof result !== 'function' ||\n    !nodeType ||\n    !selectorNodeTypes.includes(nodeType)\n  ) {\n    return result;\n  }\n\n  const isCountSelector =\n    nodeType === NodeTypes.PLURAL || nodeType === NodeTypes.ENUMERATION;\n\n  return (selector: unknown) => {\n    // Object selectors (`{ count }`, `{ value }`) carry the values along.\n    if (typeof selector === 'object' && selector !== null) {\n      return result({ ...values, ...selector });\n    }\n\n    // The count both selects the branch and fills `{{count}}`: the selector\n    // wins over a `count` passed with the values.\n    if (isCountSelector) {\n      return result({ ...values, count: selector });\n    }\n\n    const selected = result(selector);\n\n    return !areBranchesInterpolated && isAwaitingValues(selected)\n      ? selected(values)\n      : selected;\n  };\n};\n\n/**\n * Shapes the result of `insert()` wrapping a selector node as\n * `(values) => (selector) => content`, so the values reach the selected\n * branch. Any other child result is returned unchanged.\n */\nexport const resolveInsertedSelector = (\n  children: unknown,\n  result: unknown\n): unknown =>\n  typeof result === 'function' &&\n  selectorNodeTypes.includes(\n    (children as { nodeType?: string })?.nodeType ?? ''\n  )\n    ? (values: Record<string, unknown>) =>\n        bindInsertedValues(children, result, values)\n    : result;\n\n/** ---------------------------------------------\n * GENDER PLUGIN\n * --------------------------------------------- */\n\nexport type GenderCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.GENDER]: object;\n}\n  ? (\n      value: Gender\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.GENDER][keyof T[typeof NodeTypes.GENDER]],\n      S\n    >\n  : never;\n\n/** Gender plugin. Replaces node with a function that takes gender => string. */\nexport const genderPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_GENDER === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'gender-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.GENDER,\n        transform: (node: GenderContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.GENDER];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.GENDER, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (value: Gender) => getGender(result as any, value);\n        },\n      };\n\n/** ---------------------------------------------\n * SELECT PLUGIN\n * --------------------------------------------- */\n\n/**\n * Accepted selector for a select node.\n *\n * When the node declares a `fallback` case, any string is accepted (the\n * fallback covers the unmatched values) while the declared cases still\n * autocomplete. Without a `fallback`, only the declared cases are accepted.\n */\nexport type SelectSelector<States> = 'fallback' extends keyof States\n  ? Exclude<keyof States & string, 'fallback'> | (string & {})\n  : keyof States & string;\n\nexport type SelectCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.SELECT]: object;\n}\n  ? (\n      value:\n        | SelectSelector<T[typeof NodeTypes.SELECT]>\n        | { value: SelectSelector<T[typeof NodeTypes.SELECT]> }\n    ) => DeepTransformContent<\n      T[typeof NodeTypes.SELECT][keyof T[typeof NodeTypes.SELECT]],\n      S\n    >\n  : never;\n\n/** Select plugin. Replaces node with a function that takes a string => content. */\nexport const selectPlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_SELECT === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'select-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.SELECT,\n        transform: (node: SelectContent, props, deepTransformNode) => {\n          const original = node[NodeTypes.SELECT];\n          const result: Record<string, any> = {};\n\n          for (const key in original) {\n            const child = original[key as keyof typeof original];\n            const childProps = {\n              ...props,\n              children: child,\n              keyPath: [\n                ...props.keyPath,\n                { type: NodeTypes.SELECT, key } as KeyPath,\n              ],\n            };\n            result[key] = deepTransformNode(child, childProps);\n          }\n\n          return (arg: string | { value: string }) => {\n            const value = typeof arg === 'string' ? arg : arg?.value;\n            const subResult = getSelect(result, value);\n\n            if (isAwaitingValues(subResult) && typeof arg === 'object') {\n              return subResult(arg);\n            }\n\n            return subResult;\n          };\n        },\n      };\n\n/** ---------------------------------------------\n * NESTED PLUGIN\n * --------------------------------------------- */\n\nexport type NestedCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.NESTED]: infer U;\n}\n  ? U extends {\n      dictionaryKey: infer K extends DictionaryKeys;\n      path?: infer P;\n    }\n    ? GetNestingResult<K, P, S>\n    : never\n  : never;\n\n/**\n * Resolver used to turn a nested node into content.\n *\n * Optimized builds set `INTLAYER_OPTIMIZED_NESTING` so bundlers fold this to\n * the local resolver and dead-code-eliminate the registry-based one — together\n * with its `getIntlayer` import, and therefore the whole\n * `@intlayer/dictionaries-entry` module. That is what allows the dictionaries\n * entry to be emptied while `nest()` keeps working.\n */\nconst resolveNesting =\n  process.env.INTLAYER_OPTIMIZED_NESTING === 'true'\n    ? getNestingOptimized\n    : getNesting;\n\n/** Nested plugin. Replaces node with the result of `getNesting`. */\nexport const nestedPlugin = (locale?: LocalesValues): Plugins =>\n  process.env.INTLAYER_NODE_TYPE_NESTED === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'nested-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' &&\n          (node?.nodeType === NodeTypes.NESTED || node?.nodeType === 'n'),\n        transform: (node: NestedContent, props) =>\n          resolveNesting(\n            node[NodeTypes.NESTED].dictionaryKey,\n            node[NodeTypes.NESTED].path,\n            {\n              ...props,\n              locale: (locale ?? props.locale) as Locale,\n            }\n          ),\n      };\n\n/** ---------------------------------------------\n * FILE PLUGIN\n * --------------------------------------------- */\n\nexport type FileCond<T, S, _L> = T extends {\n  nodeType: NodeType | string;\n  [NodeTypes.FILE]: string;\n  content?: string;\n}\n  ? DeepTransformContent<string, S>\n  : never;\n\n/** File plugin. Replaces node with the result of `getNesting`. */\nexport const filePlugin: Plugins =\n  process.env.INTLAYER_NODE_TYPE_FILE === 'false'\n    ? fallbackPlugin\n    : {\n        id: 'file-plugin',\n        canHandle: (node) =>\n          typeof node === 'object' && node?.nodeType === NodeTypes.FILE,\n        transform: (node: FileContent, props, deepTransform) =>\n          deepTransform(node.content, {\n            ...props,\n            children: node.content,\n          }),\n      };\n\n/**\n * PLUGIN RESULT\n */\n\n/**\n * Interface that defines the properties of a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface NodeProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  plugins?: Plugins[];\n  locale?: Locale;\n  dictionaryPath?: string;\n  children?: any;\n  /**\n   * Dictionaries referenced through `nest()`, attached to the consuming\n   * dictionary by the build optimization and threaded down by\n   * `deepTransformNode`.\n   *\n   * Present only in optimized builds, where the global dictionary registry is\n   * stripped and `getNesting` resolves from this map instead. See\n   * `getNesting.optimized.ts`.\n   */\n  nestedDictionaries?: Record<string, unknown>;\n  /**\n   * Forces eager traversal of plain objects in `deepTransformNode`. By default\n   * traversal is lazy (property getters), so callers that discard the returned\n   * value never trigger plugins on nested nodes. Set this when running plugins\n   * for their side effects only (e.g. missing-locale detection), or when most\n   * of the content is read anyway: defining a getter per key, then redefining\n   * it on first read, costs more than transforming the key outright.\n   */\n  eager?: boolean;\n}\n\n/**\n * Interface that defines the plugins that can be used to transform a node.\n * This interface can be augmented in other packages, such as `react-intlayer`.\n */\nexport interface IInterpreterPlugin<T, S, L extends LocalesValues> {\n  translation: TranslationCond<T, S, L>;\n  enumeration: EnumerationCond<T, S, L>;\n  plural: PluralCond<T, S, L>;\n  condition: ConditionCond<T, S, L>;\n  insertion: InsertionCond<T, S, L>;\n  gender: GenderCond<T, S, L>;\n  select: SelectCond<T, S, L>;\n  nested: NestedCond<T, S, L>;\n  file: FileCond<T, S, L>;\n}\n\n/**\n * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.\n */\nexport type IInterpreterPluginState = {\n  translation: true;\n  enumeration: true;\n  plural: true;\n  condition: true;\n  insertion: true;\n  gender: true;\n  select: true;\n  nested: true;\n  file: true;\n};\n\n/**\n * Utility type to check if a plugin can be applied to a node.\n */\ntype CheckApplyPlugin<\n  T,\n  K extends keyof IInterpreterPlugin<T, S, L>,\n  S,\n  L extends LocalesValues = DeclaredLocales,\n> = K extends keyof S // Test if the key is a key of S.\n  ? // Test if the key of S is true. Then the plugin can be applied.\n    S[K] extends true\n    ? // Test if the key of S exist\n      IInterpreterPlugin<T, S, L>[K] extends never\n      ? never\n      : // Test if the plugin condition is true (if it's not, the plugin is skipped for this node)\n        IInterpreterPlugin<T, S, L>[K]\n    : never\n  : never;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\ntype Traverse<T, S, L extends LocalesValues = DeclaredLocales> =\n  T extends ReadonlyArray<infer U> // Turn any read-only array into a plain mutable array\n    ? Array<DeepTransformContent<U, S, L>>\n    : T extends object\n      ? { [K in keyof T]: DeepTransformContent<T[K], S, L> }\n      : T;\n\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\n\n/**\n * Traverse recursively through an object or array, applying each plugin as needed.\n */\nexport type DeepTransformContent<\n  T,\n  S = IInterpreterPluginState,\n  L extends LocalesValues = DeclaredLocales,\n> =\n  IsAny<T> extends true\n    ? T\n    : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L> extends never // Check if there is a plugin for T:\n      ? // No plugin was found, so try to transform T recursively:\n        Traverse<T, S, L>\n      : // A plugin was found – use the plugin's transformation.\n        CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L>;\n"],"mappings":"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"}

package/dist/cjs/interpreter/getDictionary.cjs

@@ -6,6 +6,12 @@ let _intlayer_config_built = require("@intlayer/config/built");
 
 //#region src/interpreter/getDictionary.ts
 /**
+* Dictionaries whose transform is running. Content is transformed eagerly, so a
+* dictionary reached again through a `nest()` cycle is transformed lazily
+* instead: its nodes then resolve on read, and the cycle unwinds.
+*/
+const transformsInProgress = /* @__PURE__ */ new WeakSet();
+/**
 * Transforms a dictionary in a single pass, applying each plugin as needed.
 *
 * @param dictionary The dictionary (or qualified dictionary group) to transform.
@@ -15,21 +21,30 @@ let _intlayer_config_built = require("@intlayer/config/built");
 *                If omitted, we’ll use a default set of plugins.
 */
 const getDictionary = (dictionary, localeOrSelector, plugins) => {
-	const { locale, selector } = require_dictionaryManipulator_qualifiedDictionary.parseDictionarySelector(localeOrSelector);
-	const cacheKey = require_interpreter_dictionaryTransformCache.getDictionaryTransformCacheKey(locale ?? _intlayer_config_built.internationalization.defaultLocale, require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey(selector), plugins);
+	const { locale, selector } = process.env.INTLAYER_DICTIONARY_SELECTOR !== "false" ? require_dictionaryManipulator_qualifiedDictionary.parseDictionarySelector(localeOrSelector) : {
+		locale: localeOrSelector,
+		selector: void 0
+	};
+	const cacheKey = require_interpreter_dictionaryTransformCache.getDictionaryTransformCacheKey(locale ?? _intlayer_config_built.internationalization.defaultLocale, process.env.INTLAYER_DICTIONARY_SELECTOR !== "false" ? require_dictionaryManipulator_qualifiedDictionary.getDictionarySelectorCacheKey(selector) : "", plugins);
 	const cached = require_interpreter_dictionaryTransformCache.readTransformCache(dictionary, cacheKey);
 	if (cached.hit) return cached.content;
 	const appliedPlugins = plugins ?? require_interpreter_getContent_getContent.getBasePlugins(locale);
-	const resolved = require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary(dictionary, selector);
+	const resolved = process.env.INTLAYER_DICTIONARY_SELECTOR !== "false" ? require_dictionaryManipulator_qualifiedDictionary.resolveQualifiedDictionary(dictionary, selector) : dictionary;
 	const transformDictionary = (resolvedDictionary) => {
 		const props = {
 			dictionaryKey: resolvedDictionary.key,
 			dictionaryPath: resolvedDictionary.filePath,
 			keyPath: [],
 			plugins: appliedPlugins,
-			nestedDictionaries: resolvedDictionary.nestedDictionaries
+			nestedDictionaries: resolvedDictionary.nestedDictionaries,
+			eager: !transformsInProgress.has(resolvedDictionary)
 		};
-		return require_interpreter_getContent_getContent.getContent(resolvedDictionary.content, props, appliedPlugins);
+		transformsInProgress.add(resolvedDictionary);
+		try {
+			return require_interpreter_getContent_getContent.getContent(resolvedDictionary.content, props, appliedPlugins);
+		} finally {
+			if (props.eager) transformsInProgress.delete(resolvedDictionary);
+		}
 	};
 	if (resolved === null) return require_interpreter_dictionaryTransformCache.writeTransformCache(dictionary, cacheKey, null);
 	if (Array.isArray(resolved)) return require_interpreter_dictionaryTransformCache.writeTransformCache(dictionary, cacheKey, resolved.map(transformDictionary));