@intlayer/types 8.4.4 → 8.4.6

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"mappings":"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"}

package/dist/types/dictionary.d.ts

@@ -1,2 +1,376 @@
-import { A as ContentAutoTransformation, B as LocalDictionaryId, F as DictionaryKey, I as DictionaryLocation, L as Fill, M as Dictionary, N as DictionaryFormat, P as DictionaryId, R as GetSubPath, V as TypedNode, j as ContentNode, z as ImportMode } from "./config-CE_7T8Jh.js";
-export { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, Fill, GetSubPath, ImportMode, LocalDictionaryId, TypedNode };
+import { DeclaredLocales, LocalesValues, Schema, SchemaKeys } from "./module_augmentation.js";
+import { FilePathPattern } from "./filePathPattern.js";
+import { NodeType } from "./nodeType.js";
+
+//#region src/dictionary.d.ts
+type BaseNode = number | string | boolean | null | undefined;
+type TypedNodeBase = {
+  nodeType: NodeType;
+};
+interface TypedNode<_NodeType = undefined> extends TypedNodeBase {}
+type FetchableContentNode<NodeType> = (args?: any) => ContentNode<NodeType> | Promise<ContentNode<NodeType>>;
+type ContentNode<T = undefined, FetchableNode = false, NodeType = (T extends undefined ? BaseNode : T)> = NodeType | TypedNode<NodeType> | ((args?: any) => ContentNode<NodeType>) | (FetchableNode extends true ? FetchableContentNode<NodeType> : undefined);
+type IsArray<T> = T extends any[] ? true : false;
+type ReplaceContentValueArray<T, FetchableNode> = T extends (infer U)[] ? ContentNode<T, FetchableNode> | ReplaceContentValue<U, FetchableNode>[] : never;
+type ReplaceContentValueObject<T, FetchableNode> = { [K in keyof T]: ReplaceContentValue<T[K], FetchableNode> };
+type ReplaceContentValue<NodeType, FetchableNode = true> = NodeType extends object ? IsArray<NodeType> extends true ? ReplaceContentValueArray<NodeType, FetchableNode> : ContentNode<NodeType, FetchableNode> | ReplaceContentValueObject<NodeType, FetchableNode> : ContentNode<NodeType, FetchableNode>;
+/**
+* Indicate how the dictionary should be filled using AI.
+*
+* Default: `true`
+*
+* - If `true`, will consider the `compiler.output` field.
+* - If `false`, will skip the fill process.
+*
+* - `./` paths are resolved relative to the component directory.
+* - `/` paths are resolved relative to the project root (`baseDir`).
+*
+* - If includes `{{locale}}` variable in the path, will trigger the generation of separate dictionaries per locale.
+*
+* Example:
+* ```ts
+* {
+*   // Create Multilingual .content.ts files close to the component
+*   fill: ({ fileName, extension }) => `./${fileName}${extension}`,
+*
+*   // fill: './{{fileName}}{{extension}}', // Equivalent using template string
+* }
+* ```
+*
+* ```ts
+* {
+*   // Create centralize per-locale JSON at the root of the project
+*   fill: ({ key, locale }) => `/locales/${locale}/${key}.content.json`,
+*
+*   // fill: '/locales/{{locale}}/{{key}}.content.json', // Equivalent using template string
+* }
+* ```
+*
+* ```ts
+* {
+*   // Create custom output based on the locale
+*   fill: {
+*     en: ({ key }) => `/locales/en/${key}.content.json`,
+*     fr: '/locales/fr/{{key}}.content.json',
+*     es: false,
+*     de: true,
+*   },
+* }
+* ```
+*
+*
+* Variable list:
+*   - `fileName`: The name of the file.
+*   - `key`: The key of the content.
+*   - `locale`: The locale of the content.
+*   - `extension`: The extension of the file.
+*   - `componentFileName`: The name of the component file.
+*   - `componentExtension`: The extension of the component file.
+*   - `format`: The format of the dictionary.
+*   - `componentFormat`: The format of the component dictionary.
+*   - `componentDirPath`: The directory path of the component.
+*/
+type Fill = boolean | FilePathPattern | Partial<Record<DeclaredLocales, boolean | FilePathPattern>>;
+type DictionaryId = string;
+type DictionaryKey = string;
+type DictionaryLocation = "remote" | "local" | "hybrid" | "plugin" | (string & {});
+type LocalDictionaryId = `${DictionaryKey}::${Dictionary["location"]}::${Dictionary["filePath"] | DictionaryId}`;
+type DictionaryFormat = "intlayer" | "icu" | "i18next" | "vue-i18n";
+/**
+* Indicates the mode of import to use for the dictionary.
+*
+* Available modes:
+* - "static": The dictionaries are imported statically.
+*   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionary`.
+* - "dynamic": The dictionaries are imported dynamically in a synchronous component using the suspense API.
+*   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+* - "live": The dictionaries are imported dynamically using the live sync API.
+*   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+*   Live mode will use the live sync API to fetch the dictionaries. If the API call fails, the dictionaries will be imported dynamically as "dynamic" mode.
+*
+* Default: "static"
+*/
+type ImportMode = "static" | "dynamic" | "fetch";
+type ContentAutoTransformation = boolean | {
+  /**
+  * Indicates if the content should be automatically transformed to a markdown node.
+  * Default: true
+  */
+  markdown?: boolean;
+  /**
+  * Indicates if the content should be automatically transformed to an HTML node.
+  * Default: true
+  */
+  html?: boolean;
+  /**
+  * Indicates if the content should be automatically transformed to an insertion node.
+  * Default: true
+  */
+  insertion?: boolean;
+};
+/**
+* Common properties shared by all Dictionary variants.
+*/
+type DictionaryBase = {
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * The schema of the dictionary, used for JSON validation
+  */
+  $schema?: "https://intlayer.org/schema.json";
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * For remote dictionaries, the id is the id of the dictionary in the remote server
+  */
+  id?: DictionaryId;
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * For remote dictionaries, the projectIds is the ids of the projects that can use this dictionary
+  * A remote dictionary can be shared between multiple projects
+  */
+  projectIds?: string[];
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * Unique Identifier for the dictionaries. Auto generated by the intlayer, it helps to identify the dictionary and know if it is a local or remote dictionary, and his location.
+  */
+  localId?: LocalDictionaryId;
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * For merged dictionaries, the localIds is the ids of the dictionaries that are merged
+  */
+  localIds?: LocalDictionaryId[];
+  /**
+  * The formatter to use for the dictionary.
+  *
+  * Default: 'intlayer'
+  *
+  * The formatter to use for the dictionary content.
+  */
+  format?: DictionaryFormat;
+  /**
+  * The key of the dictionary. If multiple dictionaries have the same key, intlayer will merge them.
+  *
+  * As convention, use '-' to separate the words in the key.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page-meta",
+  *   "content": { ... }
+  * }
+  * ```
+  */
+  key: DictionaryKey;
+  /**
+  * The title of the dictionary. Helps to identify the dictionary in the editor, and the CMS.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page-meta",
+  *   "title": "About Page",
+  *   "content": { ... }
+  * }
+  * ```
+  */
+  title?: string;
+  /**
+  * The description of the dictionary. Helps to understand the purpose of the dictionary in the editor, and the CMS.
+  * The description is also used as context for translations generation.
+  *
+  * Example:
+  * ```ts
+  * {
+  *   "key": "about-page-meta",
+  *   "description":[
+  *     "This dictionary is manage the metadata of the About Page",
+  *     "Consider good practices for SEO:",
+  *     "- The title should be between 50 and 60 characters",
+  *     "- The description should be between 150 and 160 characters",
+  *   ].join('\n'),
+  *   "content": { ... }
+  * }
+  * ```
+  */
+  description?: string;
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * The available versions of the remote dictionary. Helps to know the versions of the dictionary that are available.
+  */
+  versions?: string[];
+  /**
+  * _Managable on the CMS, do not modify it locally_
+  *
+  * The version of the remote dictionary. Helps to know the version of the dictionary that is currently used.
+  */
+  version?: string;
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * The file path of the local dictionary. Helps to know from what .content file the dictionary has been generated.
+  */
+  filePath?: string;
+  /**
+  * Helps to categorize the dictionaries. The tags can provide more context and instructions for the dictionary.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page-meta",
+  *   "tags": ["metadata","about-page"]
+  * }
+  * ```
+  */
+  tags?: string[];
+  /**
+  * Transform the dictionary in a per-locale dictionary.
+  * Each field declared in a per-locale dictionary will be transformed in a translation node.
+  * If missing, the dictionary will be treated as a multilingual dictionary.
+  * If declared, do not use translation nodes in the content.
+  *
+  * Example:
+  * ```json
+  * {
+  *   "key": "about-page",
+  *   "locale": "en",
+  *   "content": {
+  *     "multilingualContent": "English content"
+  *   }
+  * }
+  * ```
+  */
+  locale?: LocalesValues;
+  /**
+  * Indicators if the content of the dictionary should be automatically transformed.
+  * If true, the content will be transformed to the corresponding node type.
+  * - Markdown: `### Title` -> `md('### Title')`
+  * - HTML: `<div>Title</div>` -> `html('<div>Title</div>')`
+  * - Insertion: `Hello {{name}}` -> `insert('Hello {{name}}')`
+  *
+  * If an object is provided, you can specify which transformations should be enabled.
+  *
+  * Default: false
+  */
+  contentAutoTransformation?: ContentAutoTransformation;
+  /**
+  * Indicate how the dictionary should be filled using AI.
+  *
+  * Default: `true`
+  *
+  * - If `true`, will consider the `compiler.output` field.
+  * - If `false`, will skip the fill process.
+  *
+  * - `./` paths are resolved relative to the component directory.
+  * - `/` paths are resolved relative to the project root (`baseDir`).
+  *
+  * - If includes `{{locale}}` variable in the path, will trigger the generation of separate dictionaries per locale.
+  *
+  * Example:
+  * ```ts
+  * {
+  *   // Create Multilingual .content.ts files close to the component
+  *   fill: ({ fileName, extension }) => `./${fileName}${extension}`,
+  *
+  *   // fill: './{{fileName}}{{extension}}', // Equivalent using template string
+  * }
+  * ```
+  *
+  * ```ts
+  * {
+  *   // Create centralize per-locale JSON at the root of the project
+  *   fill: ({ key, locale }) => `/locales/${locale}/${key}.content.json`,
+  *
+  *   // fill: '/locales/{{locale}}/{{key}}.content.json', // Equivalent using template string
+  * }
+  * ```
+  *
+  * ```ts
+  * {
+  *   // Create custom output based on the locale
+  *   fill: {
+  *     en: ({ key }) => `/locales/en/${key}.content.json`,
+  *     fr: '/locales/fr/{{key}}.content.json',
+  *     es: false,
+  *     de: true,
+  *   },
+  * }
+  * ```
+  *
+  *
+  * Variable list:
+  *   - `fileName`: The name of the file.
+  *   - `key`: The key of the content.
+  *   - `locale`: The locale of the content.
+  *   - `extension`: The extension of the file.
+  *   - `componentFileName`: The name of the component file.
+  *   - `componentExtension`: The extension of the component file.
+  *   - `format`: The format of the dictionary.
+  *   - `componentFormat`: The format of the component dictionary.
+  *   - `componentDirPath`: The directory path of the component.
+  */
+  fill?: Fill;
+  /**
+  * _Auto generated by the intlayer, do not modify it_
+  *
+  * Indicates if the dictionary has been auto filled.
+  * In the case of conflicts, base dictionaryed will override auto filled dictionary.
+  */
+  filled?: true;
+  /**
+  * Indicates the priority of the dictionary.
+  * In the case of conflicts, the dictionary with the highest priority will override the other dictionaries.
+  */
+  priority?: number;
+  /**
+  * Indicates the mode of import to use for the dictionary.
+  *
+  * Available modes:
+  * - "static": The dictionaries are imported statically.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionary`.
+  * - "dynamic": The dictionaries are imported dynamically in a synchronous component using the suspense API.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+  * - "live": The dictionaries are imported dynamically using the live sync API.
+  *   In that case, Intlayer will replace all calls to `useIntlayer` with `useDictionaryDynamic`.
+  *   Live mode will use the live sync API to fetch the dictionaries. If the API call fails, the dictionaries will be imported dynamically as "dynamic" mode.
+  *
+  * Default: "static"
+  */
+  importMode?: ImportMode;
+  /**
+  * Indicates the location of the dictionary and controls how it synchronizes with the CMS.
+  *
+  * - 'hybrid': The dictionary is managed locally and remotely. Once pushed on the CMS, it will be synchronized from the local one. The local dictionary will be pulled from the CMS.
+  * - 'remote': The dictionary is managed remotely only. Once pushed on the CMS, it will be detached from the local one. At content load time, the remote dictionary will be pulled from the CMS. A '.content' file with remote location will be ignored.
+  * - 'local': The dictionary is managed locally. It will not be pushed to the remote CMS.
+  * - 'plugin' (or any custom string): The dictionary is managed by a plugin, or a custom source. When you will try to push it, the system will ask an action to the user.
+  */
+  location?: DictionaryLocation;
+};
+/**
+* Strict Schema Branch:
+* If a schema is provided, it MUST be one of the SchemaKeys.
+*/
+type DictionaryWithSchema<ContentType, FetchableNode, K extends SchemaKeys = SchemaKeys> = K extends any ? {
+  schema: K;
+  content: ContentType extends undefined ? ReplaceContentValue<Schema<K>, FetchableNode> | Schema<K> : ReplaceContentValue<ContentType & Schema<K>, FetchableNode> | (ContentType & Schema<K>);
+} : never;
+/**
+* Strict Discrimination Branch
+*/
+type DictionaryWithoutSchema<ContentType, FetchableNode> = {
+  schema?: never;
+  content: ContentType extends undefined ? any : ReplaceContentValue<ContentType, FetchableNode> | ContentType;
+};
+/**
+* The Final Dictionary Type
+*/
+type Dictionary<ContentType = undefined, SchemaKey extends SchemaKeys | undefined = undefined, FetchableNode = false> = DictionaryBase & (SchemaKey extends SchemaKeys ? DictionaryWithSchema<ContentType, FetchableNode, SchemaKey> : undefined extends SchemaKey ? DictionaryWithoutSchema<ContentType, FetchableNode> | DictionaryWithSchema<ContentType, FetchableNode> : never);
+type GetSubPath<T, P> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? GetSubPath<T[K], Rest> : never : P extends keyof T ? T[P] : T;
+//#endregion
+export { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, Fill, GetSubPath, ImportMode, LocalDictionaryId, TypedNode };
+//# sourceMappingURL=dictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary.d.ts","names":[],"sources":["../../src/dictionary.ts"],"mappings":"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"}

package/dist/types/filePathPattern.d.ts

@@ -1,2 +1,29 @@
-import { H as FilePathPattern, U as FilePathPatternContext, W as FilePathPatternFunction } from "./config-CE_7T8Jh.js";
-export { FilePathPattern, FilePathPatternContext, FilePathPatternFunction };
+import { DeclaredLocales } from "./module_augmentation.js";
+import { DictionaryKey } from "./dictionary.js";
+
+//#region src/filePathPattern.d.ts
+type ContentExtension = `.${string}.${"json" | "js" | "ts" | "jsx" | "tsx" | "cjs" | "mjs"}`;
+type FilePathPatternContext = {
+  locale?: DeclaredLocales;
+  key: DictionaryKey;
+  fileName: string;
+  extension: ContentExtension | (string & {});
+  format: "ts" | "cjs" | "esm" | "json" | "jsonc" | "json5";
+  componentExtension?: ".json" | ".js" | ".ts" | ".jsx" | ".tsx" | ".cjs" | ".mjs";
+  componentFormat?: "ts" | "cjs" | "esm";
+  componentFileName?: string;
+  componentDirPath?: string;
+};
+/**
+* Syntax for resolving file paths.
+*/
+type FilePathPatternFunction = (context: FilePathPatternContext) => string | Promise<string>;
+/**
+* Global syntax for defining file paths and patterns.
+* Can be a static string, a templated string (e.g. `path/{{locale}}/{{key}}{{extension}}`),
+* or a function evaluating the path dynamically.
+*/
+type FilePathPattern = string | FilePathPatternFunction;
+//#endregion
+export { FilePathPattern, FilePathPatternContext, FilePathPatternFunction };
+//# sourceMappingURL=filePathPattern.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filePathPattern.d.ts","names":[],"sources":["../../src/filePathPattern.ts"],"mappings":";;;;KAGK,gBAAA;AAAA,KAGO,sBAAA;EACV,MAAA,GAAS,eAAA;EACT,GAAA,EAAK,aAAA;EACL,QAAA;EACA,SAAA,EAAW,gBAAA;EACX,MAAA;EACA,kBAAA;EAQA,eAAA;EAEA,iBAAA;EACA,gBAAA;AAAA;;;;KAMU,uBAAA,IACV,OAAA,EAAS,sBAAA,cACG,OAAA;;;;;;KAOF,eAAA,YAA2B,uBAAA"}

package/dist/types/index.d.ts

@@ -1,6 +1,10 @@
-import { Na as locales_d_exports } from "./locales-CojWxvz7.js";
-import { n as Locale, t as ALL_LOCALES } from "./allLocales-DeCezB07.js";
-import { A as ContentAutoTransformation, B as LocalDictionaryId, C as SystemConfig, D as Plugin, E as MergedDictionaryResult, F as DictionaryKey, G as DeclaredLocales, H as FilePathPattern, I as DictionaryLocation, J as DictionaryRegistryContent, K as DictionaryKeys, L as Fill, M as Dictionary, N as DictionaryFormat, O as UnmergedDictionaryOutput, P as DictionaryId, Q as ResolvedEditor, R as GetSubPath, S as StrictMode, T as MergedDictionaryOutput, U as FilePathPatternContext, V as TypedNode, W as FilePathPatternFunction, X as LocalesValues, Y as DictionaryRegistryElement, Z as RequiredLocales, _ as RewriteRule, a as CommonAiConfig, b as Schema, c as CookiesAttributes, d as EditorConfig, et as SchemaKeys, f as InternationalizationConfig, g as RewriteObject, h as LogFunctions, i as BuildConfig, j as ContentNode, k as UnmergedDictionaryResult, l as CustomIntlayerConfig, m as LogConfig, n as AiProviderConfigMap, o as CompilerConfig, p as IntlayerConfig, q as DictionaryRegistry, r as AiProviders, s as ContentConfig, t as AiConfig, tt as StrictModeLocaleMap, u as DictionaryConfig, v as RewriteRules, w as URLType, x as StorageAttributes, y as RoutingConfig, z as ImportMode } from "./config-CE_7T8Jh.js";
-import { n as TypedNodeModel, r as formatNodeType, t as NodeType } from "./nodeType-DIgDogqh.js";
+import { locales_d_exports } from "./locales.js";
+import { ALL_LOCALES, Locale } from "./allLocales.js";
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, LocalesValues, RequiredLocales, ResolvedEditor, SchemaKeys, StrictModeLocaleMap } from "./module_augmentation.js";
+import { FilePathPattern, FilePathPatternContext, FilePathPatternFunction } from "./filePathPattern.js";
+import { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, NodeType, OBJECT, REACT_NODE, TEXT, TRANSLATION, TypedNodeModel, UNKNOWN, formatNodeType } from "./nodeType.js";
+import { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, Fill, GetSubPath, ImportMode, LocalDictionaryId, TypedNode } from "./dictionary.js";
+import { MergedDictionaryOutput, MergedDictionaryResult, Plugin, UnmergedDictionaryOutput, UnmergedDictionaryResult } from "./plugin.js";
+import { AiConfig, AiProviderConfigMap, AiProviders, BuildConfig, CommonAiConfig, CompilerConfig, ContentConfig, CookiesAttributes, CustomIntlayerConfig, DictionaryConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, Schema, StorageAttributes, StrictMode, SystemConfig, URLType } from "./config.js";
 import { ArrayNode, ConditionNode, EnumerationNode, FileNode, GenderNode, HTMLNode, InsertionNode, KeyPath, MarkdownNode, NestedNode, ObjectNode, ReactNode, TranslationNode } from "./keyPath.js";
-export { ALL_LOCALES, AiConfig, AiProviderConfigMap, AiProviders, ArrayNode, BuildConfig, CommonAiConfig, CompilerConfig, ConditionNode, ContentAutoTransformation, ContentConfig, ContentNode, CookiesAttributes, CustomIntlayerConfig, DeclaredLocales, Dictionary, DictionaryConfig, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryKeys, DictionaryLocation, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, EditorConfig, EnumerationNode, FileNode, FilePathPattern, FilePathPatternContext, FilePathPatternFunction, Fill, GenderNode, GetSubPath, HTMLNode, ImportMode, InsertionNode, InternationalizationConfig, IntlayerConfig, KeyPath, LocalDictionaryId, Locale, locales_d_exports as Locales, LocalesValues, LogConfig, LogFunctions, MarkdownNode, MergedDictionaryOutput, MergedDictionaryResult, NestedNode, NodeType, ObjectNode, Plugin, ReactNode, RequiredLocales, ResolvedEditor, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, SchemaKeys, StorageAttributes, StrictMode, StrictModeLocaleMap, SystemConfig, TranslationNode, TypedNode, TypedNodeModel, URLType, UnmergedDictionaryOutput, UnmergedDictionaryResult, formatNodeType };
+export { ALL_LOCALES, ARRAY, AiConfig, AiProviderConfigMap, AiProviders, ArrayNode, BOOLEAN, BuildConfig, CONDITION, CommonAiConfig, CompilerConfig, ConditionNode, ContentAutoTransformation, ContentConfig, ContentNode, CookiesAttributes, CustomIntlayerConfig, DeclaredLocales, Dictionary, DictionaryConfig, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryKeys, DictionaryLocation, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, ENUMERATION, EditorConfig, EnumerationNode, FILE, FileNode, FilePathPattern, FilePathPatternContext, FilePathPatternFunction, Fill, GENDER, GenderNode, GetSubPath, HTML, HTMLNode, INSERTION, ImportMode, InsertionNode, InternationalizationConfig, IntlayerConfig, KeyPath, LocalDictionaryId, Locale, locales_d_exports as Locales, LocalesValues, LogConfig, LogFunctions, MARKDOWN, MarkdownNode, MergedDictionaryOutput, MergedDictionaryResult, NESTED, NULL, NUMBER, NestedNode, NodeType, OBJECT, ObjectNode, Plugin, REACT_NODE, ReactNode, RequiredLocales, ResolvedEditor, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, SchemaKeys, StorageAttributes, StrictMode, StrictModeLocaleMap, SystemConfig, TEXT, TRANSLATION, TranslationNode, TypedNode, TypedNodeModel, UNKNOWN, URLType, UnmergedDictionaryOutput, UnmergedDictionaryResult, formatNodeType };

package/dist/types/keyPath.d.ts

@@ -1,52 +1,52 @@
-import { t as NodeType } from "./nodeType-DIgDogqh.js";
+import { ARRAY, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, OBJECT, REACT_NODE, TRANSLATION } from "./nodeType.js";
 
 //#region src/keyPath.d.ts
 type ObjectNode = {
-  type: NodeType.Object;
+  type: typeof OBJECT;
   key: string;
 };
 type ArrayNode = {
-  type: NodeType.Array;
+  type: typeof ARRAY;
   key: number;
 };
 type EnumerationNode = {
-  type: NodeType.Enumeration;
+  type: typeof ENUMERATION;
   key: string;
 };
 type TranslationNode = {
-  type: NodeType.Translation;
+  type: typeof TRANSLATION;
   key: string;
 };
 type ConditionNode = {
-  type: NodeType.Condition;
+  type: typeof CONDITION;
   key: string;
 };
 type GenderNode = {
-  type: NodeType.Gender;
+  type: typeof GENDER;
   key: string;
 };
 type InsertionNode = {
-  type: NodeType.Insertion;
+  type: typeof INSERTION;
   key?: undefined;
 };
 type MarkdownNode = {
-  type: NodeType.Markdown;
+  type: typeof MARKDOWN;
   key?: undefined;
 };
 type ReactNode = {
-  type: NodeType.ReactNode;
+  type: typeof REACT_NODE;
   key?: undefined;
 };
 type NestedNode = {
-  type: NodeType.Nested;
+  type: typeof NESTED;
   key?: undefined;
 };
 type FileNode = {
-  type: NodeType.File;
+  type: typeof FILE;
   key?: undefined;
 };
 type HTMLNode = {
-  type: NodeType.HTML;
+  type: typeof HTML;
   key?: undefined;
 };
 type KeyPath = ObjectNode | ArrayNode | TranslationNode | EnumerationNode | InsertionNode | GenderNode | MarkdownNode | ReactNode | ConditionNode | NestedNode | FileNode | HTMLNode;

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

@@ -1 +1 @@
-{"version":3,"file":"keyPath.d.ts","names":[],"sources":["../../src/keyPath.ts"],"mappings":";;;KAEY,UAAA;EACV,IAAA,EAAM,QAAA,CAAS,MAAA;EACf,GAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA,EAAM,QAAA,CAAS,KAAA;EACf,GAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA,EAAM,QAAA,CAAS,WAAA;EACf,GAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA,EAAM,QAAA,CAAS,WAAA;EACf,GAAA;AAAA;AAAA,KAGU,aAAA;EACV,IAAA,EAAM,QAAA,CAAS,SAAA;EACf,GAAA;AAAA;AAAA,KAGU,UAAA;EACV,IAAA,EAAM,QAAA,CAAS,MAAA;EACf,GAAA;AAAA;AAAA,KAGU,aAAA;EACV,IAAA,EAAM,QAAA,CAAS,SAAA;EACf,GAAA;AAAA;AAAA,KAGU,YAAA;EACV,IAAA,EAAM,QAAA,CAAS,QAAA;EACf,GAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA,EAAM,QAAA,CAAS,SAAA;EACf,GAAA;AAAA;AAAA,KAGU,UAAA;EACV,IAAA,EAAM,QAAA,CAAS,MAAA;EACf,GAAA;AAAA;AAAA,KAGU,QAAA;EACV,IAAA,EAAM,QAAA,CAAS,IAAA;EACf,GAAA;AAAA;AAAA,KAGU,QAAA;EACV,IAAA,EAAM,QAAA,CAAS,IAAA;EACf,GAAA;AAAA;AAAA,KAGU,OAAA,GACR,UAAA,GACA,SAAA,GACA,eAAA,GACA,eAAA,GACA,aAAA,GACA,UAAA,GACA,YAAA,GACA,SAAA,GACA,aAAA,GACA,UAAA,GACA,QAAA,GACA,QAAA"}
+{"version":3,"file":"keyPath.d.ts","names":[],"sources":["../../src/keyPath.ts"],"mappings":";;;KAEY,UAAA;EACV,IAAA,SAAa,MAAA;EACb,GAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA,SAAa,KAAA;EACb,GAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA,SAAa,WAAA;EACb,GAAA;AAAA;AAAA,KAGU,eAAA;EACV,IAAA,SAAa,WAAA;EACb,GAAA;AAAA;AAAA,KAGU,aAAA;EACV,IAAA,SAAa,SAAA;EACb,GAAA;AAAA;AAAA,KAGU,UAAA;EACV,IAAA,SAAa,MAAA;EACb,GAAA;AAAA;AAAA,KAGU,aAAA;EACV,IAAA,SAAa,SAAA;EACb,GAAA;AAAA;AAAA,KAGU,YAAA;EACV,IAAA,SAAa,QAAA;EACb,GAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA,SAAa,UAAA;EACb,GAAA;AAAA;AAAA,KAGU,UAAA;EACV,IAAA,SAAa,MAAA;EACb,GAAA;AAAA;AAAA,KAGU,QAAA;EACV,IAAA,SAAa,IAAA;EACb,GAAA;AAAA;AAAA,KAGU,QAAA;EACV,IAAA,SAAa,IAAA;EACb,GAAA;AAAA;AAAA,KAGU,OAAA,GACR,UAAA,GACA,SAAA,GACA,eAAA,GACA,eAAA,GACA,aAAA,GACA,UAAA,GACA,YAAA,GACA,SAAA,GACA,aAAA,GACA,UAAA,GACA,QAAA,GACA,QAAA"}