@joker.front/core 1.2.136

package/types/src/hmr.d.ts

@@ -0,0 +1,15 @@
+import { Component, ComponentConstructor, TemplateType } from "./component";
+/**
+ * 热更新助手（热更新使用）(构建时会按需剔除)
+ */
+export declare let __JOKER_HMR_RUNTIME: {
+    recordRender: (id: string, template: {
+        render: TemplateType;
+    }) => void;
+    recordComponent: (id: string, component: {
+        component: ComponentConstructor;
+    }) => void;
+    record: (id: string, component: Component) => void;
+    reload: (id: string, component: ComponentConstructor) => void;
+    rerender: (id: string, template: TemplateType) => void;
+};

package/types/src/index.d.ts

@@ -0,0 +1,10 @@
+export { AST, RENDER_HANDLER, createCodeFunction, createCommand, createComment, createElement, createFuntionBody, createText, createComponent } from "@joker.front/ast";
+export * from "./component";
+export * from "./parser/vnode";
+export { ParserTemplate, NodeChangeType } from "./parser/index";
+export * from "./observer/watcher";
+export * from "./observer/index";
+export * from "./utils/DI";
+export * from "./hmr";
+export * from "./event-bus";
+export { registerGlobalFilter } from "./filter";

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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,46 @@
+/**
+ * 存放劫持对象的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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -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/src/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 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

@@ -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/src/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;
+}