@joker.front/core 1.2.136 → 1.2.138

package/types/src/observer/dep.d.ts

@@ -1,46 +0,0 @@
-import { Watcher } from "./watcher";
-/**
- * 作为观察者和对象代理中间的关系桥
- * 数据变更时：Ob->dep->watcher
- * 设置依赖时：watcher->dep
- */
-export declare class Dep {
-    /**
-     * 关系id，尽在production模式下生效
-     */
-    id: string;
-    /**
-     * 当前目标的监听者
-     *
-     * 在更改值之前，设置该静态值，使其在值变更时收集相应的依赖关系
-     * 设置完毕后清除该值
-     *
-     * 之所以采用静态值，不采用方法的原因：
-     * 可能存在多值变更，或者读取
-     */
-    static target?: Watcher<any>;
-    watchers: Map<string | symbol, Watcher<any>[]>;
-    /**
-     * 设置依赖
-     * @param key
-     */
-    depend(key: string | symbol): void;
-    /**
-     * 添加观察者
-     * @param key
-     * @param watcher
-     */
-    addWatcher(key: string | symbol, watcher: Watcher<any>): void;
-    /**
-     * 删除观察者
-     * @param key
-     * @param watcher
-     */
-    removeWatcher(key: string | symbol, watcher: Watcher<any>): void;
-    /**
-     * 通知key下面的观察者
-     * @param key
-     */
-    notify(key: string | symbol): void;
-}
-export declare function notifyGroupDeps(list: Map<Dep, Array<string | symbol>>): void;

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

@@ -1,46 +0,0 @@
-/**
- * 存放劫持对象的Dep的Key
- */
-export declare const OBJECTPROXY_DEPID: unique symbol;
-/**
- * 数据劫持
- * @param data 数据
- * @param clone 是否clone
- * @returns 返回可观察对象
- */
-export declare function observer<T extends Object>(data: T, clone?: boolean): T;
-/**
- * 定义可劫持观察的属性
- *
- * 该方法会污染value深层，如想纯净数据，自行clone
- * @param target
- * @param key
- * @param value
- */
-export declare function defineObserverProperty(target: any, key: string | symbol, value: any): void;
-/**
- * 浅劫持监听，不污染数据源，只对根值监听，不对属性监听
- * @returns
- */
-export declare class ShallowObserver<T> {
-    private data;
-    private dep;
-    constructor(data: T);
-    /**
-     * 是否有变更
-     */
-    isChanged: boolean;
-    get value(): T;
-    set value(newVal: T);
-}
-/**
- * 组合回复，针对大量值变更，又不想频繁更新DOM，
- * 可通过该方法实现一个作用域内的统一组合回复
- * @param func 处理方法
- * @returns
- */
-export declare function combinedReply(func: Function): void;
-/**
- * 判断一个值是否是已被数据代理劫持
- */
-export declare function isObserverData(data: any): boolean;

package/types/src/observer/watcher.d.ts

@@ -1,46 +0,0 @@
-import { Dep } from "./dep";
-/**
- * 观察者
- *
- * 负责观察对象，并收集依赖关系，并在值变更时做出回调响应
- */
-export declare class Watcher<T extends object = any> {
-    private ob;
-    private updateCallBack;
-    private forceCallBack?;
-    private getter;
-    value: any;
-    isDestroy: boolean;
-    /**
-     * 运行时的关系收集
-     *
-     * 主要作用是：运行时做基本的重复过滤,并收集当前“有效的”Dep关系
-     * 一个Dep 肯定对应一个对象， 对象的key不会出现重复
-     */
-    private runRelations;
-    /**
-     * 实际关系
-     */
-    relations: Map<Dep, Array<string | symbol>>;
-    /**
-     *
-     * @param ob 数据源
-     * @param expOrFn 表达式（string｜Function）
-     * @param updateCallBack update回调
-     * @param forceCallBack 是否强制回调， 有些值未变更时也会强制回调
-     */
-    constructor(ob: T | (() => T), updateCallBack: Function, expOrFn?: string | ((obj: T) => any | void) | Function, forceCallBack?: boolean | undefined);
-    getValue(): any;
-    /**
-     * 添加Dep关系
-     * @param dep
-     * @param key
-     */
-    addDep(dep: Dep, key: string | symbol): void;
-    /**
-     * 更新值，并对其进行响应
-     */
-    update(): void;
-    destroy(): void;
-    private clearnDeps;
-}

package/types/src/parser/command/code.d.ts

@@ -1,6 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "../parser";
-import { VNode } from "../vnode";
-export declare class ParserCode extends IParser<AST.PropertyOrFunctionCommand, VNode.Text | VNode.Html> {
-    parser(): void;
-}

package/types/src/parser/command/condition.d.ts

@@ -1,22 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "../parser";
-import { VNode } from "../vnode";
-export declare class ParserCondition extends IParser<AST.IfCommand, VNode.Condition> {
-    parser(): void;
-    /**
-     * 渲染子集
-     *
-     * @return 返回当前渲染是否有显示变更
-     */
-    private renderConditionChildren;
-    /**
-     * 获取同级前面的判断条件结果，如果有一个true则返回true，
-     * 否则认为上面所有条件判断都为false
-     * @returns
-     */
-    private getPrevIfResult;
-    /**
-     * 重载所有的判断（从上到下）
-     */
-    private reloadAllCondition;
-}

package/types/src/parser/command/for.d.ts

@@ -1,23 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "../parser";
-import { VNode } from "../vnode";
-export declare class ParserList extends IParser<AST.ForCommand, VNode.List> {
-    parser(): void;
-    private renderChildrens;
-    private renderConditionChildrens;
-    private renderInOrOfChildrens;
-    /**
-     * 渲染循环项
-     * @param ob
-     * @param index
-     */
-    private renderItem;
-    /**
-     * 销毁历史遗留多余的节点
-     * @param index
-     */
-    private destroyOldChildrens;
-}
-export declare class ParserListeItem extends IParser<AST.ForCommand, VNode.ListItem> {
-    parser(): void;
-}

package/types/src/parser/command/section.d.ts

@@ -1,8 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "../parser";
-import { VNode } from "../vnode";
-export declare const DEFAULT_SECTION_TAG = "default";
-export declare class ParserRenderSection extends IParser<AST.PropertyOrFunctionCommand, VNode.RenderSection> {
-    parser(): void;
-    private transformParam;
-}

package/types/src/parser/comment.d.ts

@@ -1,6 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "./parser";
-import { VNode } from "./vnode";
-export declare class ParserComment extends IParser<AST.Comment, VNode.Comment> {
-    parser(): void;
-}

package/types/src/parser/component.d.ts

@@ -1,23 +0,0 @@
-import { AST, IComponent } from "@joker.front/ast";
-import { IParser } from "./parser";
-import { Component } from "../component";
-import { VNode } from "./vnode";
-export declare function checkIsComponent(tagName: string, ob: Component): boolean;
-export declare class ParserComponent extends IParser<(AST.Element | AST.Component) & {
-    node?: VNode.Component<IComponent>;
-}, VNode.Component<IComponent>> {
-    parser(): void;
-    /**
-     * 是否允许重载
-     * 直接指向内存的组件，无法重新实例化
-     */
-    get canReload(): boolean;
-    /** 用于重载 */
-    reload(): void;
-    private initPropData;
-    private initEvent;
-    private renderChildren;
-    private getSections;
-    protected beforeDestroy(keepalive?: boolean): void;
-    private transformPropValue;
-}

package/types/src/parser/element.d.ts

@@ -1,9 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "./parser";
-import { VNode } from "./vnode";
-export declare class ParserElement extends IParser<AST.Element, VNode.Element> {
-    parser(): void;
-    private initAttributes;
-    private initEvents;
-    private transformAttrVal;
-}

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

@@ -1,77 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { Component } from "../component";
-import { Render } from "./render";
-import { VNode } from "./vnode";
-export type NodeChangeType = "append" | "remove" | "update" | "after-enter" | "after-leave";
-export type ObType = Component & Record<string, any>;
-export declare class ParserTemplate {
-    asts: AST.Node[];
-    ob: ObType;
-    /** VNode 根 */
-    root: VNode.Root;
-    /** VNode ref索引集 */
-    refs: Record<string, Array<VNode.Node>>;
-    sleeped: boolean;
-    /**
-     * node变更观察者
-     */
-    nodeWatcherEvents: Record<string, Array<(node: VNode.Node, type: NodeChangeType, propertyKey?: string) => void>>;
-    /** VNode 渲染处理程序 （依赖注入） */
-    render: Render.IRender;
-    constructor(asts: AST.Node[], ob: ObType, parent?: VNode.Node);
-    parser(): void;
-    /**
-     * VNode挂载
-     * @param root
-     */
-    mount(root: any): void;
-    /**
-     * 编译AST子集
-     * @param asts
-     * @param parent
-     */
-    parserNodes(asts: AST.Node[], parent: VNode.Node, ob?: Component & Record<string, any>): void;
-    /**
-     * 添加ref
-     * @param refName ref值
-     * @param node VNode节点
-     */
-    addRef(refKey: string, node: VNode.Node): void;
-    /**
-     * 移除Node所在ref
-     * @param node VNode节点
-     */
-    removeRef(node: VNode.Node): void;
-    /**
-     * 添加节点变更观察者
-     * @param ref
-     * @param callBack
-     */
-    addNodeWatcher(ref: string, callBack: (node: VNode.Node, type: NodeChangeType) => void): void;
-    /**
-     * 移除节点变更观察者
-     * @param ref
-     * @param callBack
-     */
-    removeNodeWatcher(ref: string, callBack: Function): void;
-    /**
-     * 响应节点变更，通知观察者
-     * @param ref
-     * @param node
-     * @param nodeChangeType
-     */
-    notifyNodeWatcher(ref: string, node: VNode.Node, nodeChangeType: NodeChangeType, propertyKey?: string): void;
-    sleep(node?: VNode.Node): void;
-    private weakup;
-    /**
-     * 销毁
-     */
-    destroy(keepalive?: boolean): void;
-    reParser(asts: AST.Node[], keepalive?: boolean): void;
-    nodeTransition(node: VNode.Node | undefined, mode: "enter" | "leave", name?: string, callBack?: Function, type?: "transition" | "animation"): boolean;
-}
-export declare function getFirstElement(node: VNode.Node): VNode.Element | undefined;
-export declare function getNodeSupportTransition(node: VNode.Node): {
-    name: any;
-    type: any;
-} | undefined;

package/types/src/parser/parser.d.ts

@@ -1,82 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { ObType, ParserTemplate, NodeChangeType } from ".";
-import { Watcher } from "../observer/watcher";
-import { VNode } from "./vnode";
-export declare const FILTERTAG = "Filter";
-export declare abstract class IParser<T extends AST.Node, N extends VNode.Node> {
-    /** ast集合 */
-    protected ast: T;
-    /** 数据源 会在component上进行属性新增 */
-    ob: ObType;
-    /** 父节点 */
-    protected parent: VNode.Node;
-    /** 外部处理（ParserTemplate） */
-    protected ext: ParserTemplate;
-    /** 当前转换节点ref标记 */
-    ref: string;
-    /** 当前AST解析 所产生的观察者 */
-    private watchers;
-    node?: N;
-    constructor(
-    /** ast集合 */
-    ast: T, 
-    /** 数据源 会在component上进行属性新增 */
-    ob: ObType, 
-    /** 父节点 */
-    parent: VNode.Node, 
-    /** 外部处理（ParserTemplate） */
-    ext: ParserTemplate);
-    /**
-     * 上游主入口方法（初始化执行）
-     */
-    abstract parser(): void;
-    protected beforeDestroy(keepalive?: boolean): void | boolean;
-    /**
-     * 销毁流程
-     */
-    destroy(keepalive?: boolean): void;
-    private destroyOtherData;
-    /**
-     * 销毁所有子集VNode
-     */
-    protected destroyChildrens(keepalive?: boolean): void;
-    /**
-     * 销毁所有子集VNode的watcher，为了防止延迟卸载时，无效通知广播
-     */
-    protected destroyChildrensWatcher(nodeItem?: VNode.Node): void;
-    /**
-     * 插入自身节点
-     */
-    protected appendNode(): void;
-    protected afterParser(): void;
-    /**
-     * 通知节点观察者
-     * @param type 通知类型
-     */
-    protected notifyNodeWatcher(type: NodeChangeType, propertyKey?: string): void;
-    /**
-     * 运行表达式方法，并返回运行后的值（不带观察者）
-     * @param express 表达式 string|function
-     * @param ob 数据源
-     * @returns
-     */
-    protected runExpress(express: string, ob: any): any;
-    /**
-     * 运行表达式方法，并返回运行后的值（带观察者）
-     * @param express 表达式 string|function
-     * @param ob 数据源
-     * @param updateCallBack 更新回调
-     * @param forceCallBack 是否强制回调
-     * @returns
-     */
-    protected runExpressWithWatcher(express: string | Function, ob: any, updateCallBack: (newVal: any, oldVal: any) => void, forceCallBack?: boolean): any;
-    /**
-     * 添加观察者
-     * @param watcher
-     */
-    protected addWatch(watcher: Watcher<any>): void;
-    /**
-     * 清空所有观察者
-     */
-    protected clearWatchers(): void;
-}

package/types/src/parser/render.d.ts

@@ -1,86 +0,0 @@
-import { VNode } from "./vnode";
-import { IComponent } from "@joker.front/ast";
-type TransitionType = "transition" | "animation";
-export declare namespace Render {
-    /**
-     * 注入TagId
-     */
-    const IRENDERIOCTAGID: unique symbol;
-    /**
-     * 备注：在渲染时执行appendNode，最终执行一次mount挂载
-     * 不会出现根目录append的场景，因为指令group会优先占位
-     *
-     * append 和 remove方法不会存在 parent的参数，因为一次挂载后
-     * 会存在关系，根据关系直接执行
-     * 上游调用也无需关心parent，特别是在watch周期内
-     */
-    interface IRender {
-        /**
-         * 挂载
-         * @param root 挂载根
-         * 不限制root类型，为后面做多端兼容
-         */
-        mount(root: any): void;
-        /**
-         * 添加节点
-         * @param node NodeInfo
-         */
-        appendNode(node: VNode.Node): void;
-        /**
-         * 更新节点
-         * @param node NodeInfo
-         * @param propertyKey 更新属性名称
-         */
-        updateNode(node: VNode.Node, propertyKey?: string): void;
-        /**
-         * 删除节点
-         * @param {VNode.Node} node
-         * @param {VNode.Node} parent 如果为空则带表root跟节点下集
-         * @param {boolean} reserveOutPut 是否需要保留out产物
-         */
-        removeNode(node: VNode.Node, reserveOutPut?: boolean): void;
-        /**
-         * 销毁，卸载DOM并释放变量
-         */
-        destroy(): void;
-        /**
-         * element节点transition enter
-         */
-        elementToEnter(node: VNode.Element, name: string, type?: TransitionType, callBack?: Function): void;
-        /**
-         * element节点transition leave
-         */
-        elementToLeave(node: VNode.Element, name: string, type?: TransitionType, callBack?: Function): void;
-        /**
-         * 触发组件事件
-         * @param node
-         * @param eventName
-         * @returns false 则代表通知广播
-         */
-        triggerEvent(node: VNode.Component, eventName: string, e: VNode.Event): void | false;
-    }
-    /**
-     * 默认Render，采用H5-DOM模式进行输出
-     */
-    class DomRender implements IRender {
-        elements: DocumentFragment;
-        constructor();
-        mount(root: Element | VNode.Component): void;
-        appendNode(node: VNode.Node): void;
-        updateNode(node: VNode.Node, propertyKey?: string | undefined): void;
-        removeNode(node: VNode.Node, reserveOutPut?: boolean): void;
-        destroy(): void;
-        elementToEnter(node: VNode.Element, name: string, type?: TransitionType, callBack?: Function): void;
-        elementToLeave(node: VNode.Element, name: string, type?: TransitionType, callBack?: Function): void;
-        triggerEvent(node: VNode.Component<IComponent & Record<string, any>>, _eventName: string, _e: VNode.Event): void | false;
-        private transitionFrame;
-        private renderNode;
-        private initElementEvents;
-        private parserHtml;
-        private isCommandGroup;
-        private appendNodeChildren;
-        private setAttribute;
-    }
-}
-export declare function getTransitionClassName(transition: string, mode: "enter" | "leave", type: "from" | "active" | "to"): string;
-export {};

package/types/src/parser/text.d.ts

@@ -1,6 +0,0 @@
-import { AST } from "@joker.front/ast";
-import { IParser } from "./parser";
-import { VNode } from "./vnode";
-export declare class ParserText extends IParser<AST.Text, VNode.Text> {
-    parser(): void;
-}

package/types/src/parser/vnode.d.ts

@@ -1,182 +0,0 @@
-import { AST, IComponent } from "@joker.front/ast";
-import { Component as ComponentClass } from "../component";
-import { ObType } from ".";
-import { SectionType } from "../component";
-import { IParser } from "./parser";
-/**
- * 虚拟DOM
- *
- * 该控件分类区别于AST，分类是按照实际输出类型作为划分
- */
-export declare namespace VNode {
-    const PARSERKEY: unique symbol;
-    /**
-     * VNode 基类
-     */
-    class Node {
-        parent?: Node | undefined;
-        /**
-         * 是否是静态节点，非动态节点。例如：element、text、comment等
-         */
-        static?: boolean;
-        output?: any;
-        [PARSERKEY]?: IParser<AST.Node, VNode.Node>;
-        childrens?: Node[];
-        /**
-         * 当前节点是否睡眠
-         */
-        sleep: boolean;
-        constructor(parent?: Node | undefined);
-        /**
-         * 上一个节点
-         */
-        get prev(): Node | undefined;
-        /**
-         * 下一个节点
-         */
-        get next(): Node | undefined;
-        /**
-         * 匹配第一个符合要求的祖先元素
-         * @param match
-         * @param breakWhenVRoot 是否过滤到当前视图根时中断
-         * @returns
-         */
-        closest<T extends VNode.Node = VNode.Node>(filter: (node: VNode.Node) => boolean | void, breakWhenVRoot?: boolean): T | undefined;
-        /**
-         * 返回所有匹配的子元素
-         * @param filter 返回true则记录，返回false则跳过该元素的子集
-         * @returns
-         */
-        find(filter: (node: VNode.Node) => boolean | void, childrens?: Array<VNode.Node>, _out?: Array<VNode.Node>): Array<VNode.Node>;
-        /**
-         * 是否包含
-         * @param filter 返回true则记录，返回false则跳过该元素的子集
-         * @returns
-         */
-        contains(filter: (node: VNode.Node) => boolean | void, childrens?: Array<VNode.Node>): boolean;
-    }
-    /**
-     * 根节点
-     */
-    class Root<T extends IComponent = IComponent & Record<string, any>> extends Node {
-        childrens: Node[];
-        component: T;
-        constructor();
-    }
-    /**
-     * 文本类型节点
-     */
-    class Text extends Node {
-        text: string;
-        static: boolean;
-        constructor(text: string, parent: Node);
-    }
-    /**
-     * Html节点
-     */
-    class Html extends Node {
-        html: string;
-        static: boolean;
-        constructor(html: string, parent: Node);
-    }
-    /**
-     * 注释节点
-     */
-    class Comment extends Node {
-        text: string;
-        static: boolean;
-        constructor(text: string, parent: Node);
-    }
-    /**
-     * Element节点
-     */
-    class Element extends Node {
-        tagName: string;
-        static: boolean;
-        attributes: Record<string, any>;
-        transitionTimer?: number;
-        childrens: Node[];
-        events: Array<[string, {
-            modifiers?: string[];
-            callBack: EventCallBack;
-        }]>;
-        /**
-         * 协助事件存储，用于存储辅助事件，例如outside等事件
-         */
-        _assistEventCache?: Array<[string, (e: any) => void]>;
-        constructor(tagName: string, parent: Node);
-    }
-    type Event<T = undefined> = {
-        /**
-         * 事件名称
-         */
-        eventName: string;
-        /**
-         * 原生event，对应运行平台
-         */
-        event?: any;
-        /** 触发事件目标元素 */
-        target?: Node;
-        /** 阻止默认事件 */
-        preventDefault(): void;
-        /** 阻止事件传播 */
-        stopPropagation(): void;
-        /** 参数 */
-        data: T;
-    };
-    type EventCallBack<T = any> = (e: Event<T>) => void;
-    /**
-     * 组件节点
-     */
-    class Component<T extends IComponent = IComponent & Record<string, any>> extends Node {
-        name?: string;
-        transitionTimer?: number;
-        component: T;
-        events: Array<[string, {
-            modifiers?: string[];
-            callBack: EventCallBack;
-        }]>;
-        propValues: Record<string, any>;
-        keepalive?: boolean;
-        /**
-         * 当前组件第一个element vnode
-         */
-        get firstElement(): Element | undefined;
-        private findElement;
-    }
-    /**
-     * 条件节点
-     */
-    class Condition extends Node {
-        cmdName: AST.IfCommand["kind"];
-        result: boolean;
-        childrens: Node[];
-        isShow: boolean;
-        constructor(cmdName: AST.IfCommand["kind"], parent: Node);
-    }
-    /**
-     * 列表节点,内部包含多组列表项
-     */
-    class List extends Node {
-        childrens: ListItem[];
-    }
-    /**
-     * 循环列表项
-     */
-    class ListItem extends Node {
-        ob: ObType;
-        childrens: Node[];
-        constructor(ob: ObType, parent: VNode.Node);
-    }
-    /**
-     * 插槽节点
-     */
-    class RenderSection extends Node {
-        id: string;
-        params: any[];
-        section?: SectionType;
-        childrens: Node[];
-        ob?: ComponentClass & Record<string, any>;
-        constructor(idOrSection: string | SectionType, parent: Node);
-    }
-}