@dooboostore/dom-render 1.0.98

package/lifecycle/OnCreateRendered.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @deprecated  아직 적용안됨
+ */
+export interface OnCreateRendered {
+    onCreateRendered(...param: any[]): void;
+}
+export declare const isOnCreateRendered: (obj: any) => obj is OnCreateRendered;
+//# sourceMappingURL=OnCreateRendered.d.ts.map

package/lifecycle/OnCreateRendered.js

@@ -0,0 +1,4 @@
+export const isOnCreateRendered = (obj) => {
+    return typeof (obj === null || obj === void 0 ? void 0 : obj.onCreateRendered) === 'function';
+};
+//# sourceMappingURL=OnCreateRendered.js.map

package/lifecycle/OnCreatedThisChild.d.ts

@@ -0,0 +1,6 @@
+import { OnCreateRenderDataParams } from '../lifecycle/OnCreateRenderData';
+export interface OnCreatedThisChild {
+    onCreatedThisChild(child: any, childData: OnCreateRenderDataParams): void;
+}
+export declare const isOnCreatedThisChild: (obj: any) => obj is OnCreatedThisChild;
+//# sourceMappingURL=OnCreatedThisChild.d.ts.map

package/lifecycle/OnCreatedThisChild.js

@@ -0,0 +1,4 @@
+export const isOnCreatedThisChild = (obj) => {
+    return typeof (obj === null || obj === void 0 ? void 0 : obj.onCreatedThisChild) === 'function';
+};
+//# sourceMappingURL=OnCreatedThisChild.js.map

package/lifecycle/OnDestroyRender.d.ts

@@ -0,0 +1,9 @@
+import { RawSet } from '../rawsets/RawSet';
+export type OnDestroyRenderParams = {
+    rawSet: RawSet;
+};
+export interface OnDestroyRender {
+    onDestroyRender(data: OnDestroyRenderParams): void;
+}
+export declare const isOnDestroyRender: (obj: any) => obj is OnDestroyRender;
+//# sourceMappingURL=OnDestroyRender.d.ts.map

package/lifecycle/OnDestroyRender.js

@@ -0,0 +1,4 @@
+export const isOnDestroyRender = (obj) => {
+    return typeof (obj === null || obj === void 0 ? void 0 : obj.onDestroyRender) === 'function';
+};
+//# sourceMappingURL=OnDestroyRender.js.map

package/lifecycle/OnInitRender.d.ts

@@ -0,0 +1,6 @@
+import { RawSet } from '../rawsets/RawSet';
+export interface OnInitRender {
+    onInitRender(param: any, rawSet: RawSet): void;
+}
+export declare function isOnInitRender(obj: any): obj is OnInitRender;
+//# sourceMappingURL=OnInitRender.d.ts.map

package/lifecycle/OnInitRender.js

@@ -0,0 +1,4 @@
+export function isOnInitRender(obj) {
+    return typeof (obj === null || obj === void 0 ? void 0 : obj.onInitRender) === 'function';
+}
+//# sourceMappingURL=OnInitRender.js.map

package/lifecycle/OnProxyDomRender.d.ts

@@ -0,0 +1,5 @@
+import { Config } from '../configs/Config';
+export interface OnProxyDomRender {
+    onProxyDomRender(config: Config): void;
+}
+//# sourceMappingURL=OnProxyDomRender.d.ts.map

package/lifecycle/OnProxyDomRender.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OnProxyDomRender.js.map

package/lifecycle/dr-this/OnDrThisBind.d.ts

@@ -0,0 +1,5 @@
+export interface OnDrThisBind {
+    onDrThisBind(): void;
+}
+export declare const isOnDrThisBind: (obj: any) => obj is OnDrThisBind;
+//# sourceMappingURL=OnDrThisBind.d.ts.map

package/lifecycle/dr-this/OnDrThisBind.js

@@ -0,0 +1,4 @@
+export const isOnDrThisBind = (obj) => {
+    return typeof (obj === null || obj === void 0 ? void 0 : obj.onDrThisBind) === 'function';
+};
+//# sourceMappingURL=OnDrThisBind.js.map

package/lifecycle/dr-this/OnDrThisUnBind.d.ts

@@ -0,0 +1,5 @@
+export interface OnDrThisUnBind {
+    onDrThisUnBind(): void;
+}
+export declare const isOnDrThisUnBind: (obj: any) => obj is OnDrThisUnBind;
+//# sourceMappingURL=OnDrThisUnBind.d.ts.map

package/lifecycle/dr-this/OnDrThisUnBind.js

@@ -0,0 +1,4 @@
+export const isOnDrThisUnBind = (obj) => {
+    return typeof (obj === null || obj === void 0 ? void 0 : obj.onDrThisUnBind) === 'function';
+};
+//# sourceMappingURL=OnDrThisUnBind.js.map

package/managers/RenderManager.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RenderManager.d.ts.map

package/managers/RenderManager.js

@@ -0,0 +1,12 @@
+export {};
+// export class RenderManager {
+//     static render(obj: any, target = Object.keys(obj)) {
+//         const domRenderProxy = obj._DomRender_proxy as DomRenderProxy<any>;
+//         if (domRenderProxy) {
+//             target.forEach(it => {
+//                 domRenderProxy.root([it], obj[it]);
+//             })
+//         }
+//     }
+// }
+//# sourceMappingURL=RenderManager.js.map

package/messenger/DefaultMessenger.d.ts

@@ -0,0 +1,4 @@
+import { Messenger } from './Messenger';
+export declare class DefaultMessenger extends Messenger {
+}
+//# sourceMappingURL=DefaultMessenger.d.ts.map

package/messenger/DefaultMessenger.js

@@ -0,0 +1,4 @@
+import { Messenger } from './Messenger';
+export class DefaultMessenger extends Messenger {
+}
+//# sourceMappingURL=DefaultMessenger.js.map

package/messenger/Messenger.d.ts

@@ -0,0 +1,79 @@
+import { ConstructorType } from '@dooboostore/core/types';
+import { Config } from '../configs/Config';
+declare enum CallBackType {
+    FILTER = 0,
+    MAP = 1,
+    SUBSCRIBE = 2
+}
+export type ChannelData = {
+    channel: Channel;
+    data?: (any | undefined);
+};
+export 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;
+}
+type MessengerEventDetail = {
+    key: string | object | ConstructorType<any>;
+    data?: any;
+    action?: string;
+    result?: (c: ChannelData[]) => void;
+};
+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 {};
+//# sourceMappingURL=Messenger.d.ts.map

package/messenger/Messenger.js

@@ -0,0 +1,185 @@
+import { DomRenderFinalProxy } from '../types/Types';
+var CallBackType;
+(function (CallBackType) {
+    CallBackType[CallBackType["FILTER"] = 0] = "FILTER";
+    CallBackType[CallBackType["MAP"] = 1] = "MAP";
+    CallBackType[CallBackType["SUBSCRIBE"] = 2] = "SUBSCRIBE";
+})(CallBackType || (CallBackType = {}));
+export class ChannelSubscription {
+    constructor(channel, subscriber) {
+        this.channel = channel;
+        this.subscriber = subscriber;
+    }
+    unsubscribe() {
+        this.subscriber.unsubscribe();
+    }
+}
+export class ChannelSubscriber {
+    constructor(channel) {
+        this.channel = channel;
+        this.callbacks = [];
+    }
+    exeCallback(data, metaData) {
+        for (const callback of this.callbacks) {
+            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
+    filter(callback) {
+        this.callbacks.push({ type: CallBackType.FILTER, callback });
+        return this;
+    }
+    map(callback) {
+        this.callbacks.push({ type: CallBackType.MAP, callback });
+        return this;
+    }
+    subscribe(callback) {
+        this.callbacks.push({ type: CallBackType.SUBSCRIBE, callback });
+        this.channel.subscribers.add(this);
+        return new ChannelSubscription(this.channel, this);
+    }
+    unsubscribe() {
+        this.channel.subscribers.delete(this);
+    }
+    deleteSubscriber() {
+        this.unsubscribe();
+        this.channel.subscribers.delete(this);
+    }
+}
+export class Channel {
+    constructor(messenger, obj, key) {
+        this.messenger = messenger;
+        this.obj = obj;
+        this.key = key;
+        this.subscribers = new Set();
+    }
+    publish(key, data, action) {
+        var _a;
+        const rtns = [];
+        (_a = this.messenger.getChannels(key)) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            try {
+                it.subscribers.forEach(its => {
+                    const rdata = its.exeCallback(data, { channel: this, action });
+                    rtns.push({ channel: it, data: rdata });
+                });
+            }
+            catch (e) {
+                console.error(e);
+            }
+        });
+        return rtns;
+    }
+    allPublish(data, action) {
+        const rtns = [];
+        this.messenger.getAllChannelKeys().forEach(it => {
+            rtns.push(this.publish(it, data));
+        });
+        return rtns.flat();
+    }
+    // string point
+    filter(filterF) {
+        const subscriber = new ChannelSubscriber(this);
+        subscriber.filter(filterF);
+        return subscriber;
+    }
+    map(filterF) {
+        const subscriber = new ChannelSubscriber(this);
+        subscriber.map(filterF);
+        return subscriber;
+    }
+    subscribe(subscribeCallback) {
+        const subscriber = new ChannelSubscriber(this);
+        return subscriber.subscribe(subscribeCallback);
+    }
+    ;
+    deleteChannel() {
+        this.messenger.deleteChannel(this);
+    }
+    ;
+}
+export class Messenger {
+    constructor(config) {
+        this.config = config;
+        this.channels = new Set();
+        this.config.window.addEventListener(Messenger.EVENT_PUBLISH_KEY, (e) => {
+            var _a, _b;
+            const detail = e.detail;
+            // console.log('--->', detail)
+            const rtns = [];
+            (_a = this.getChannels(detail.key)) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+                try {
+                    it.subscribers.forEach(its => {
+                        const 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, (e) => {
+            const detail = e.detail;
+            // console.log('--->', detail)
+            const channel = this.createChannel(detail.obj, detail.key);
+            detail.init(channel, channel.subscribe(detail.subscribe));
+        });
+    }
+    static publish(window, detail) {
+        window.dispatchEvent(new CustomEvent(Messenger.EVENT_PUBLISH_KEY, { detail }));
+    }
+    static subscribe(window, detail) {
+        window.dispatchEvent(new CustomEvent(Messenger.EVENT_SUBSCRIBE_KEY, { detail }));
+    }
+    createChannel(obj, key = obj.constructor.name) {
+        const channel = 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;
+    }
+    deleteChannel(channel) {
+        this.channels.delete(channel);
+    }
+    deleteChannelFromObj(obj) {
+        if (obj) {
+            this.channels.forEach(it => {
+                if (it.obj === obj) {
+                    // console.log('dddddddddddd', obj)
+                    this.deleteChannel(it);
+                }
+            });
+        }
+    }
+    addChannel(channel) {
+        this.channels.add(channel);
+    }
+    getChannels(key) {
+        if (typeof key === 'object') {
+            key = key.constructor.name;
+        }
+        else if (typeof key === 'function') {
+            key = key.name;
+        }
+        return Array.from(this.channels.values()).filter(it => it.key === key);
+    }
+    getAllChannels() {
+        return Array.from(this.channels.values());
+    }
+    getAllChannelKeys() {
+        return Array.from(this.channels.values()).map(it => it.key);
+    }
+}
+Messenger.EVENT_PUBLISH_KEY = 'domRenderMessenger_publish';
+Messenger.EVENT_SUBSCRIBE_KEY = 'domRenderMessenger_subscribe';
+//# sourceMappingURL=Messenger.js.map

package/operators/Appender.d.ts

@@ -0,0 +1,15 @@
+export declare class Appender<T = any> implements Iterable<T> {
+    [key: number]: T[] | undefined;
+    length: number;
+    keyMap: Map<string, number>;
+    isAppender: boolean;
+    constructor(...defaultDatas: T[]);
+    [Symbol.iterator](): Iterator<T>;
+    set(key: string, ...v: T[]): void;
+    delete(key: string): void;
+    getAll(): T[];
+    getAlls(): T[][];
+    push(...items: T[]): void;
+    clear(): void;
+}
+//# sourceMappingURL=Appender.d.ts.map

package/operators/Appender.js

@@ -0,0 +1,90 @@
+export class Appender {
+    constructor(...defaultDatas) {
+        this.length = 0;
+        this.keyMap = new Map();
+        this.isAppender = true;
+        // console.log('defaultDatas', defaultDatas);
+        this.push(...defaultDatas);
+        // (this.childs as any).isAppender = true;
+    }
+    [Symbol.iterator]() {
+        const items = this.getAll();
+        let idx = 0;
+        return {
+            next(value) {
+                let r = { value: undefined, done: true };
+                if (items.length > idx) {
+                    r = { value: items[idx], done: false };
+                }
+                idx++;
+                return r;
+            }
+        };
+    }
+    set(key, ...v) {
+        const o = this.keyMap.get(key);
+        // console.log('set!!', o);
+        if (o !== undefined) {
+            this[o] = v;
+        }
+        else {
+            this.keyMap.set(key, this.length);
+            // console.log('setPush', v)
+            this.push(...v);
+        }
+    }
+    delete(key) {
+        const o = this.keyMap.get(key);
+        if (o !== undefined) {
+            this[o] = [];
+            this.keyMap.delete(key);
+            // this.length--;
+        }
+    }
+    getAll() {
+        return this.getAlls().flat();
+    }
+    getAlls() {
+        const map = Array.from({ length: this.length }).filter((it, idx) => this[idx]).map((it, idx) => this[idx]);
+        return map;
+    }
+    push(...items) {
+        // console.log('----1>', items, items.length, this.length);
+        if (items && items.length > 0) {
+            items.index = this.length;
+            this[this.length++] = items;
+            // this[this.length] = [];
+        }
+        // console.log('----2>', items, items.length, this.length);
+        // console.log('---22->', this.length)
+        // const appender = this.childs[this.lastIndex];
+        // appender.values = items;
+        // this.childs.push(new Appender(appender.index + 1));
+    }
+    // delete(idx: number): void {
+    //     // if (idx in this) {
+    //     //     console.log('---------dele',idx)
+    //     //     delete this[idx];
+    //     //     this.length = this.length - 1;
+    //     // }
+    //     this.length = this.length - 1;
+    // }
+    // 인덱스 접근을 위한 getter와 setter 추가
+    // get(index: number): T | undefined {
+    //     return this.storage[index];
+    // }
+    //
+    // set(index: number, value: T): void {
+    //     this.storage[index] = value;
+    //     this.length = Math.max(this.length, index + 1);
+    // }
+    clear() {
+        // console.log('length', this.length);
+        for (let i = 0; i < this.length; i++) {
+            delete this[i];
+        }
+        this.keyMap.clear();
+        this.length = 0;
+    }
+}
+//# sourceMappingURL=Appender.js.map

package/operators/Dr.d.ts

@@ -0,0 +1,9 @@
+import { OperatorExecuterAttrRequire } from './OperatorExecuterAttrRequire';
+import { RawSet } from '../rawsets/RawSet';
+import { Render } from '../rawsets/Render';
+import { AfterCallBack, ElementSource, ExecuteState, ReturnContainer, Source } from './OperatorExecuter';
+export declare class Dr extends OperatorExecuterAttrRequire<null> {
+    constructor(rawSet: RawSet, render: Render, returnContainer: ReturnContainer, elementSource: ElementSource, source: Source, afterCallBack: AfterCallBack);
+    executeAttrRequire(data: null): Promise<ExecuteState>;
+}
+//# sourceMappingURL=Dr.d.ts.map

package/operators/Dr.js

@@ -0,0 +1,53 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { OperatorExecuterAttrRequire } from './OperatorExecuterAttrRequire';
+import { ScriptUtils } from '@dooboostore/core-web/script/ScriptUtils';
+import { RawSet } from '../rawsets/RawSet';
+import { ExecuteState } from './OperatorExecuter';
+export class Dr extends OperatorExecuterAttrRequire {
+    constructor(rawSet, render, returnContainer, elementSource, source, afterCallBack) {
+        super(rawSet, render, returnContainer, elementSource, source, afterCallBack);
+    }
+    executeAttrRequire(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const itRandom = RawSet.drItOtherEncoding(this.elementSource.element);
+            const vars = RawSet.drVarEncoding(this.elementSource.element, (_a = this.elementSource.attrs.drVarOption) !== null && _a !== void 0 ? _a : '');
+            const newTemp = this.source.config.window.document.createElement('temp');
+            ScriptUtils.eval(`
+                    ${this.render.bindScript}
+                    const n = $element.cloneNode(true);
+                    var destIt = ${this.elementSource.attrs.drItOption};
+                    if (destIt !== undefined) {
+                        n.getAttributeNames().forEach(it => n.setAttribute(it, n.getAttribute(it).replace(/\\#it\\#/g, destIt)))
+                        // console.log('----', n.innerHTML);
+                        n.innerHTML = n.innerHTML.replace(/\\#it\\#/g, destIt);
+                        // console.log('----', n.innerHTML);
+                    }
+                    if (this.__render.drStripOption === 'true') {
+                        Array.from(n.childNodes).forEach(it => this.__fag.append(it));
+                    } else {
+                        this.__render.fag.append(n);
+                    }`, Object.assign(this.source.obj, {
+                __render: Object.freeze(Object.assign({ fag: newTemp, drStripOption: this.elementSource.attrs.drStripOption }, this.render))
+            }));
+            RawSet.drVarDecoding(newTemp, vars);
+            RawSet.drItOtherDecoding(newTemp, itRandom);
+            const tempalte = this.source.config.window.document.createElement('template');
+            tempalte.innerHTML = newTemp.innerHTML;
+            this.returnContainer.fag.append(tempalte.content);
+            const rr = RawSet.checkPointCreates(this.returnContainer.fag, this.source.obj, this.source.config);
+            (_b = this.elementSource.element.parentNode) === null || _b === void 0 ? void 0 : _b.replaceChild(this.returnContainer.fag, this.elementSource.element);
+            this.returnContainer.raws.push(...rr);
+            return ExecuteState.EXECUTE;
+        });
+    }
+}
+//# sourceMappingURL=Dr.js.map

package/operators/DrAppender.d.ts

@@ -0,0 +1,9 @@
+import { OperatorExecuterAttrRequire } from './OperatorExecuterAttrRequire';
+import { RawSet } from '../rawsets/RawSet';
+import { Render } from '../rawsets/Render';
+import { AfterCallBack, ElementSource, ExecuteState, ReturnContainer, Source } from './OperatorExecuter';
+export declare class DrAppender extends OperatorExecuterAttrRequire<string> {
+    constructor(rawSet: RawSet, render: Render, returnContainer: ReturnContainer, elementSource: ElementSource, source: Source, afterCallBack: AfterCallBack);
+    executeAttrRequire(attr: string): Promise<ExecuteState>;
+}
+//# sourceMappingURL=DrAppender.d.ts.map

package/operators/DrAppender.js

@@ -0,0 +1,69 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { OperatorExecuterAttrRequire } from './OperatorExecuterAttrRequire';
+import { ScriptUtils } from '@dooboostore/core-web/script/ScriptUtils';
+import { RawSet } from '../rawsets/RawSet';
+import { ExecuteState } from './OperatorExecuter';
+export class DrAppender extends OperatorExecuterAttrRequire {
+    constructor(rawSet, render, returnContainer, elementSource, source, afterCallBack) {
+        source.operatorAround = undefined;
+        super(rawSet, render, returnContainer, elementSource, source, afterCallBack, false);
+    }
+    executeAttrRequire(attr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const itRandom = RawSet.drItOtherEncoding(this.elementSource.element);
+            const vars = RawSet.drVarEncoding(this.elementSource.element, (_a = this.elementSource.attrs.drVarOption) !== null && _a !== void 0 ? _a : '');
+            const newTemp = this.source.config.window.document.createElement('temp');
+            ScriptUtils.eval(`
+                    try{
+                    ${this.render.bindScript}
+                    ${(_b = this.elementSource.attrs.drBeforeOption) !== null && _b !== void 0 ? _b : ''}
+                        const ifWrap = document.createElement('div');
+                        // ifWrap.setAttribute('${RawSet.DR_STRIP_OPTIONNAME}', 'true');
+                        // ifWrap.setAttribute('${RawSet.DR_IF_NAME}', '${this.elementSource.attrs.drAppender} && ${this.elementSource.attrs.drAppender}.length > 0');
+                        const n = this.__render.element.cloneNode(true);
+                        Object.entries(this.__render.drAttr).filter(([k,v]) => k !== 'drAppender' && v).forEach(([k, v]) => n.setAttribute(this.__render.drAttrsOriginName[k], v));
+                        const length = ${this.elementSource.attrs.drAppender}.length;
+                        if (length > 0) {
+                            n.setAttribute('${RawSet.DR_FOR_OF_NAME}', '${this.elementSource.attrs.drAppender}[' + (length-1) + ']');
+                            n.setAttribute('${RawSet.DR_NEXT_OPTIONNAME}', '${this.elementSource.attrs.drAppender},' + length);
+                        } else {
+                            n.setAttribute('${RawSet.DR_FOR_OF_NAME}', '${this.elementSource.attrs.drAppender}[0]');
+                            n.setAttribute('${RawSet.DR_NEXT_OPTIONNAME}', '${this.elementSource.attrs.drAppender},' + 1);
+                        }
+                        // console.log('appender--->', Array.from(n.getAttributeNames()).map(it=>({name:it,attr: n.getAttribute(it)})));
+                        // const drOptionThis = n.getAttribute('${RawSet.DR_THIS_OPTIONNAME}');
+                        // if (drOptionThis) {
+                        // }
+                        // ifWrap.append(n);
+                        // this.__render.fag.append(ifWrap);
+                        this.__render.fag.append(n);
+                    ${(_c = this.elementSource.attrs.drAfterOption) !== null && _c !== void 0 ? _c : ''}
+                    }catch(e){}
+                    `, Object.assign(this.source.obj, {
+                __render: Object.freeze(Object.assign({ drStripOption: this.elementSource.attrs.drStripOption, drAttr: this.elementSource.attrs, drAttrsOriginName: RawSet.drAttrsOriginName, fag: newTemp }, this.render
+                // eslint-disable-next-line no-use-before-define
+                ))
+            }));
+            RawSet.drVarDecoding(newTemp, vars);
+            RawSet.drItOtherDecoding(newTemp, itRandom);
+            const tempalte = this.source.config.window.document.createElement('template');
+            tempalte.innerHTML = newTemp.innerHTML;
+            this.returnContainer.fag.append(tempalte.content);
+            const rr = RawSet.checkPointCreates(this.returnContainer.fag, this.source.obj, this.source.config);
+            (_d = this.elementSource.element.parentNode) === null || _d === void 0 ? void 0 : _d.replaceChild(this.returnContainer.fag, this.elementSource.element);
+            // const rrr = rr.flatMap(it => it.render(obj, config));// .flat();
+            this.returnContainer.raws.push(...rr);
+            return ExecuteState.EXECUTE;
+        });
+    }
+}
+//# sourceMappingURL=DrAppender.js.map

package/operators/DrFor.d.ts

@@ -0,0 +1,9 @@
+import { OperatorExecuterAttrRequire } from './OperatorExecuterAttrRequire';
+import { RawSet } from '../rawsets/RawSet';
+import { Render } from '../rawsets/Render';
+import { AfterCallBack, ElementSource, ExecuteState, ReturnContainer, Source } from './OperatorExecuter';
+export declare class DrFor extends OperatorExecuterAttrRequire<string> {
+    constructor(rawSet: RawSet, render: Render, returnContainer: ReturnContainer, elementSource: ElementSource, source: Source, afterCallBack: AfterCallBack);
+    executeAttrRequire(attr: string): Promise<ExecuteState>;
+}
+//# sourceMappingURL=DrFor.d.ts.map