@winged/core/build/vdom/vdom.d.ts

Morden webapp framekwork made only for ts developers. (UNDER DEVELOPMENT, PLEASE DO NOT USE)

import { ModificationTree } from '../types';
import { ViewModel } from '../viewModel/ViewModel';
import { VListItem } from './logicalNode/LNFor';
import { LNSlot } from './logicalNode/LNSlot';
import { LNSubview } from './logicalNode/LNSubview';
import { LogicalNode } from './logicalNode/LogicalNode';
import { VElement } from './VElement';
import { VText } from './VText';
export interface PrevSibling {
    node?: Node;
}
export declare class VDomRoot {
    domCreated: boolean;
    container: HTMLElement;
    private rootElement;
    /** dirty means this will be render in next animation frame */
    private dirty;
    private renderCache?;
    constructor(rootElement: VElement);
    initialRender(vm: ViewModel, container: HTMLElement, prevSibling: PrevSibling): void;
    update(vm: ViewModel, modificationTree: ModificationTree): void;
    renderUpdate(): void;
    destroy(): void;
    private computeModifiedState;
    private checkRebuildStateDependencies;
}
interface BaseView {
    _propsType: {};
}
export declare type VDomStruct = [NodeType, string] | [NodeType, string, AttrDict] | [NodeType, string, NodeContent] | [NodeType, string, AttrDict, NodeContent];
declare type NodeType = 'E' | 'D' | 'L';
declare type NodeContent = string | ContentStructList;
declare type NonTagNodeContent = string | Array<string | ['D', string]>;
export interface AttrDict {
    [attr: string]: NonTagNodeContent;
}
export interface ContentStructList {
    [index: number]: string | VDomStruct;
    length: number;
}
export declare class VNodeRegister {
    view: BaseView;
    viewClassName: string;
    /** this api is provided by View */
    registerSubviewNode: (node: LNSubview) => {
        propsGetter: () => any;
        stateDependencies: string[];
    };
    /** this api is provided by View */
    registerSlotNode: (node: LNSlot) => void;
    constructor(view: BaseView);
    destory(): void;
}
declare type LogicalNodeParentType = 'common' | 'If' | 'View' | 'Plugin';
declare class VDomFactory {
    /**
     * NOTE: verifyMode controls whether renderables are constructed under verifyMode
     * this will be true when doing v.ts file generating or html grammar check.
     * when verifyMode is on,
     * all vdom entity will try to create the whole set of their children struct for verify purpose
     * this will only effect LNFor and LNIf node for now
     */
    verifyMode: boolean;
    /**
     * NOTE: idCounters controls entityId
     * only used for verifyMode
     * when parsing vdom struct,
     * we will will give all vdom entity an unique id,
     * to help referring them to the same entity that parsed from html file
     * so their line & colum number can be shown when there's an verify eror
     */
    private idCounters;
    private SUPPORTED_LOGICAL_TAGS;
    private VALID_LOGICAL_CHILDREN_TAGS;
    getIdCounters(): {
        entityId: number;
    };
    createVDomRoot(struct: VDomStruct, register: VNodeRegister): VDomRoot;
    createVChildren(struct: string | VDomStruct, parentType: LogicalNodeParentType, register: VNodeRegister): LogicalNode | VText | VElement;
    createVListItem(childrenStruct: Array<string | VDomStruct>, register: VNodeRegister, indexKeyName?: string): VListItem;
    createVElement(struct: VDomStruct, register: VNodeRegister): VElement;
    private createLogicalNode;
    private normalizeStruct;
}
export declare const vDomFactory: VDomFactory;
export {};