lit-intlayer 8.4.10

package/dist/types/src/client/useLocaleStorage.d.ts

@@ -0,0 +1,31 @@
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+/**
+ * Get the current locale from storage (cookie or localStorage).
+ */
+export declare const localeInStorage: import('intlayer').Locale | undefined;
+/**
+ * @deprecated Use localeInStorage instead.
+ */
+export declare const localeCookie: import('intlayer').Locale | undefined;
+/**
+ * Persist the locale to storage (cookie and/or localStorage).
+ */
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * @deprecated Use setLocaleInStorage instead.
+ */
+export declare const setLocaleCookie: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+/**
+ * Returns the current locale from storage and a setter.
+ */
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+    localeStorage: import('intlayer').Locale;
+    setLocaleStorage: (locale: LocalesValues) => void;
+};
+/**
+ * @deprecated Use useLocaleStorage instead.
+ */
+export declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
+    localeCookie: import('intlayer').Locale;
+    setLocaleCookie: (locale: LocalesValues) => void;
+};

package/dist/types/src/client/useRewriteURL.d.ts

@@ -0,0 +1,2 @@
+import { ReactiveControllerHost } from 'lit';
+export declare const useRewriteURL: (host: ReactiveControllerHost) => void;

package/dist/types/src/editor/useEditor.d.ts

@@ -0,0 +1,22 @@
+import { ReactiveControllerHost } from 'lit';
+/**
+ * Initialises the Intlayer visual editor client on the given host element.
+ *
+ * Does nothing when `INTLAYER_EDITOR_ENABLED` is `"false"` or the editor
+ * package reports that it is disabled.
+ *
+ * Call this once, typically from your root/shell element.
+ *
+ * @param host - The LitElement (or any ReactiveControllerHost).
+ *
+ * @example
+ * ```ts
+ * class AppShell extends LitElement {
+ *   constructor() {
+ *     super();
+ *     useEditor(this);
+ *   }
+ * }
+ * ```
+ */
+export declare const useEditor: (host: ReactiveControllerHost) => void;

package/dist/types/src/format/index.d.ts

@@ -0,0 +1 @@
+export * from './useIntl';

package/dist/types/src/format/useIntl.d.ts

@@ -0,0 +1,50 @@
+import { WrappedIntl } from '@intlayer/core/utils';
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * ReactiveController that provides a locale-bound `Intl` object.
+ *
+ * Acts exactly like the native `Intl` namespace but automatically uses the
+ * current application locale, updating the host whenever the locale changes.
+ *
+ * @internal
+ */
+declare class IntlController implements ReactiveController {
+    private readonly host;
+    private readonly _overrideLocale;
+    private _unsubscribe;
+    /** The locale-bound Intl object. */
+    value: WrappedIntl;
+    constructor(host: ReactiveControllerHost, locale?: LocalesValues);
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+/**
+ * Reactive hook that provides a locale-bound `Intl` object.
+ *
+ * The returned controller's `.value` property gives access to locale-aware
+ * `NumberFormat`, `DateTimeFormat`, `RelativeTimeFormat`, etc. without
+ * needing to pass the current locale manually.
+ *
+ * @param host   - The LitElement (or any ReactiveControllerHost).
+ * @param locale - Optional locale override.
+ * @returns An `IntlController` with a `.value: WrappedIntl` property.
+ *
+ * @example
+ * ```ts
+ * class PriceTag extends LitElement {
+ *   private intl = useIntl(this);
+ *
+ *   render() {
+ *     const formatted = new this.intl.value.NumberFormat({
+ *       style: 'currency',
+ *       currency: 'USD',
+ *     }).format(9.99);
+ *
+ *     return html`<span>${formatted}</span>`;
+ *   }
+ * }
+ * ```
+ */
+export declare const useIntl: (host: ReactiveControllerHost, locale?: LocalesValues) => IntlController;
+export {};

package/dist/types/src/getDictionary.d.ts

@@ -0,0 +1,4 @@
+import { Dictionary } from '@intlayer/types/dictionary';
+import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { DeepTransformContent } from './plugins';
+export declare const getDictionary: <T extends Dictionary, L extends LocalesValues = DeclaredLocales>(dictionary: T, locale?: L) => DeepTransformContent<T["content"], L>;

package/dist/types/src/getIntlayer.d.ts

@@ -0,0 +1,3 @@
+import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types/module_augmentation';
+import { DeepTransformContent } from './plugins';
+export declare const getIntlayer: <T extends DictionaryKeys, L extends LocalesValues = DeclaredLocales>(key: T, locale?: L) => DeepTransformContent<DictionaryRegistryContent<T>, L>;

package/dist/types/src/html/HTMLRenderer.d.ts

@@ -0,0 +1,49 @@
+import { LitElement, nothing } from 'lit';
+import { HTMLComponents } from './types';
+export type RenderHTMLProps = {
+    components?: HTMLComponents<'permissive', {}>;
+};
+/**
+ * Renders an HTML string directly, without a global provider.
+ * Returns the raw string; pass to `unsafeHTML()` in a Lit template.
+ */
+export declare const renderHTML: (content: string, _props?: RenderHTMLProps) => string;
+/**
+ * Returns a render function that uses the global provider's configuration
+ * (installed via `installIntlayerHTML`), falling back to identity.
+ */
+export declare const useHTMLRenderer: ({ components, }?: RenderHTMLProps) => ((content: string) => string);
+/**
+ * `<intlayer-html-renderer>` — renders an HTML string into the light DOM.
+ *
+ * Uses the globally installed HTML renderer when available
+ * (see `installIntlayerHTML`), or falls back to `unsafeHTML` with the raw string.
+ *
+ * @example
+ * ```html
+ * <intlayer-html-renderer content="<strong>Hello</strong> World">
+ * </intlayer-html-renderer>
+ * ```
+ */
+export declare class HTMLRenderer extends LitElement {
+    static properties: {
+        content: {
+            type: StringConstructor;
+        };
+        components: {
+            attribute: boolean;
+        };
+    };
+    /** The HTML string to render. */
+    content: string;
+    /** Optional component overrides for HTML tags. */
+    components?: HTMLComponents<'permissive', {}>;
+    /** Render into light DOM so host-page CSS can style the output. */
+    createRenderRoot(): this;
+    render(): typeof nothing | import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'intlayer-html-renderer': HTMLRenderer;
+    }
+}

package/dist/types/src/html/index.d.ts

@@ -0,0 +1,3 @@
+export * from './HTMLRenderer';
+export * from './installIntlayerHTML';
+export type * from './types';

package/dist/types/src/html/installIntlayerHTML.d.ts

@@ -0,0 +1,40 @@
+import { HTMLComponents } from './types';
+export type RenderHTMLOptions = {
+    components?: HTMLComponents<'permissive', {}>;
+};
+export type RenderHTMLFunction = (html: string, overrides?: HTMLComponents<'permissive', {}> | RenderHTMLOptions) => string;
+export type IntlayerHTMLProvider = {
+    renderHTML: RenderHTMLFunction;
+};
+export type IntlayerHTMLPluginOptions = {
+    components?: HTMLComponents<'permissive', {}>;
+    renderHTML?: RenderHTMLFunction;
+};
+/**
+ * Create and return a single IntlayerHTMLProvider instance.
+ */
+export declare const createIntlayerHTMLClient: (renderHTML: RenderHTMLFunction) => IntlayerHTMLProvider;
+/**
+ * Install the Intlayer HTML provider for your Lit application.
+ *
+ * The installed renderer is used by `<intlayer-html-renderer>` and
+ * `useHTMLRenderer()`.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayerHTML } from 'lit-intlayer';
+ *
+ * installIntlayerHTML({
+ *   components: {
+ *     a: ({ href, children }) => `<a class="styled-link" href="${href}">${children}</a>`,
+ *   },
+ * });
+ * ```
+ */
+export declare const installIntlayerHTML: (pluginOptions?: IntlayerHTMLPluginOptions | RenderHTMLFunction) => IntlayerHTMLProvider;
+/**
+ * Access the installed IntlayerHTMLProvider.
+ * Returns a fallback renderer that outputs the raw HTML string if no
+ * provider has been installed.
+ */
+export declare const useHTML: () => IntlayerHTMLProvider;

package/dist/types/src/html/types.d.ts

@@ -0,0 +1,42 @@
+import { HTMLTagsType } from '@intlayer/core/transpiler';
+/**
+ * Helper to extract specific props from the configuration value.
+ */
+type PropsFromConfig<Value> = Value extends true ? {} : Value extends object ? Value : {};
+/**
+ * Common props for HTML elements rendered in Lit.
+ * Components receive these as a plain object.
+ */
+type ElementProps = Record<string, unknown> & {
+    children?: string;
+};
+/**
+ * Lit component type — a function that takes props and returns a string of HTML.
+ */
+type LitHTMLComponent<P = {}> = (props: P & ElementProps) => string;
+/**
+ * Helper: Defines the mapping for the explicitly listed keys in T.
+ */
+type DefinedComponents<T, IsRequired extends boolean> = IsRequired extends true ? {
+    [K in keyof T]: LitHTMLComponent<PropsFromConfig<T[K]>>;
+} : {
+    [K in keyof T]?: LitHTMLComponent<PropsFromConfig<T[K]>>;
+};
+/**
+ * Helper: Defines the standard HTML tags NOT listed in T.
+ */
+type RestHTMLComponents<T> = {
+    [K in Exclude<keyof HTMLTagsType, keyof T>]?: LitHTMLComponent;
+};
+/**
+ * The supported modes for the HTMLComponents type.
+ */
+export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+/**
+ * Component map for HTML rendering in Lit.
+ * Each component receives props and children and returns an HTML string.
+ */
+export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
+    [key: string]: LitHTMLComponent;
+} : DefinedComponents<T, false> & RestHTMLComponents<T>;
+export {};

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

@@ -0,0 +1,14 @@
+import { LocalesValues } from '@intlayer/types/module_augmentation';
+import { IInterpreterPluginLit } from './plugins';
+declare module '@intlayer/core/interpreter' {
+    interface IInterpreterPlugin<T, S, L extends LocalesValues> extends IInterpreterPluginLit<T, S, L> {
+    }
+}
+export * from './client';
+export * from './editor/useEditor';
+export * from './format/useIntl';
+export * from './getDictionary';
+export * from './getIntlayer';
+export * from './html';
+export * from './markdown';
+export * from './plugins';

package/dist/types/src/markdown/MarkdownRenderer.d.ts

@@ -0,0 +1,78 @@
+import { LitElement, nothing } from 'lit';
+import { HTMLComponents } from '../html/types';
+import { MarkdownProviderOptions, RenderMarkdownFunction } from './installIntlayerMarkdown';
+export type RenderMarkdownProps = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: string;
+};
+/**
+ * Renders markdown to an HTML string without using the global provider.
+ * Pass the result to `unsafeHTML()` in a Lit template.
+ */
+export declare const renderMarkdown: (content: string, { forceBlock, forceInline, preserveFrontmatter, tagfilter, }?: RenderMarkdownProps) => string;
+/**
+ * Returns a render function that uses the global provider's configuration
+ * (installed via `installIntlayerMarkdown`), falling back to `compileMarkdown`.
+ */
+export declare const useMarkdownRenderer: (props?: RenderMarkdownProps) => ((content: string) => string);
+/**
+ * `<intlayer-markdown-renderer>` — renders a markdown string as HTML.
+ *
+ * Renders into the light DOM (no shadow root) so that the host page's CSS
+ * can style the generated markup.
+ *
+ * Uses the globally installed markdown renderer when available
+ * (see `installIntlayerMarkdown`), or falls back to the default compiler.
+ *
+ * @example
+ * ```html
+ * <intlayer-markdown-renderer content="# Hello **World**">
+ * </intlayer-markdown-renderer>
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { html } from 'lit';
+ * import 'lit-intlayer/markdown'; // registers the element
+ *
+ * html`<intlayer-markdown-renderer .content=${myMarkdown}></intlayer-markdown-renderer>`
+ * ```
+ */
+export declare class MarkdownRenderer extends LitElement {
+    static properties: {
+        content: {
+            type: StringConstructor;
+        };
+        forceBlock: {
+            type: BooleanConstructor;
+        };
+        forceInline: {
+            type: BooleanConstructor;
+        };
+        preserveFrontmatter: {
+            type: BooleanConstructor;
+        };
+        tagfilter: {
+            type: BooleanConstructor;
+        };
+        renderMarkdown: {
+            attribute: boolean;
+        };
+    };
+    /** The markdown string to compile and render. */
+    content: string;
+    forceBlock?: boolean;
+    forceInline?: boolean;
+    preserveFrontmatter?: boolean;
+    tagfilter?: boolean;
+    /** Optional custom render function — overrides the global provider. */
+    renderMarkdownFn?: RenderMarkdownFunction;
+    /** Render into light DOM so host-page CSS can style the output. */
+    createRenderRoot(): this;
+    render(): typeof nothing | import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'intlayer-markdown-renderer': MarkdownRenderer;
+    }
+}

package/dist/types/src/markdown/compiler.d.ts

@@ -0,0 +1,25 @@
+import { CompileOptions, sanitizer as defaultSanitizer, slugify as defaultSlugify, RuleType } from '@intlayer/core/markdown';
+export { defaultSanitizer as sanitizer, defaultSlugify as slugify, RuleType };
+export type MarkdownCompilerOptions = CompileOptions;
+/**
+ * Compile markdown to an HTML string.
+ *
+ * The resulting string can be rendered in a Lit template using the
+ * `unsafeHTML` directive or the `<intlayer-markdown-renderer>` element.
+ *
+ * @example
+ * ```ts
+ * import { compileMarkdown } from 'lit-intlayer/markdown';
+ * import { unsafeHTML } from 'lit/directives/unsafe-html.js';
+ *
+ * class MyElement extends LitElement {
+ *   render() {
+ *     const html = compileMarkdown('# Hello **World**');
+ *     return html`${unsafeHTML(html)}`;
+ *   }
+ * }
+ * ```
+ */
+export declare const compileMarkdown: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+export declare const compiler: (markdown?: string, options?: MarkdownCompilerOptions) => string;
+export declare const compile: (markdown?: string, options?: MarkdownCompilerOptions) => string;

package/dist/types/src/markdown/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compiler';
+export * from './installIntlayerMarkdown';
+export * from './MarkdownRenderer';
+export * from './runtime';

package/dist/types/src/markdown/installIntlayerMarkdown.d.ts

@@ -0,0 +1,50 @@
+import { HTMLComponents } from '../html/types';
+export type MarkdownProviderOptions = {
+    /** Forces the compiler to always output content with a block-level wrapper. */
+    forceBlock?: boolean;
+    /** Forces the compiler to always output content with an inline wrapper. */
+    forceInline?: boolean;
+    /** Whether to preserve frontmatter in the markdown content. */
+    preserveFrontmatter?: boolean;
+    /** Whether to use the GitHub Tag Filter. */
+    tagfilter?: boolean;
+};
+export type RenderMarkdownOptions = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: string;
+};
+export type RenderMarkdownFunction = (markdown: string, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: string) => string;
+export type IntlayerMarkdownProvider = {
+    components?: HTMLComponents<'permissive', {}>;
+    renderMarkdown: RenderMarkdownFunction;
+};
+export type IntlayerMarkdownPluginOptions = MarkdownProviderOptions & {
+    components?: HTMLComponents<'permissive', {}>;
+    wrapper?: string;
+    renderMarkdown?: RenderMarkdownFunction;
+};
+/**
+ * Create and return a single IntlayerMarkdownProvider instance.
+ */
+export declare const createIntlayerMarkdownClient: (renderMarkdown: RenderMarkdownFunction, components?: HTMLComponents<"permissive", {}>) => IntlayerMarkdownProvider;
+/**
+ * Install the Intlayer Markdown provider for your Lit application.
+ *
+ * Call once at startup, before any elements that render markdown are connected.
+ * The installed renderer is used by `<intlayer-markdown-renderer>` and
+ * `useMarkdownRenderer()`.
+ *
+ * @example
+ * ```ts
+ * import { installIntlayerMarkdown } from 'lit-intlayer/markdown';
+ *
+ * installIntlayerMarkdown({ forceBlock: true });
+ * ```
+ */
+export declare const installIntlayerMarkdown: (pluginOptions?: IntlayerMarkdownPluginOptions | RenderMarkdownFunction) => IntlayerMarkdownProvider;
+/**
+ * Access the installed IntlayerMarkdownProvider.
+ * Returns a fallback renderer that outputs the raw markdown string if no
+ * provider has been installed.
+ */
+export declare const useMarkdown: () => IntlayerMarkdownProvider;

package/dist/types/src/markdown/runtime.d.ts

@@ -0,0 +1,12 @@
+import { MarkdownRuntime } from '@intlayer/core/markdown';
+/**
+ * Lit-specific MarkdownRuntime that produces HTML strings.
+ */
+export declare const litRuntime: MarkdownRuntime;
+/**
+ * Creates a Lit runtime with a custom createElement for advanced use cases.
+ */
+export declare const createLitRuntime: (options?: {
+    onCreateElement?: (type: any, props: Record<string, any> | null, children: any[]) => string;
+}) => MarkdownRuntime;
+export default litRuntime;

package/dist/types/src/plugins.d.ts

@@ -0,0 +1,75 @@
+import { DeepTransformContent as DeepTransformContentCore, IInterpreterPluginState as IInterpreterPluginStateCore, Plugins } from '@intlayer/core/interpreter';
+import { DeclaredLocales, LocalesValues } from '@intlayer/types/module_augmentation';
+import { NodeType } from '@intlayer/types/nodeType';
+import { HTMLComponents } from './html/types';
+import { IntlayerNode as IntlayerNodeCore } from './renderIntlayerNode';
+import * as NodeTypes from '@intlayer/types/nodeType';
+/** ---------------------------------------------
+ * INTLAYER NODE PLUGIN
+ * --------------------------------------------- */
+export type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
+export type IntlayerNode<T, P = {}> = IntlayerNodeCore<T> & P;
+/**
+ * Wraps string/number leaf values in an IntlayerNode so they carry
+ * `.value`, `.raw`, `toString()`, and `__update()`.
+ */
+export declare const intlayerNodePlugins: Plugins;
+/** ---------------------------------------------
+ * INSERTION PLUGIN
+ * --------------------------------------------- */
+export type InsertionCond<T, _S, _L> = T extends {
+    nodeType: NodeType | string;
+    [NodeTypes.INSERTION]: string;
+    fields: readonly string[];
+} ? <V extends {
+    [K in T['fields'][number]]: string | number;
+}>(values: V) => IntlayerNode<string> : never;
+export declare const insertionPlugin: Plugins;
+/** ---------------------------------------------
+ * MARKDOWN PLUGIN
+ * --------------------------------------------- */
+export type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
+    metadata: DeepTransformContent<string>;
+    /** Returns the raw markdown string; render with compileMarkdown() or <intlayer-markdown>. */
+    use: (components?: HTMLComponents<'permissive', {}>) => string;
+}> : never;
+export declare const markdownStringPlugin: Plugins;
+export type MarkdownCond<T> = T extends {
+    nodeType: NodeType | string;
+    [NodeTypes.MARKDOWN]: infer M;
+    metadata?: infer U;
+    tags?: infer U;
+} ? {
+    use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<M>;
+    metadata: DeepTransformContent<U>;
+} : never;
+export declare const markdownPlugin: Plugins;
+/** ---------------------------------------------
+ * HTML PLUGIN
+ * --------------------------------------------- */
+export type HTMLPluginCond<T> = T extends {
+    nodeType: NodeType | string;
+    [NodeTypes.HTML]: infer I;
+    tags?: infer U;
+} ? {
+    /** Returns the raw HTML string; render with unsafeHTML() or <intlayer-html>. */
+    use: (components?: HTMLComponents<'permissive', U>) => IntlayerNode<I>;
+} : never;
+export declare const htmlPlugin: Plugins;
+/** ---------------------------------------------
+ * PLUGINS RESULT
+ * --------------------------------------------- */
+export interface IInterpreterPluginLit<T, S, L extends LocalesValues> {
+    litIntlayerNode: IntlayerNodeCond<T>;
+    litInsertion: InsertionCond<T, S, L>;
+    litMarkdown: MarkdownCond<T>;
+    litHtml: HTMLPluginCond<T>;
+}
+export type IInterpreterPluginState = Omit<IInterpreterPluginStateCore, 'insertion'> & {
+    litIntlayerNode: true;
+    litInsertion: true;
+    litMarkdown: true;
+    litHtml: true;
+};
+export type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContentCore<T, IInterpreterPluginState, L>;
+export declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];

package/dist/types/src/renderIntlayerNode.d.ts

@@ -0,0 +1,22 @@
+import { ResolvedEditor } from '@intlayer/types/module_augmentation';
+export type IntlayerNode<T = string> = ResolvedEditor<T & {
+    raw: T;
+    value: T;
+    toString: () => string;
+    valueOf: () => T;
+    toJSON: () => T;
+    __update: (next: IntlayerNode<T>) => void;
+}, {
+    raw: T;
+    value: T;
+    toString: () => string;
+    valueOf: () => T;
+    toJSON: () => T;
+    __update: (next: IntlayerNode<T>) => void;
+}>;
+export declare const renderIntlayerNode: <T extends string | number | boolean | null | undefined>({ value, additionalProps, }: {
+    value: T;
+    children?: any;
+    additionalProps?: Record<string, unknown>;
+    [key: string]: unknown;
+}) => IntlayerNode<T>;