@joker.front/core 1.2.137 → 1.2.138

package/README.md

@@ -1,5 +1,7 @@
 # Joker
 
+Joker 是一个框架平台，旨在为所有开发场景提供支持。其中，Joker.front 是 Joker 平台下的前端开发框架，它提供标准化的前端开发标准，使用面向对象、组件化的编程模型，帮助你高效地开发用户界面。无论是简单还是复杂的界面，Joker.front 都可以轻松应对。
+
 ## 什么是 Joker？
 
 Joker 是一个框架平台，旨在为所有开发场景提供支持。其中，Joker.front 是 Joker 平台下的前端开发框架，它提供标准化的前端开发标准，使用面向对象、组件化的编程模型，帮助你高效地开发用户界面。无论是简单还是复杂的界面，Joker.front 都可以轻松应对。
@@ -61,4 +63,4 @@ npm run dev
 
 ## 文档
 
-[官网](www.jokers.pub)
+[官网](http://www.jokers.pub)

package/dist/bundle.es.js

@@ -1562,6 +1562,7 @@ var Render;
                 }
             }
             else if (attrName === "style" && isObject(attrVal)) {
+                el.removeAttribute("style");
                 for (let name in attrVal) {
                     let isEmptyValue = false;
                     if (attrVal[name] === undefined || attrVal[name] === false) {
@@ -1571,14 +1572,8 @@ var Render;
                     if (isEmptyStr(val)) {
                         isEmptyValue = true;
                     }
-                    //空移除属性
-                    if (isEmptyValue) {
-                        el.style.removeProperty(name);
-                        //@ts-ignore
-                        el.style[name] = "";
-                        continue;
-                    }
-                    else {
+                    //非空
+                    if (!isEmptyValue) {
                         //@ts-ignore
                         el.style[name] = val;
                     }

package/dist/bundle.js

@@ -1563,6 +1563,7 @@ var Render;
                 }
             }
             else if (attrName === "style" && isObject(attrVal)) {
+                el.removeAttribute("style");
                 for (let name in attrVal) {
                     let isEmptyValue = false;
                     if (attrVal[name] === undefined || attrVal[name] === false) {
@@ -1572,14 +1573,8 @@ var Render;
                     if (isEmptyStr(val)) {
                         isEmptyValue = true;
                     }
-                    //空移除属性
-                    if (isEmptyValue) {
-                        el.style.removeProperty(name);
-                        //@ts-ignore
-                        el.style[name] = "";
-                        continue;
-                    }
-                    else {
+                    //非空
+                    if (!isEmptyValue) {
                         //@ts-ignore
                         el.style[name] = val;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@joker.front/core",
-    "version": "1.2.137",
+    "version": "1.2.138",
     "description": "",
     "main": "./dist/bundle.js",
     "module": "./dist/bundle.es.js",

package/types/components/component.d.ts

@@ -1,13 +0,0 @@
-import { Component } from "../component";
-export declare class ComponentContainer extends Component {
-    template: never[];
-    propsType: {
-        name: StringConstructor;
-        data: ObjectConstructor;
-    };
-    private cache;
-    mounted(): void;
-    loadComponent(componentName: string): Promise<void>;
-    beforeDestory(): void;
-    removeCache(componentName?: string): void;
-}

package/types/components/container.d.ts

@@ -1,15 +0,0 @@
-import { Component } from "../index";
-/**
- * 动态组件容器
- */
-export declare class ComponentContainer extends Component<{
-    name: string;
-    data: object;
-}> {
-    template: never[];
-    private cache;
-    mounted(): void;
-    loadComponent(componentName?: string): Promise<void>;
-    beforeDestory(): void;
-    removeCache(componentName?: string): void;
-}

package/types/components/template.d.ts

@@ -1,7 +0,0 @@
-import { Component } from "../component";
-/**
- * 虚拟模板容器，用于进行归组，作为组件配置属性
- */
-export declare class Template extends Component {
-    template: () => import("@joker.front/ast").AST.Command[];
-}

package/types/docs/build/docs.d.ts

@@ -1 +0,0 @@
-export {};

package/types/docs/build/markdown-it-demo.d.ts

@@ -1,3 +0,0 @@
-import MarkdownIt from "markdown-it";
-export declare let demoPlugin: MarkdownIt.PluginSimple;
-export declare let divPlugin: MarkdownIt.PluginSimple;

package/types/docs/build/utils.d.ts

@@ -1,3 +0,0 @@
-export declare const isWindows: boolean;
-export declare function normalizePath(strPath: string): string;
-export declare function slash(p: string): string;

package/types/docs/common/loading.d.ts

@@ -1,2 +0,0 @@
-export declare function showLoading(): void;
-export declare function hideLoading(): void;

package/types/docs/main.d.ts

@@ -1 +0,0 @@
-import "@joker.front/ui/index.css";

package/types/eventBus.d.ts

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

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

package/types/src/component.d.ts

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

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

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

package/types/src/hmr.d.ts

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

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

@@ -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);
-    }
-}

package/types/src/props.d.ts

@@ -1,9 +0,0 @@
-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/utils/DI.d.ts

@@ -1,15 +0,0 @@
-type Constructor<T = any> = new (...args: any[]) => T;
-/**
- * IOC依赖注入容器
- *
- * IOC依赖注入适用场景：
- * 内部已规划的API、Interface，需要在外部对其进行逻辑注入的场景
- * 区分于plugin，plugin是根据整体声明周期做的切面注入
- */
-export declare namespace IContainer {
-    function bind<T>(tagId: symbol | string): {
-        to: (target: Constructor<T>) => void;
-    };
-    function get<T>(tagId: symbol | string, ...params: any[]): T | undefined;
-}
-export {};