dom-render 1.0.73 → 1.0.76

package/iterators/Range.d.ts

@@ -1,22 +1,22 @@
-export declare class RangeResult implements IteratorResult<number> {
-    done: boolean;
-    value: number;
-    constructor(value: number | undefined, done: boolean);
-}
-export declare class RangeIterator implements Iterator<number> {
-    private _first;
-    private _current;
-    private _last;
-    private _step;
-    constructor(first: number, last: number, step: number);
-    next(value?: any): IteratorResult<number>;
-}
-export declare class Range implements Iterable<number> {
-    first: number;
-    last: number;
-    step: number;
-    readonly isRange = true;
-    constructor(first: number, last: number, step?: number);
-    [Symbol.iterator](): Iterator<number>;
-    static range(first: number | string, last?: number, step?: number): Range;
-}
+export declare class RangeResult implements IteratorResult<number> {
+    done: boolean;
+    value: number;
+    constructor(value: number | undefined, done: boolean);
+}
+export declare class RangeIterator implements Iterator<number> {
+    private _first;
+    private _current;
+    private _last;
+    private _step;
+    constructor(first: number, last: number, step: number);
+    next(value?: any): IteratorResult<number>;
+}
+export declare class Range implements Iterable<number> {
+    first: number;
+    last: number;
+    step: number;
+    readonly isRange = true;
+    constructor(first: number, last: number, step?: number);
+    [Symbol.iterator](): Iterator<number>;
+    static range(first: number | string, last?: number, step?: number): Range;
+}

package/iterators/Range.js

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Range = exports.RangeIterator = exports.RangeResult = void 0;
-// within rangeResult.ts
-// @ts-ignore
-var RangeResult = /** @class */ (function () {
-    function RangeResult(value, done) {
-        this.done = done;
-        this.value = value !== null && value !== void 0 ? value : 0;
-    }
-    return RangeResult;
-}());
-exports.RangeResult = RangeResult;
-var RangeIterator = /** @class */ (function () {
-    function RangeIterator(first, last, step) {
-        this._current = this._first = first;
-        this._last = last;
-        this._step = step;
-    }
-    RangeIterator.prototype.next = function (value) {
-        var r;
-        if (this._first < this._last && this._current < this._last) {
-            r = new RangeResult(this._current, false);
-            this._current += this._step;
-        }
-        else if (this._first > this._last && this._current > this._last) {
-            r = new RangeResult(this._current, false);
-            this._current -= this._step;
-        }
-        else {
-            r = new RangeResult(undefined, true);
-        }
-        return r;
-    };
-    return RangeIterator;
-}());
-exports.RangeIterator = RangeIterator;
-var Range = /** @class */ (function () {
-    function Range(first, last, step) {
-        if (step === void 0) { step = 1; }
-        this.first = first;
-        this.last = last;
-        this.step = step;
-        this.isRange = true;
-    }
-    Range.prototype[Symbol.iterator] = function () {
-        return new RangeIterator(this.first, this.last, this.step);
-    };
-    Range.range = function (first, last, step) {
-        if (step === void 0) { step = 1; }
-        if (typeof first === 'number' && last === undefined) {
-            return new Range(0, first, step);
-        }
-        else if (typeof first === 'string') {
-            var _a = first.split('..'), _first = _a[0], _b = _a[1], _last = _b === void 0 ? '0' : _b;
-            var _c = _last.split(','), __last = _c[0], _d = _c[1], _step = _d === void 0 ? '1' : _d;
-            return new Range(Number(_first.trim()), Number(__last.trim()), Number(_step.trim()));
-        }
-        else {
-            return new Range(first, last !== null && last !== void 0 ? last : 0, step);
-        }
-    };
-    return Range;
-}());
-exports.Range = Range;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Range = exports.RangeIterator = exports.RangeResult = void 0;
+// within rangeResult.ts
+// @ts-ignore
+var RangeResult = /** @class */ (function () {
+    function RangeResult(value, done) {
+        this.done = done;
+        this.value = value !== null && value !== void 0 ? value : 0;
+    }
+    return RangeResult;
+}());
+exports.RangeResult = RangeResult;
+var RangeIterator = /** @class */ (function () {
+    function RangeIterator(first, last, step) {
+        this._current = this._first = first;
+        this._last = last;
+        this._step = step;
+    }
+    RangeIterator.prototype.next = function (value) {
+        var r;
+        if (this._first < this._last && this._current < this._last) {
+            r = new RangeResult(this._current, false);
+            this._current += this._step;
+        }
+        else if (this._first > this._last && this._current > this._last) {
+            r = new RangeResult(this._current, false);
+            this._current -= this._step;
+        }
+        else {
+            r = new RangeResult(undefined, true);
+        }
+        return r;
+    };
+    return RangeIterator;
+}());
+exports.RangeIterator = RangeIterator;
+var Range = /** @class */ (function () {
+    function Range(first, last, step) {
+        if (step === void 0) { step = 1; }
+        this.first = first;
+        this.last = last;
+        this.step = step;
+        this.isRange = true;
+    }
+    Range.prototype[Symbol.iterator] = function () {
+        return new RangeIterator(this.first, this.last, this.step);
+    };
+    Range.range = function (first, last, step) {
+        if (step === void 0) { step = 1; }
+        if (typeof first === 'number' && last === undefined) {
+            return new Range(0, first, step);
+        }
+        else if (typeof first === 'string') {
+            var _a = first.split('..'), _first = _a[0], _b = _a[1], _last = _b === void 0 ? '0' : _b;
+            var _c = _last.split(','), __last = _c[0], _d = _c[1], _step = _d === void 0 ? '1' : _d;
+            return new Range(Number(_first.trim()), Number(__last.trim()), Number(_step.trim()));
+        }
+        else {
+            return new Range(first, last !== null && last !== void 0 ? last : 0, step);
+        }
+    };
+    return Range;
+}());
+exports.Range = Range;

package/lifecycle/OnBeforeReturnGet.d.ts

@@ -1,3 +1,3 @@
-export interface OnBeforeReturnGet {
-    onBeforeReturnGet(name: string, value: any, fullPath?: string[]): void;
-}
+export interface OnBeforeReturnGet {
+    onBeforeReturnGet(name: string, value: any, fullPath?: string[]): void;
+}

package/lifecycle/OnBeforeReturnGet.js

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

package/lifecycle/OnBeforeReturnSet.d.ts

@@ -1,3 +1,3 @@
-export interface OnBeforeReturnSet {
-    onBeforeReturnSet(name: string, value: any, fullPath?: string[]): void;
-}
+export interface OnBeforeReturnSet {
+    onBeforeReturnSet(name: string, value: any, fullPath?: string[]): void;
+}

package/lifecycle/OnBeforeReturnSet.js

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

package/lifecycle/OnCreateRender.d.ts

@@ -1,3 +1,3 @@
-export interface OnCreateRender {
-    onCreateRender(...param: any[]): void;
-}
+export interface OnCreateRender {
+    onCreateRender(...param: any[]): void;
+}

package/lifecycle/OnCreateRender.js

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

package/lifecycle/OnDestroyRender.d.ts

@@ -0,0 +1,4 @@
+import { CreatorMetaData } from '../RawSet';
+export interface OnDestroyRender {
+    onDestroyRender(metaData?: CreatorMetaData): void;
+}

package/lifecycle/OnDestroyRender.js

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

package/lifecycle/OnInitRender.d.ts

@@ -1,7 +1,7 @@
-import { CreatorMetaData, Render } from '../RawSet';
-export interface OnInitRender {
-    onInitRender(data?: {
-        render?: Render;
-        creatorMetaData?: CreatorMetaData;
-    }): void;
-}
+import { CreatorMetaData, Render } from '../RawSet';
+export interface OnInitRender {
+    onInitRender(data?: {
+        render?: Render;
+        creatorMetaData?: CreatorMetaData;
+    }): void;
+}

package/lifecycle/OnInitRender.js

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

package/lifecycle/OnProxyDomRender.d.ts

@@ -0,0 +1,4 @@
+import { Config } from '../Config';
+export interface OnProxyDomRender {
+    onProxyDomRender(config: Config): void;
+}

package/lifecycle/OnProxyDomRender.js

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

package/managers/RenderManager.d.ts

@@ -1,3 +1,3 @@
-export declare class RenderManager {
-    static render(obj: any, target?: string[]): void;
-}
+export declare class RenderManager {
+    static render(obj: any, target?: string[]): void;
+}

package/managers/RenderManager.js

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderManager = void 0;
-var RenderManager = /** @class */ (function () {
-    function RenderManager() {
-    }
-    RenderManager.render = function (obj, target) {
-        if (target === void 0) { target = Object.keys(obj); }
-        var domRenderProxy = obj._DomRender_proxy;
-        if (domRenderProxy) {
-            target.forEach(function (it) {
-                domRenderProxy.root([it], obj[it]);
-            });
-        }
-    };
-    return RenderManager;
-}());
-exports.RenderManager = RenderManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderManager = void 0;
+var RenderManager = /** @class */ (function () {
+    function RenderManager() {
+    }
+    RenderManager.render = function (obj, target) {
+        if (target === void 0) { target = Object.keys(obj); }
+        var domRenderProxy = obj._DomRender_proxy;
+        if (domRenderProxy) {
+            target.forEach(function (it) {
+                domRenderProxy.root([it], obj[it]);
+            });
+        }
+    };
+    return RenderManager;
+}());
+exports.RenderManager = RenderManager;

package/messenger/DefaultMessenger.d.ts

@@ -0,0 +1,3 @@
+import { Messenger } from './Messenger';
+export declare class DefaultMessenger extends Messenger {
+}

package/messenger/DefaultMessenger.js

@@ -0,0 +1,27 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMessenger = void 0;
+var Messenger_1 = require("./Messenger");
+var DefaultMessenger = /** @class */ (function (_super) {
+    __extends(DefaultMessenger, _super);
+    function DefaultMessenger() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return DefaultMessenger;
+}(Messenger_1.Messenger));
+exports.DefaultMessenger = DefaultMessenger;

package/messenger/Messenger.d.ts

@@ -0,0 +1,78 @@
+import { ConstructorType } from '../types/Types';
+import { Config } from '../Config';
+declare enum CallBackType {
+    FILTER = 0,
+    MAP = 1,
+    SUBSCRIBE = 2
+}
+export declare type ChannelData = {
+    channel: Channel;
+    data?: (any | undefined);
+};
+export declare type ChannelMetaData = {
+    channel?: Channel;
+    action?: string;
+};
+export declare class ChannelSubscription {
+    channel: Channel;
+    subscriber: ChannelSubscriber;
+    constructor(channel: Channel, subscriber: ChannelSubscriber);
+    unsubscribe(): void;
+}
+export declare class ChannelSubscriber<SD = any> {
+    channel: Channel;
+    parentSubscriber?: ChannelSubscriber;
+    callbacks: ({
+        type: CallBackType;
+        callback: (data: any, metaData: ChannelMetaData) => any | undefined;
+    })[];
+    constructor(channel: Channel);
+    exeCallback(data: any, metaData: ChannelMetaData): any;
+    filter<D = SD>(callback: (data: D, meta: ChannelMetaData) => boolean): ChannelSubscriber<SD>;
+    map<D = SD, R = any>(callback: (data: D, meta: ChannelMetaData) => R): ChannelSubscriber<R>;
+    subscribe(callback: (data: SD, metaData: ChannelMetaData) => any | undefined): ChannelSubscription;
+    unsubscribe(): void;
+    deleteSubscriber(): void;
+}
+export declare class Channel {
+    private messenger;
+    obj: object;
+    key: string;
+    subscribers: Set<ChannelSubscriber<any>>;
+    constructor(messenger: Messenger, obj: object, key: string);
+    publish(key: string | object | ConstructorType<any>, data: any, action?: string): ChannelData[];
+    allPublish(data: any, action: string): any[];
+    filter<D = any>(filterF: (data: D, meta: ChannelMetaData) => boolean): ChannelSubscriber<D>;
+    map<D = any, R = any>(filterF: (data: D, meta: ChannelMetaData) => R): ChannelSubscriber<R>;
+    subscribe<D = any>(subscribeCallback: (data: D, meta: ChannelMetaData) => any | void | undefined): ChannelSubscription;
+    deleteChannel(): void;
+}
+declare type MessengerEventDetail = {
+    key: string | object | ConstructorType<any>;
+    data?: any;
+    action?: string;
+    result?: (c: ChannelData[]) => void;
+};
+declare type MessengerSubscribeEventDetail = {
+    obj: any;
+    key?: string | object | ConstructorType<any>;
+    init: (channel: Channel, subscription: ChannelSubscription) => void;
+    subscribe: (data: any, meta: ChannelMetaData) => void;
+};
+export declare abstract class Messenger {
+    private config;
+    private channels;
+    static readonly EVENT_PUBLISH_KEY = "domRenderMessenger_publish";
+    static readonly EVENT_SUBSCRIBE_KEY = "domRenderMessenger_subscribe";
+    constructor(config: Config);
+    static publish(window: Window, detail: MessengerEventDetail): void;
+    static subscribe(window: Window, detail: MessengerSubscribeEventDetail): void;
+    createChannel(obj: any, key?: any): Channel;
+    deleteChannel(channel: Channel): void;
+    deleteChannelFromObj(obj: any): void;
+    addChannel(channel: Channel): void;
+    getChannels(key: string | object | ConstructorType<any>): Channel[];
+    getAllChannels(): Channel[];
+    getAllChannelKeys(): string[];
+}
+export {};

package/messenger/Messenger.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messenger = exports.Channel = exports.ChannelSubscriber = exports.ChannelSubscription = void 0;
+var Types_1 = require("../types/Types");
+var CallBackType;
+(function (CallBackType) {
+    CallBackType[CallBackType["FILTER"] = 0] = "FILTER";
+    CallBackType[CallBackType["MAP"] = 1] = "MAP";
+    CallBackType[CallBackType["SUBSCRIBE"] = 2] = "SUBSCRIBE";
+})(CallBackType || (CallBackType = {}));
+var ChannelSubscription = /** @class */ (function () {
+    function ChannelSubscription(channel, subscriber) {
+        this.channel = channel;
+        this.subscriber = subscriber;
+    }
+    ChannelSubscription.prototype.unsubscribe = function () {
+        this.subscriber.unsubscribe();
+    };
+    return ChannelSubscription;
+}());
+exports.ChannelSubscription = ChannelSubscription;
+var ChannelSubscriber = /** @class */ (function () {
+    function ChannelSubscriber(channel) {
+        this.channel = channel;
+        this.callbacks = [];
+    }
+    ChannelSubscriber.prototype.exeCallback = function (data, metaData) {
+        for (var _i = 0, _a = this.callbacks; _i < _a.length; _i++) {
+            var callback = _a[_i];
+            if (callback.type === CallBackType.FILTER && !callback.callback(data, metaData)) {
+                break;
+            }
+            else if (callback.type === CallBackType.MAP) {
+                data = callback.callback(data, metaData);
+            }
+            else if (callback.type === CallBackType.SUBSCRIBE) {
+                data = callback.callback(data, metaData);
+                break;
+            }
+        }
+        return data;
+    };
+    // chaining point
+    ChannelSubscriber.prototype.filter = function (callback) {
+        this.callbacks.push({ type: CallBackType.FILTER, callback: callback });
+        return this;
+    };
+    ChannelSubscriber.prototype.map = function (callback) {
+        this.callbacks.push({ type: CallBackType.MAP, callback: callback });
+        return this;
+    };
+    ChannelSubscriber.prototype.subscribe = function (callback) {
+        this.callbacks.push({ type: CallBackType.SUBSCRIBE, callback: callback });
+        this.channel.subscribers.add(this);
+        return new ChannelSubscription(this.channel, this);
+    };
+    ChannelSubscriber.prototype.unsubscribe = function () {
+        this.channel.subscribers.delete(this);
+    };
+    ChannelSubscriber.prototype.deleteSubscriber = function () {
+        this.unsubscribe();
+        this.channel.subscribers.delete(this);
+    };
+    return ChannelSubscriber;
+}());
+exports.ChannelSubscriber = ChannelSubscriber;
+var Channel = /** @class */ (function () {
+    function Channel(messenger, obj, key) {
+        this.messenger = messenger;
+        this.obj = obj;
+        this.key = key;
+        this.subscribers = new Set();
+    }
+    Channel.prototype.publish = function (key, data, action) {
+        var _this = this;
+        var _a;
+        var rtns = [];
+        (_a = this.messenger.getChannels(key)) === null || _a === void 0 ? void 0 : _a.forEach(function (it) {
+            try {
+                it.subscribers.forEach(function (its) {
+                    var rdata = its.exeCallback(data, { channel: _this, action: action });
+                    rtns.push({ channel: it, data: rdata });
+                });
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+        return rtns;
+    };
+    Channel.prototype.allPublish = function (data, action) {
+        var _this = this;
+        var rtns = [];
+        this.messenger.getAllChannelKeys().forEach(function (it) {
+            rtns.push(_this.publish(it, data));
+        });
+        return rtns.flat();
+    };
+    // string point
+    Channel.prototype.filter = function (filterF) {
+        var subscriber = new ChannelSubscriber(this);
+        subscriber.filter(filterF);
+        return subscriber;
+    };
+    Channel.prototype.map = function (filterF) {
+        var subscriber = new ChannelSubscriber(this);
+        subscriber.map(filterF);
+        return subscriber;
+    };
+    Channel.prototype.subscribe = function (subscribeCallback) {
+        var subscriber = new ChannelSubscriber(this);
+        return subscriber.subscribe(subscribeCallback);
+    };
+    ;
+    Channel.prototype.deleteChannel = function () {
+        this.messenger.deleteChannel(this);
+    };
+    ;
+    return Channel;
+}());
+exports.Channel = Channel;
+var Messenger = /** @class */ (function () {
+    function Messenger(config) {
+        var _this = this;
+        this.config = config;
+        this.channels = new Set();
+        this.config.window.addEventListener(Messenger.EVENT_PUBLISH_KEY, function (e) {
+            var _a, _b;
+            var detail = e.detail;
+            console.log('--->', detail);
+            var rtns = [];
+            (_a = _this.getChannels(detail.key)) === null || _a === void 0 ? void 0 : _a.forEach(function (it) {
+                try {
+                    it.subscribers.forEach(function (its) {
+                        var rdata = its.exeCallback(detail.data, { action: detail.action });
+                        rtns.push({ channel: it, data: rdata });
+                    });
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            });
+            (_b = detail.result) === null || _b === void 0 ? void 0 : _b.call(detail, rtns);
+        });
+        this.config.window.addEventListener(Messenger.EVENT_SUBSCRIBE_KEY, function (e) {
+            var detail = e.detail;
+            console.log('--->', detail);
+            var channel = _this.createChannel(detail.obj, detail.key);
+            detail.init(channel, channel.subscribe(detail.subscribe));
+        });
+    }
+    Messenger.publish = function (window, detail) {
+        window.dispatchEvent(new CustomEvent(Messenger.EVENT_PUBLISH_KEY, { detail: detail }));
+    };
+    Messenger.subscribe = function (window, detail) {
+        window.dispatchEvent(new CustomEvent(Messenger.EVENT_SUBSCRIBE_KEY, { detail: detail }));
+    };
+    Messenger.prototype.createChannel = function (obj, key) {
+        if (key === void 0) { key = obj.constructor.name; }
+        var channel = Types_1.DomRenderFinalProxy.final(new Channel(this, obj, key));
+        this.channels.add(channel);
+        // this.channels.get(key) ? this.channels.get(key)!.push(channel) : this.channels.set(key, [channel]);
+        return channel;
+    };
+    Messenger.prototype.deleteChannel = function (channel) {
+        this.channels.delete(channel);
+    };
+    Messenger.prototype.deleteChannelFromObj = function (obj) {
+        var _this = this;
+        if (obj) {
+            this.channels.forEach(function (it) {
+                if (it.obj === obj) {
+                    console.log('dddddddddddd', obj);
+                    _this.deleteChannel(it);
+                }
+            });
+        }
+    };
+    Messenger.prototype.addChannel = function (channel) {
+        this.channels.add(channel);
+    };
+    Messenger.prototype.getChannels = function (key) {
+        if (typeof key === 'object') {
+            key = key.constructor.name;
+        }
+        else if (typeof key === 'function') {
+            key = key.name;
+        }
+        return Array.from(this.channels.values()).filter(function (it) { return it.key === key; });
+    };
+    Messenger.prototype.getAllChannels = function () {
+        return Array.from(this.channels.values());
+    };
+    Messenger.prototype.getAllChannelKeys = function () {
+        return Array.from(this.channels.values()).map(function (it) { return it.key; });
+    };
+    Messenger.EVENT_PUBLISH_KEY = 'domRenderMessenger_publish';
+    Messenger.EVENT_SUBSCRIBE_KEY = 'domRenderMessenger_subscribe';
+    return Messenger;
+}());
+exports.Messenger = Messenger;

package/operators/Appender.d.ts

@@ -1,12 +1,7 @@
-export declare class Appender {
-    index: number;
-    values?: any[];
-    constructor(index: number);
-}
-export declare class AppenderContainer {
-    [key: number]: any[] | undefined;
-    length: number;
-    constructor();
-    push(...items: any[]): void;
-    clear(): void;
-}
+export declare class Appender {
+    [key: number]: any[] | undefined;
+    length: number;
+    constructor();
+    push(...items: any[]): void;
+    clear(): void;
+}