dom-render 1.0.71 → 1.0.74

package/Config.d.ts

@@ -1,33 +1,36 @@
-import { ConstructorType } from './types/Types';
-import { CreatorMetaData, RawSet, Render } from './RawSet';
-export declare type TargetElement = {
-    name: string;
-    template?: string;
-    styles?: string[];
-    callBack: (target: Element, obj: any, rawSet: RawSet) => DocumentFragment;
-    complete?: (target: Element, obj: any, rawSet: RawSet) => void;
-    __render?: Render;
-    __creatorMetaData?: CreatorMetaData;
-};
-export declare type TargetAttr = {
-    name: string;
-    callBack: (target: Element, attrValue: string, obj: any, rawSet: RawSet) => DocumentFragment;
-    complete?: (target: Element, attrValue: string, obj: any, rawSet: RawSet) => void;
-};
-export interface Config {
-    window: Window;
-    targetElements?: TargetElement[];
-    targetAttrs?: TargetAttr[];
-    onElementInit?: (name: string, obj: any, rawSet: RawSet, targetElement: TargetElement) => any;
-    onAttrInit?: (name: string, attrValue: string, obj: any, rawSet: RawSet) => any;
-    proxyExcludeTyps?: ConstructorType<any>[];
-    proxyExcludeOnBeforeReturnSets?: string[];
-    proxyExcludeOnBeforeReturnGets?: string[];
-    scripts?: {
-        [n: string]: any;
-    };
-    applyEvents?: {
-        attrName: string;
-        callBack: (elements: Element, attrValue: string, obj: any) => void;
-    }[];
-}
+import { ConstructorType } from './types/Types';
+import { CreatorMetaData, RawSet, Render } from './RawSet';
+import { Router } from './routers/Router';
+export declare type TargetElement = {
+    name: string;
+    template?: string;
+    styles?: string[];
+    callBack: (target: Element, obj: any, rawSet: RawSet) => DocumentFragment;
+    complete?: (target: Element, obj: any, rawSet: RawSet) => void;
+    __render?: Render;
+    __creatorMetaData?: CreatorMetaData;
+};
+export declare type TargetAttr = {
+    name: string;
+    callBack: (target: Element, attrValue: string, obj: any, rawSet: RawSet) => DocumentFragment;
+    complete?: (target: Element, attrValue: string, obj: any, rawSet: RawSet) => void;
+};
+export declare type Config = {
+    window: Window;
+    targetElements?: TargetElement[];
+    targetAttrs?: TargetAttr[];
+    onElementInit?: (name: string, obj: any, rawSet: RawSet, targetElement: TargetElement) => any;
+    onAttrInit?: (name: string, attrValue: string, obj: any, rawSet: RawSet) => any;
+    proxyExcludeTyps?: ConstructorType<any>[];
+    proxyExcludeOnBeforeReturnSets?: string[];
+    proxyExcludeOnBeforeReturnGets?: string[];
+    scripts?: {
+        [n: string]: any;
+    };
+    routerType?: 'hash' | 'path' | 'none';
+    router?: Router;
+    applyEvents?: {
+        attrName: string;
+        callBack: (elements: Element, attrValue: string, obj: any) => void;
+    }[];
+};

package/Config.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/DomRender.d.ts

@@ -1,4 +1,27 @@
-import { Config } from './Config';
-export declare class DomRender {
-    static run<T extends object>(obj: T, target?: Node, config?: Config): T;
-}
+import { Config } from './Config';
+import { ConstructorType } from './types/Types';
+import { RawSet } from './RawSet';
+export declare class DomRender {
+    static run<T extends object>(obj: T, target?: Node, config?: Config): T;
+    static addComponent(config: Config, { type, tagName }: {
+        type: ConstructorType<any>;
+        tagName?: string;
+    }, { template, styles }: {
+        template: string;
+        styles?: string[];
+    }): {
+        add: (source: {
+            type: ConstructorType<any>;
+            tagName?: string;
+        }, front: {
+            template: string;
+            styles?: string[];
+        }) => any;
+    };
+    static addAttribute(config: Config, attrName: string, getThisObj: (element: Element, attrValue: string, obj: any, rawSet: RawSet) => any, factory: (element: Element, attrValue: string, obj: any, rawSet: RawSet) => DocumentFragment): {
+        add: (attrName: string, getThisObj: (element: Element, attrValue: string, obj: any, rawSet: RawSet) => any, factory: (element: Element, attrValue: string, obj: any, rawSet: RawSet) => DocumentFragment) => any;
+    };
+    static addAttributeCallBack(config: Config, attrName: string, callBack: (elements: Element, attrValue: string, obj: any) => void): {
+        add: (attrName: string, callBack: (elements: Element, attrValue: string, obj: any) => void) => any;
+    };
+}

package/DomRender.js

@@ -1,29 +1,88 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DomRender = void 0;
-var DomRenderProxy_1 = require("./DomRenderProxy");
-var DomRender = /** @class */ (function () {
-    function DomRender() {
-    }
-    DomRender.run = function (obj, target, config) {
-        var robj = obj;
-        if ('_DomRender_isProxy' in obj) {
-            if (target) {
-                obj._DomRender_proxy.initRender(target);
-            }
-            robj = obj;
-            return robj;
-        }
-        if (!config) {
-            config = { window: window };
-        }
-        var domRender = new DomRenderProxy_1.DomRenderProxy(obj, target, config);
-        var dest = new Proxy(obj, domRender);
-        robj = dest;
-        domRender.run(robj);
-        return robj;
-    };
-    return DomRender;
-}());
-exports.DomRender = DomRender;
-// export default DomRender;
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomRender = void 0;
+var DomRenderProxy_1 = require("./DomRenderProxy");
+var PathRouter_1 = require("./routers/PathRouter");
+var HashRouter_1 = require("./routers/HashRouter");
+var RawSet_1 = require("./RawSet");
+var DomRender = /** @class */ (function () {
+    function DomRender() {
+    }
+    DomRender.run = function (obj, target, config) {
+        var _a, _b;
+        var robj = obj;
+        if ('_DomRender_isProxy' in obj) {
+            if (target) {
+                obj._DomRender_proxy.initRender(target);
+            }
+            robj = obj;
+            return robj;
+        }
+        if (!config) {
+            config = { window: window };
+        }
+        config.routerType = config.routerType || 'none';
+        var domRender = new DomRenderProxy_1.DomRenderProxy(obj, target, config);
+        var dest = new Proxy(obj, domRender);
+        robj = dest;
+        if (config.routerType === 'path') {
+            config.router = (_a = config.router) !== null && _a !== void 0 ? _a : new PathRouter_1.PathRouter(robj, config.window);
+        }
+        else if (config.routerType === 'hash') {
+            config.router = (_b = config.router) !== null && _b !== void 0 ? _b : new HashRouter_1.HashRouter(robj, config.window);
+        }
+        domRender.run(robj);
+        return robj;
+    };
+    DomRender.addComponent = function (config, _a, _b) {
+        var _c;
+        var type = _a.type, _d = _a.tagName, tagName = _d === void 0 ? type.name : _d;
+        var template = _b.template, _e = _b.styles, styles = _e === void 0 ? [] : _e;
+        var component = RawSet_1.RawSet.createComponentTargetElement(tagName, function (e, o, r2, counstructorParam) {
+            // console.log('------->',counstructorParam)
+            return new (type.bind.apply(type, __spreadArray([void 0], counstructorParam, false)))();
+        }, template, styles, config);
+        config.targetElements = (_c = config.targetElements) !== null && _c !== void 0 ? _c : [];
+        config.targetElements.push(component);
+        return {
+            add: function (source, front) {
+                return DomRender.addComponent(config, source, front);
+            }
+        };
+    };
+    DomRender.addAttribute = function (config, attrName, getThisObj, factory) {
+        var _a;
+        var targetAttribute = RawSet_1.RawSet.createComponentTargetAttribute(attrName, getThisObj, factory);
+        config.targetAttrs = (_a = config.targetAttrs) !== null && _a !== void 0 ? _a : [];
+        config.targetAttrs.push(targetAttribute);
+        return {
+            add: function (attrName, getThisObj, factory) {
+                return DomRender.addAttribute(config, attrName, getThisObj, factory);
+            }
+        };
+    };
+    DomRender.addAttributeCallBack = function (config, attrName, callBack) {
+        var _a;
+        config.applyEvents = (_a = config.applyEvents) !== null && _a !== void 0 ? _a : [];
+        config.applyEvents.push({
+            attrName: attrName,
+            callBack: callBack
+        });
+        return {
+            add: function (attrName, callBack) {
+                return DomRender.addAttributeCallBack(config, attrName, callBack);
+            }
+        };
+    };
+    return DomRender;
+}());
+exports.DomRender = DomRender;

package/DomRenderProxy.d.ts

@@ -1,29 +1,29 @@
-import { RawSet } from './RawSet';
-import { Config } from './Config';
-export declare class DomRenderProxy<T extends object> implements ProxyHandler<T> {
-    _domRender_origin: T;
-    private config;
-    _domRender_ref: Map<object, Set<string>>;
-    _rawSets: Map<string, Set<RawSet>>;
-    _domRender_proxy?: T;
-    _targets: Set<Node>;
-    constructor(_domRender_origin: T, target: Node | undefined, config: Config);
-    static unFinal<T = any>(obj: T): T;
-    static final<T = any>(obj: T): T;
-    static isFinal<T = any>(obj: T): boolean;
-    run(objProxy: T): void;
-    initRender(target: Node): void;
-    getRawSets(): RawSet[];
-    render(raws?: RawSet[]): void;
-    root(paths: string[], value?: any, lastDoneExecute?: boolean): string[];
-    set(target: T, p: string | symbol, value: any, receiver: T): boolean;
-    get(target: T, p: string | symbol, receiver: any): any;
-    has(target: T, p: string | symbol): boolean;
-    proxy(parentProxy: T, obj: T | any, p: string): any;
-    addRef(parent: object, path: string): void;
-    addRawSetAndRender(path: string, rawSet: RawSet): void;
-    addRawSet(path: string, rawSet: RawSet): void;
-    removeRawSet(...raws: RawSet[]): void;
-    private targetGarbageRawSet;
-    private garbageRawSet;
-}
+import { RawSet } from './RawSet';
+import { Config } from './Config';
+export declare class DomRenderProxy<T extends object> implements ProxyHandler<T> {
+    _domRender_origin: T;
+    config: Config;
+    _domRender_ref: Map<object, Set<string>>;
+    _rawSets: Map<string, Set<RawSet>>;
+    _domRender_proxy?: T;
+    _targets: Set<Node>;
+    constructor(_domRender_origin: T, target: Node | undefined, config: Config);
+    static unFinal<T = any>(obj: T): T;
+    static final<T = any>(obj: T): T;
+    static isFinal<T = any>(obj: T): boolean;
+    run(objProxy: T): void;
+    initRender(target: Node): void;
+    getRawSets(): RawSet[];
+    render(raws?: RawSet[] | string): void;
+    root(paths: string[], value?: any, lastDoneExecute?: boolean): string[];
+    set(target: T, p: string | symbol, value: any, receiver: T): boolean;
+    get(target: T, p: string | symbol, receiver: any): any;
+    has(target: T, p: string | symbol): boolean;
+    proxy(parentProxy: T, obj: T | any, p: string): any;
+    addRef(parent: object, path: string): void;
+    addRawSetAndRender(path: string, rawSet: RawSet): void;
+    addRawSet(path: string, rawSet: RawSet): void;
+    removeRawSet(...raws: RawSet[]): void;
+    private targetGarbageRawSet;
+    private garbageRawSet;
+}