@optionfactory/fml 8.0.0

package/dist/ftl.d.mts

@@ -0,0 +1,361 @@
+declare class Expressions {
+    #private;
+    static MODE_EXPRESSION: symbol;
+    static MODE_TEMPLATED: symbol;
+    /**
+     * Parses an expression.
+     * @param {string} expression
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+     * @returns the ast
+     */
+    static parse(expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
+    /**
+     * Evaluates an expression.
+     * @param {{[k: string]: any } | null | undefined } modules
+     * @param {any[]} dataStack
+     * @param {any} ast
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+     * @returns the result
+     */
+    static evaluate(modules: {
+        [k: string]: any;
+    } | null | undefined, dataStack: any[], ast: any, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
+    /**
+     * Parses and evaluates an expression.
+     * @param {{ [x: string]: any; } | null | undefined} modules
+     * @param {any[]} dataStack
+     * @param {string} expression
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+     * @returns the result
+     */
+    static interpret(modules: {
+        [x: string]: any;
+    } | null | undefined, dataStack: any[], expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
+}
+declare class ExpressionEvaluator {
+    #private;
+    constructor(modules: any, dataStack: any);
+    withModule(name: any, value: any): ExpressionEvaluator;
+    withOverlay(...data: any[]): ExpressionEvaluator;
+    evaluate(expression: any, mode: any): any;
+    evaluateExpression(expression: any): any;
+    evaluateTemplated(expression: any): any;
+}
+declare class Fragments {
+    /**
+     * Creates a DocumentFragment from an string.
+     * @param  {...string} html
+     * @returns {DocumentFragment} the fragment
+     */
+    static fromHtml(...html: string[]): DocumentFragment;
+    /**
+     * Creates a string representation (HTML) of a DocumentFragment.
+     * @param {DocumentFragment} fragment
+     * @returns {string} the html
+     */
+    static toHtml(fragment: DocumentFragment): string;
+    /**
+     * Checks if a fragment contains only blank text nodes
+     * @param {DocumentFragment} fragment
+     * @returns {boolean} true if the fragment is blank
+     */
+    static isBlank(fragment: DocumentFragment): boolean;
+    /**
+     * Creates a DocumentFragment from nodes.
+     * @param  {...Node} nodes
+     * @returns {DocumentFragment} the fragment
+     */
+    static from(...nodes: Node[]): DocumentFragment;
+    /**
+     * Creates a DocumentFragment from childNodes of an element.
+     * @param {Node} el
+     * @returns {DocumentFragment} the fragment
+     */
+    static fromChildNodes(el: Node): DocumentFragment;
+}
+declare class Attributes {
+    static id: number;
+    /**
+     * Creates a unique id with the given prefix.
+     * @param {string} prefix
+     * @returns
+     */
+    static uid(prefix: string): string;
+    /**
+     * Sets an attribute if not present.
+     * @param {Element} el
+     * @param {string} k
+     * @param {string} v
+     * @returns
+     */
+    static defaultValue(el: Element, k: string, v: string): string | null;
+    /**
+     * Forwards prefixed attributes from an element to another (removing the prefix).
+     * @param {string} prefix
+     * @param {Element} from
+     * @param {Element} to
+     */
+    static forward(prefix: string, from: Element, to: Element): void;
+    /**
+     * Changes the presence of an attribute.
+     * @param {Element} el
+     * @param {string} attr
+     * @param {boolean} value
+     */
+    static toggle(el: Element, attr: string, value: boolean): void;
+    /**
+     * Changes the presence of an attribute based on its current state.
+     * @param {Element} el
+     * @param {string} attr
+     */
+    static flip(el: Element, attr: string): void;
+    /**
+     * Sets the value of an attribute. nullish values remove the attribute.
+     * @param {Element} el
+     * @param {string} attr
+     * @param {string | null | undefined} value
+     */
+    static set(el: Element, attr: string, value: string | null | undefined): void;
+}
+declare class LightSlots {
+    /**
+     * Extracts light slots from an element. For non default slots in a template tag, the content is extracted.
+     * @param {Element} el
+     * @returns the slots
+     */
+    static from(el: Element): {
+        default: DocumentFragment;
+    };
+    static slotFromNode(el: any): any;
+}
+declare class Nodes {
+    /**
+     * Checks if an element is already parsed.
+     * @param {Element} el
+     * @returns
+     */
+    static isParsed(el: Element): boolean;
+    static waitParsed(el: any): Promise<any>;
+    /**
+     * Returns the first child of the element element (if exists) matching the selector.
+     * @param {Element} el
+     * @param {string} selector
+     * @returns
+     */
+    static queryChildren(el: Element, selector: string): Element | null;
+    /**
+     * Returns all children of the element matching the selector.
+     * @param {Element} el
+     * @param {string} selector
+     * @returns
+     */
+    static queryChildrenAll(el: Element, selector: string): Element[];
+}
+declare class Template {
+    #private;
+    /**
+     * Creates a template from a string.
+     * @param {string} html
+     * @param {{ [k: string] : any }?} [modules]
+     * @param {...*} data
+     * @returns the template
+     */
+    static fromHtml(html: string, modules?: {
+        [k: string]: any;
+    } | null, ...data: any[]): Template;
+    /**
+     * Creates a template from the content of the first template element matching the selector.
+     * @param {string} selector for an HTMLTemplateElement
+     * @param {{ [k: string] : any }?} [modules]
+     * @param {...*} data
+     * @returns the template
+     */
+    static fromSelector(selector: string, modules?: {
+        [k: string]: any;
+    } | null, ...data: any[]): Template;
+    /**
+     * Creates a template from the content of an HTMLTemplateElement.
+     * @param {HTMLTemplateElement} templateEl
+     * @param {{ [k: string] : any }?} [modules]
+     * @param {...*} data
+     * @returns the template
+     */
+    static fromTemplate(templateEl: HTMLTemplateElement, modules?: {
+        [k: string]: any;
+    } | null, ...data: any[]): Template;
+    /**
+     * Creates a template from a DocumentFragment.
+     * @param {DocumentFragment} fragment
+     * @param { { [k: string] : any }? } [modules]
+     * @param {...*} data
+     * @returns the template
+     */
+    static fromFragment(fragment: DocumentFragment, modules?: {
+        [k: string]: any;
+    } | null, ...data: any[]): Template;
+    /**
+     * Creates a template.
+     * @param {DocumentFragment} fragment
+     * @param {{ [x: string]: any; } | null | undefined} modules
+     * @param {any[]} dataStack
+     */
+    constructor(fragment: DocumentFragment, modules: {
+        [x: string]: any;
+    } | null | undefined, dataStack: any[]);
+    /**
+     * Creates a new Template replacing the modules and dataStack from a context.
+     * @param {{modules: { [x: string]: any; } | null | undefined, data: any[]}} context
+     */
+    withContext({ modules, data }: {
+        modules: {
+            [x: string]: any;
+        } | null | undefined;
+        data: any[];
+    }): Template;
+    /**
+     * Creates a new Template replacing the modules and dataStack from a registry.
+     * @param any registry
+     */
+    withContextFrom(registry: any): Template;
+    /**
+     * Creates a new Template replacing the fragment.
+     * @param {DocumentFragment} fragment
+     */
+    withFragment(fragment: DocumentFragment): Template;
+    /**
+     * Creates a new Template with a new module added.
+     * @param {string?} name
+     * @param {{[k: string]: any}} value
+     */
+    withModule(name: string | null, value: {
+        [k: string]: any;
+    }): Template;
+    /**
+     * Creates a new Template replacing the modules.
+     * @param {{ [x: string]: any; }?} modules
+     */
+    withModules(modules: {
+        [x: string]: any;
+    } | null): Template;
+    /**
+     * Creates a new Template replacing the data stack.
+     * @param {any[]} dataStack the dataStack
+     */
+    withData(dataStack: any[]): Template;
+    /**
+     * Creates a new Template with new a data overlay added to the stack.
+     * @param {...*} data
+     */
+    withOverlay(...data: any[]): Template;
+    /**
+     * Evaluates an expression using the configured modules and data.
+     * @param {string} expression
+     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
+     * @param {...*} data
+     */
+    evaluate(expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null, ...data: any[]): void;
+    /**
+     * Returns an expression evaluator with bound modules and dataStack.
+     */
+    evaluator(): ExpressionEvaluator;
+    /**
+     * Renders the template.
+     * @returns a DocumentFragment
+     */
+    render(): DocumentFragment;
+    /**
+     * Renders this template on the Element (replacing children).
+     * @param {Element} el
+     */
+    renderTo(el: Element): void;
+    /**
+     * Renders this template appending the resulting fragment to the Element.
+     * @param {Element} el
+     */
+    appendTo(el: Element): void;
+    /**
+     * Renders this template appending the resulting fragment to the first Element maching the selector, if exists.
+     * @param {string} selector
+     */
+    renderToSelector(selector: string): void;
+    /**
+     * Renders this template appending the resulting fragment to the Element maching the selector, if exists.
+     * @param {string} selector
+     */
+    appendToSelector(selector: string): void;
+}
+declare class RenderError extends Error {
+    #private;
+    node: any;
+    constructor(message: any, nodeOrFragment: any, cause: any);
+    static stringify(nodeOrFragment: any): string;
+}
+declare class Registry {
+    #private;
+    defineElement(tag: any, klass: any): this;
+    defineModule(name: any, value: any): this;
+    defineModules(ms: any): this;
+    defineComponent(name: any, value: any): this;
+    defineData(...data: any[]): this;
+    defineOverlay(...data: any[]): this;
+    defineMapper(k: any, v: any): this;
+    plugin(p: any): this;
+    configure(): this;
+    get upgrades(): MapIterator<[any, any]>;
+    context(): {
+        modules: any;
+        data: any[];
+    };
+    evaluator(): ExpressionEvaluator;
+    component(name: any): any;
+}
+declare const registry: Registry;
+declare class Templates {
+    static fromHtml(html: any): Template;
+    static fromSelector(selector: any): Template;
+    static fromTemplate(templateEl: any): Template;
+    static fromFragment(fragment: any): Template;
+}
+declare class Rendering {
+    static waitFor(el: any): Promise<void>;
+    static waitForChildren(el: any): Promise<void>;
+}
+export type Mapper = {
+    unmarshal: (val: string | null | undefined, name: string, el: Element) => any;
+    marshal: (val: any, name: string, el: Element) => string | null;
+};
+/**
+ * An attribute Mapper.
+ *
+ * @typedef {object} Mapper
+ * @property {(val: string|null|undefined, name: string, el: Element) => any} unmarshal
+ * @property {(val: any, name: string, el: Element) => string|null} marshal
+ */
+declare class ParsedElement extends HTMLElement {
+    #private;
+    static BITS: {
+        enqueue: (el: any) => void;
+        SLOTS: boolean;
+        OBSERVED: never[];
+        /** @type {Record<string, Mapper>} */
+        ATTR_TO_MAPPER: Record<string, Mapper>;
+        TEMPLATES: {};
+    };
+    static get observedAttributes(): never[];
+    unmarshal(attr: any, str: any): any;
+    marshal(attr: any, value: any): string | null;
+    /**
+     * @param {string} [name] - The name of the template target, defaults to 'default'
+     */
+    template(name?: string): any;
+    connectedCallback(): void;
+    attributeChangedCallback(attr: any, oldValue: any, newValue: any): void;
+    formDisabledCallback(disabled: any): void;
+    upgrade(): Promise<void>;
+    render(c: any): void;
+    reflect(fn: any): void;
+    reflectTo(attr: any, value: any): void;
+}
+export { Attributes, ExpressionEvaluator, Expressions, Fragments, LightSlots, Nodes, ParsedElement, Registry, RenderError, Rendering, Template, Templates, registry };
+
+export as namespace ftl;