@joker.front/core 1.2.136

package/types/parser/index.d.ts

@@ -0,0 +1,77 @@
+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/parser/parser.d.ts

@@ -0,0 +1,82 @@
+import { AST } from "@joker.front/ast";
+import { ObType, ParserTemplate, NodeChangeType } from ".";
+import { Watcher } from "../observer/watcher";
+import { VNode } from "./vnode";
+export declare const GLOBAL_TAG = "Global";
+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/parser/render.d.ts

@@ -0,0 +1,86 @@
+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/parser/text.d.ts

@@ -0,0 +1,6 @@
+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/parser/vnode.d.ts

@@ -0,0 +1,180 @@
+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>;
+        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;
+        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);
+    }
+}

package/types/props.d.ts

@@ -0,0 +1,9 @@
+export type PropValueType = String | ArrayConstructor | Number | Object | Function | Boolean;
+export type PropTypeFullModel = {
+    type?: PropValueType | Array<PropValueType>;
+    required?: Boolean;
+    default?: any;
+    validate?: (val: any) => Boolean;
+};
+export type PropType = PropValueType | Array<PropValueType> | PropTypeFullModel;
+export declare function getPropValue(propsData: Readonly<Record<string | symbol, any>>, key: string | symbol, propsType?: Record<string | symbol, any>): any;

package/types/src/component.d.ts

@@ -0,0 +1,216 @@
+import { AST, IComponent, RENDER_HANDLER } from "@joker.front/ast";
+import { NodeChangeType, ParserTemplate } from "./parser";
+import { VNode } from "./parser/vnode";
+import { PropType } from "./props";
+declare const PROPS_DATA_KEY: unique symbol;
+declare const PROPS_DATA_PROXY: unique symbol;
+declare const PRIVATE_WATCHERS: unique symbol;
+declare const EVENT_DATA_KEY: unique symbol;
+declare const PARSER_TEMPLATE_TARGET: unique symbol;
+export type TemplateType = Array<AST.Node> | ((h: typeof RENDER_HANDLER) => Array<AST.Node>);
+export declare const SCOPE_ID: unique symbol;
+export declare const JOKER_COMPONENT_TAG: unique symbol;
+export type ComponentConstructor = typeof Component<any>;
+export type ImportComponentConstructor = () => Promise<{
+    default: ComponentConstructor;
+}>;
+export type SectionType = {
+    asts: AST.Node[];
+    ob?: Component & Record<string, any>;
+    parser?: ParserTemplate;
+    params?: string[];
+};
+type DefaultKeyVal = Record<string | symbol, any>;
+/**
+ * Joker组件
+ */
+export declare class Component<T extends DefaultKeyVal = {}> implements IComponent {
+    $sections: Record<string, SectionType>;
+    readonly isKeepAlive?: boolean | undefined;
+    static [JOKER_COMPONENT_TAG]: boolean;
+    /**
+     * scopeId 配合css：Scoped
+     */
+    [SCOPE_ID]?: string;
+    /**
+     * 可观察数据（具备劫持观察能力）
+     */
+    model: DefaultKeyVal;
+    /**
+     * 渲染模板
+     */
+    template?: TemplateType;
+    /**
+     * 挂载根
+     */
+    $root: any;
+    /**
+     * 是否已睡眠
+     */
+    isSleeped: boolean;
+    /**
+     * 可用的声明组件
+     */
+    components: Record<string, ComponentConstructor | ImportComponentConstructor>;
+    /**
+     * props辅助约束
+     * @example { name:"默认值",age:Number }
+     * 可以配置默认值，也可以配置为约束，类型参考PropType
+     */
+    propsOption?: Partial<Record<keyof T, PropType | any>>;
+    private [PROPS_DATA_KEY];
+    private [PARSER_TEMPLATE_TARGET]?;
+    private [PROPS_DATA_PROXY]?;
+    private [PRIVATE_WATCHERS];
+    private [EVENT_DATA_KEY];
+    /**
+     * @param propData prop参数
+     * @param sections 渲染部分区域
+     * @param isKeepAlive 是否要保持存活，启用时再destroy时只会销毁UI部分，不会销毁数据，直到使用destroy(true)才会销毁
+     */
+    constructor(propData?: T, $sections?: Record<string, SectionType>, isKeepAlive?: boolean | undefined);
+    /**
+     * 主动声明接受的参数
+     * @returns
+     */
+    get props(): Readonly<Partial<T>>;
+    /**
+     * 挂载
+     * @param root
+     */
+    $mount(root: any | VNode.Component<IComponent>): this;
+    /**
+     * 节点动画，仅支持 element及组件节点
+     */
+    $nodeTransition(nodeOrRef: string | VNode.Node, mode: "enter" | "leave", name?: string, callBack?: Function, type?: "transition" | "animation"): void;
+    /**
+     * 销毁
+     */
+    $destroy(force?: boolean): void;
+    /**
+     * VNode ref索引集
+     */
+    get $refs(): Readonly<Record<string, Array<VNode.Node>>>;
+    /**
+     * 根据ref获取单个VNode
+     */
+    $getRef<T extends VNode.Node>(ref: string): T | undefined;
+    /**
+     * 获取相同ref的VNode集合
+     */
+    $getRefs<T extends VNode.Node>(ref: string): Array<T> | undefined;
+    /**
+     * 单向同步prop值，并监听变更后重新同步
+     * @param propKey 需要观察同步的props key
+     * @param modelKey 要赋值的model key，不传案prop key 进行赋值
+     * @param convertVal 值转换方法
+     */
+    $syncProp(propKey: keyof T): void;
+    $syncProp(propKey: keyof T, modelKey: string): void;
+    $syncProp(propKey: keyof T, convertVal: (val: any) => any): void;
+    $syncProp(propKey: keyof T, modelKey: string, convertVal: (val: any) => any): void;
+    /**
+     * 根节点（虚拟DOM）
+     */
+    get $rootVNode(): Readonly<VNode.Root> | undefined;
+    /**
+     * 添加节点变更监听
+     * @param ref  ref标记
+     * @param callBack
+     * @returns 销毁方法
+     */
+    $watchNode(ref: string, callBack: (node: VNode.Node, type: NodeChangeType, property?: string) => void): (() => void) | undefined;
+    /**
+     * 观察值变更
+     * @param express
+     * @param callBack
+     * @returns 销毁watcher
+     */
+    $watch(express: () => any, callBack: (nv?: any, ov?: any) => void): () => void;
+    /**
+     * 事件注册
+     * @param eventName
+     * @param callBack
+     */
+    $on(eventName: string, callBack: VNode.EventCallBack): void;
+    /**
+     * 事件卸载
+     * @param eventName
+     * @param callBack
+     */
+    $off(eventName: string, callBack?: VNode.EventCallBack): void;
+    /**
+     * 触发事件
+     * @param eventName 事件名称
+     * @param param 参数
+     * @param targetEvent event
+     */
+    $trigger(eventName: string, param?: any, targetEvent?: VNode.Event): void;
+    /**
+     * 主动渲染（仅渲染，一般适用于模板区域的热更新使用/或动态装载等复杂场景）
+     * @param newTemplate 可指定新的模板，否则按照原模板
+     * @param keepalive 渲染新模板时，是否要保留之前的存活组件（高级用法）
+     * @returns
+     */
+    $render(newTemplate?: TemplateType, keepalive?: boolean): void;
+    /**
+     * 生命周期函数（完成初始化）
+     */
+    protected created(): void;
+    /**
+     * 生命周期函数（完成挂载）
+     */
+    protected mounted(): void;
+    /**
+     * 生命周期函数（销毁前）
+     */
+    protected beforeDestroy(): void;
+    /**
+     * 睡眠时，在启用keepalive属性时才会触发该周期
+     */
+    protected sleeped(): void;
+    /**
+     * 唤醒时，在启用keepalive属性时才会触发该周期
+     */
+    protected wakeup(): void;
+    /**
+     * 生命周期函数（销毁后）
+     */
+    protected destroyed(): void;
+}
+/**
+ * 注册全局组件
+ * @param componentsOrName 组件名/列表
+ * @param component 组件
+ */
+export declare function registerGlobalComponent(componentsOrName: Record<string, ComponentConstructor> | string, component?: ComponentConstructor): void;
+/**
+ * 根据注册key获取组件
+ * @param name 组件名称
+ * @returns 组件
+ */
+export declare function getGlobalComponent(key: string): ComponentConstructor | undefined;
+/**
+ * 动态组件容器
+ */
+export declare class ComponentContainer extends Component<{
+    [key: string]: any;
+    name: string;
+    "transition-name": string;
+}> {
+    template: never[];
+    private cache;
+    mounted(): void;
+    private propsVaule;
+    created(): void;
+    loadComponent(componentName?: string): Promise<void>;
+    beforeDestroy(): void;
+    removeCache(componentName?: string): void;
+}
+/**
+ * 虚拟模板容器，用于进行归组，作为组件配置属性
+ */
+export declare class Template extends Component {
+    template: () => AST.Command[];
+}
+export {};

package/types/src/event-bus.d.ts

@@ -0,0 +1,15 @@
+export type EventCallBackItem = {
+    callBack: EventCallBackType;
+    once?: Boolean;
+};
+export type EventCallBackType = (e: {
+    stopPropagation: Function;
+    callTimes: Number;
+}, params?: any) => boolean | void;
+export declare class EventBus<T extends string> {
+    private eventDatas;
+    on(eventName: T, callBack: EventCallBackType): void;
+    once(eventName: T, callBack: EventCallBackType): void;
+    off(eventName: T, callBack?: EventCallBackType): void;
+    trigger(eventName: T, param?: any): false | undefined;
+}

package/types/src/filter.d.ts

@@ -0,0 +1,13 @@
+export type GlobalFilter = (...args: any[]) => string | void | undefined;
+export declare const globalFilters: Record<string, GlobalFilter>;
+/**
+ * 注册全局组件
+ * @param components 组件
+ */
+export declare function registerGlobalFilter(filters: Record<string, GlobalFilter>): void;
+/**
+ * 根据注册key获取组件
+ * @param name 组件名称
+ * @returns 组件
+ */
+export declare function getGlobalFilter(key: string): GlobalFilter | undefined;