@b-side/parser/lib/element.d.ts

HTML Parser used to parse HTML string and bind data to it.

import { BSideElementInterface } from '@b-side/shared';
import { Expression } from './expression';
import { Effects } from './side-effects';
export declare const SelfClosingTags: string[];
export declare class bsElement {
    #private;
    attributesMap: {
        static: Map<string, string>;
        dynamic?: Map<string, Expression>;
    };
    childs: Array<bsElement>;
    dependancies: Effects;
    nodeName: string;
    strAttributes: string;
    parent?: bsElement;
    set dom(value: Node | undefined);
    get dom(): Node | undefined;
    appendText(string: string): void;
    appendExpression(string: string): void;
    append(element: bsElement): void;
    clone(parent?: bsElement): bsElement;
    updateDependancies(context: Record<string, unknown>, contextSnapshot?: string, newKeys?: string[]): string[];
    toString(): string;
}
export declare class bsCondition extends bsElement {
    expression: Expression;
    logic: {
        elements: bsElement[];
        resolved: bsElement[];
        isDefault: boolean;
    };
    constructor(attributes: Map<string, {
        expression: string;
    }>);
    clone(parent?: bsElement): bsCondition;
    updateDependancies(context: Record<string, unknown>, contextSnapshot?: string, newKeys?: string[]): string[];
}
export declare class bsFragment extends bsElement {
    #private;
    set dom(value: DocumentFragment);
    get dom(): DocumentFragment;
    createDomElement(): DocumentFragment;
}
export declare class bsIteration extends bsCondition {
    clones: bsElement[][];
    clone(parent?: bsElement): bsIteration;
}
export declare class bsNode extends bsElement {
    #private;
    attributesMap: {
        static: Map<any, any>;
        dynamic: Map<any, any>;
    };
    eventsMap: {
        static: Map<any, any>;
        dynamic: Map<any, any>;
    };
    constructor(attributes?: Map<string, {
        expression?: string;
        value?: string;
    }>);
    set dom(value: BSideElementInterface);
    get dom(): BSideElementInterface;
    clone(parent?: bsElement): bsNode;
    createDomElement(): BSideElementInterface;
    setAttributesMap(attributes: Map<string, {
        expression?: string;
        value?: string;
    }>): void;
}
export declare class bsText extends bsElement {
    #private;
    content: string;
    constructor(text?: string);
    set dom(value: Text);
    get dom(): Text;
    clone(parent?: bsElement): bsText;
    createDomElement(): Text;
}
export declare class bsExpression extends bsElement {
    #private;
    expression: Expression;
    siblings: ChildNode[];
    template: HTMLTemplateElement;
    constructor(text?: string);
    set dom(value: HTMLElement);
    get dom(): HTMLElement;
    clone(parent: bsElement): bsExpression;
    updateDependancies(context: Record<string, unknown>, contextSnapshot?: string, newKeys?: string[]): string[];
}
export declare const CreateElement: (tagName: string, strAttributes?: string, attributes?: Map<string, {
    expression?: string;
    value?: string;
}>) => bsElement;
//# sourceMappingURL=element.d.ts.map