@dooboostore/dom-render 1.0.107 → 1.0.109

package/src/operators/DrTargetElement.ts

@@ -0,0 +1,133 @@
+import { ScriptUtils } from '@dooboostore/core-web/script/ScriptUtils';
+import { RawSet } from '../rawsets/RawSet';
+import { CreatorMetaData } from '../rawsets/CreatorMetaData';
+import {
+  AfterCallBack,
+  ElementSource,
+  ExecuteState,
+  OperatorExecuter,
+  ReturnContainer,
+  Source
+} from './OperatorExecuter';
+import { Render } from '../rawsets/Render';
+import { ElementUtils } from '@dooboostore/core-web/element/ElementUtils';
+
+declare global {
+  interface Window {
+    HTMLMetaElement: typeof HTMLMetaElement;
+  }
+}
+
+// 여기서 사용자가 등록한 TargetElement가 들어간다.
+export class DrTargetElement extends OperatorExecuter<void> {
+  constructor(
+    rawSet: RawSet,
+    render: Render,
+    returnContainer: ReturnContainer,
+    elementSource: ElementSource,
+    source: Source,
+    afterCallBack: AfterCallBack
+  ) {
+    source.operatorAround = undefined;
+    super(rawSet, render, returnContainer, elementSource, source, afterCallBack, false);
+  }
+
+  async execute(): Promise<ExecuteState> {
+    const targetElement = this.source.config?.targetElements?.find(
+      it => it.name.toLowerCase() === this.elementSource.element.tagName.toLowerCase()
+    );
+    if (targetElement) {
+      if (
+        this.rawSet.point.start instanceof this.source.config.window.HTMLMetaElement &&
+        this.rawSet.point.end instanceof this.source.config.window.HTMLMetaElement
+      ) {
+        this.rawSet.point.start.setAttribute('this-path', `this.__domrender_components.${this.rawSet.uuid}`);
+        this.rawSet.point.end.setAttribute('this-path', `this.__domrender_components.${this.rawSet.uuid}`);
+      }
+
+      const documentFragment = await targetElement.callBack(
+        this.elementSource.element,
+        this.source.obj,
+        this.rawSet,
+        this.elementSource.attrs,
+        this.source.config
+      );
+      if (documentFragment) {
+        const detectAction = this.elementSource.element.getAttribute(RawSet.DR_DETECT_NAME);
+        // const dictionaryKey = this.elementSource.element.getAttribute(RawSet.DR_DICTIONARY_OPTIONKEYNAME);
+        // console.log('dictionaryKey', dictionaryKey);
+        // const render = (documentFragment as any).render;
+        this.rawSet.dataSet.fragment = documentFragment;
+        // if (documentFragment) {
+        //     const tempDiv = this.source.config.window.document.createElement('div');
+        //     tempDiv.appendChild(documentFragment.cloneNode(true));
+        //     console.log('DocumentFragment innerHTML:', tempDiv.innerHTML);
+        // }
+
+        // this.rawSet.dataSet??={};
+        // this.rawSet.dataSet.data = render.component;
+        if (detectAction && this.rawSet.dataSet.render) {
+          // TODO: 없어져야될듯?
+          this.rawSet.detect = {
+            action: () => {
+              const script = `var $component = this.__render.component; var $element = this.__render.element; var $innerHTML = this.__render.innerHTML; var $attribute = this.__render.attribute;  ${detectAction} `;
+              ScriptUtils.evaluate(
+                script,
+                Object.assign(this.source.obj, {
+                  __render: this.rawSet.dataSet.render
+                })
+              );
+            }
+          };
+        }
+        // fag.append(documentFragment)
+
+        // console.log('----------1', ElementUtils.toInnerHTML(documentFragment, {document: this.source.config.window.document}));
+        // await Promises.sleep(1000)
+        let targetFragment = documentFragment;
+        if (targetElement.noStrip) {
+          // documentFragment.firstElementChild.classList.add(`${this.rawSet.uuid}___DrTargetElement`)
+          const fragment = this.source.config.window.document.createDocumentFragment();
+          Array.from(documentFragment.firstElementChild?.childNodes || []).forEach(child => {
+            // fragment.appendChild(child.cloneNode(true));
+            fragment.appendChild(child);
+          });
+          // fragment.append(documentFragment.firstElementChild);
+          targetFragment = fragment;
+        }
+        // console.log('----------2', ElementUtils.toInnerHTML(targetFragment, {document: this.source.config.window.document}));
+        const rr = RawSet.checkPointCreates(targetFragment, this.source.obj, this.source.config);
+        rr.forEach((it, index) => {
+
+          // const z = ElementUtils.toInnerHTML(it.dataSet.fragment, {document: this.source.config.window.document});
+          // console.log('-z--z('+index+')', z, it);
+          // it.point.start;
+          // // 새로운 comment element 추가
+          // const comment = this.source.config.window.document.createComment('새로 만든 comment element');
+          // it.point.start.parentNode?.insertBefore(comment, it.point.start.nextSibling);
+        })
+        // for (let rawSet of rr) {
+        //   await rawSet.render(this.source.obj, this.source.config)
+        // }
+        // console.log('cccccccccccccccccccccc', rr, typeof Window);
+        if (targetElement.noStrip) {
+          Array.from(targetFragment.childNodes || []).forEach(child => {
+            documentFragment.firstElementChild?.appendChild(child);
+          });
+        }
+        this.elementSource.element.parentNode?.replaceChild(documentFragment, this.elementSource.element);
+        this.returnContainer.raws.push(...rr);
+        this.afterCallBack.onElementInitCallBacks.push({
+          name: targetElement.name.toLowerCase(),
+          obj: this.source.obj,
+          targetElement,
+          creatorMetaData: targetElement.__creatorMetaData as CreatorMetaData
+        });
+        // console.log('sssssssssssssss', this.source.obj);
+        targetElement?.complete?.(this.elementSource.element, this.source.obj, this.rawSet);
+      }
+      return ExecuteState.EXECUTE;
+    }
+    return ExecuteState.NO_EXECUTE;
+  }
+}

package/src/operators/DrTargetElementIsElement.ts

@@ -0,0 +1,76 @@
+import { RawSet } from '../rawsets/RawSet';
+import { CreatorMetaData } from '../rawsets/CreatorMetaData';
+import { AfterCallBack, ElementSource, ExecuteState, OperatorExecuter, ReturnContainer, Source } from './OperatorExecuter';
+import { Render } from '../rawsets/Render';
+import { ScriptUtils } from '@dooboostore/core-web/script/ScriptUtils';
+
+
+// 여기서 사용자가 등록한 TargetElement가 들어간다.
+export class DrTargetElementIsElement extends OperatorExecuter<string | null> {
+  constructor(rawSet: RawSet, render: Render, returnContainer: ReturnContainer, elementSource: ElementSource, source: Source, afterCallBack: AfterCallBack) {
+    source.operatorAround = undefined;
+    super(rawSet, render, returnContainer, elementSource, source, afterCallBack, false);
+  }
+
+  async execute(attr: string | null): Promise<ExecuteState> {
+    if (!attr) {
+      return ExecuteState.NO_EXECUTE;
+    }
+    const targetElement = this.source.config?.targetElements?.find(it => it.name.toLowerCase() === attr.toLowerCase());
+    // console.log('--------------tar', targetElement)
+    if (targetElement) {
+      if (this.rawSet.point.start instanceof this.source.config.window.HTMLMetaElement && this.rawSet.point.end instanceof this.source.config.window.HTMLMetaElement) {
+        this.rawSet.point.start.setAttribute('this-path', `this.__domrender_components.${this.rawSet.uuid}`)
+        this.rawSet.point.end.setAttribute('this-path', `this.__domrender_components.${this.rawSet.uuid}`)
+      }
+
+
+      const documentFragment = await targetElement.callBack(this.elementSource.element, this.source.obj, this.rawSet, this.elementSource.attrs, this.source.config);
+      if (documentFragment) {
+        const detectAction = this.elementSource.element.getAttribute(RawSet.DR_DETECT_NAME);
+        this.rawSet.dataSet.fragment = documentFragment;
+        if (detectAction && this.rawSet.dataSet.render) {
+          // TODO: 없어져야될듯?
+          this.rawSet.detect = {
+            action: () => {
+              const script = `var $component = this.__render.component; var $element = this.__render.element; var $innerHTML = this.__render.innerHTML; var $attribute = this.__render.attribute;  ${detectAction} `;
+              ScriptUtils.evaluate(script, Object.assign(this.source.obj, {
+                __render: this.rawSet.dataSet.render
+              }))
+            }
+          };
+        }
+
+        // dr-replace-target-element-is 는 무조건 NoStrip로 처리
+        const noStrip = targetElement.noStrip
+
+        let targetFragment = documentFragment;
+        if (noStrip) {
+          const fragment = this.source.config.window.document.createDocumentFragment()
+          Array.from(documentFragment.firstElementChild?.childNodes || []).forEach(child => {
+            fragment.appendChild(child);
+          });
+          targetFragment = fragment;
+        }
+
+        const rr = RawSet.checkPointCreates(targetFragment, this.source.obj, this.source.config)
+        if (noStrip) {
+          Array.from(targetFragment.childNodes||[]).forEach(child => {
+            documentFragment.firstElementChild?.appendChild(child)
+          })
+        }
+        this.elementSource.element.parentNode?.replaceChild(documentFragment, this.elementSource.element);
+        this.returnContainer.raws.push(...rr);
+        this.afterCallBack.onElementInitCallBacks.push({
+          name: targetElement.name.toLowerCase(),
+          obj: this.source.obj,
+          targetElement,
+          creatorMetaData: targetElement.__creatorMetaData as CreatorMetaData
+        });
+        targetElement?.complete?.(this.elementSource.element, this.source.obj, this.rawSet);
+      }
+      return ExecuteState.EXECUTE;
+    }
+    return ExecuteState.NO_EXECUTE;
+  }
+}

package/src/operators/DrThis.ts

@@ -0,0 +1,107 @@
+import { OperatorExecuterAttrRequire } from './OperatorExecuterAttrRequire';
+import { RawSet } from '../rawsets/RawSet';
+import { ComponentSet } from '../components/ComponentSet';
+import { ExecuteState } from './OperatorExecuter';
+import { isOnDrThisUnBind } from '../lifecycle/dr-this/OnDrThisUnBind';
+import { isOnDrThisBind } from '../lifecycle/dr-this/OnDrThisBind';
+import { ScriptUtils } from '@dooboostore/core-web/script/ScriptUtils';
+import { Render } from '../rawsets/Render';
+
+export class DrThis extends OperatorExecuterAttrRequire<string> {
+  async executeAttrRequire(attr: any): Promise<ExecuteState> {
+    // const e = this.elementSource;
+    // console.log('drThis!!!!!!!!!!!!!', this.elementSource.attrs.drDetectIfOption, this.elementSource.attrs.drIfOption);
+    const optionIf = this.elementSource.attrs.drDetectIfOption ?? this.elementSource.attrs.drIfOption;
+    const ok = ScriptUtils.evaluate(`
+                ${this.render.bindScript}
+                try {
+                  const ok  = ${this.elementSource.attrs.drThis};
+                  const option = ${optionIf};
+                  if (option!==null) {
+                     return !!(ok && option); 
+                  }
+                  // console.log('vv', ${this.elementSource.attrs.drThis}, ${this.elementSource.attrs.drIfOption}, '${this.elementSource.attrs.drIfOption}');
+                  return !!ok;
+                } catch(e) {
+                  return false;
+                }
+                `, Object.assign(this.source.obj,
+      {
+        __render: Object.freeze({
+          drAttr: this.elementSource.attrs,
+          drAttrsOriginName: RawSet.drAttrsOriginName,
+          ...this.render
+        } as Render)
+      }
+    ));
+    // console.log('----zxvxcv-----!!!aa!', ok);
+    // if (!ok) {
+    //   this.elementSource.element.remove();
+    //   return ExecuteState.STOP;
+    // }
+
+    // console.log('----zxvxcv-----!!!!', attr);
+    if (attr && this.elementSource.attrs.drThis && ok) {
+      let thisPath = this.elementSource.attrs.drThis;
+      // let optionIf = this.elementSource.attrs.drIfOption;
+      // console.log('drThis!!!!!!!!!!!!!, ', optionIf)
+      if (attr instanceof ComponentSet) {
+        // console.log('drThis!!!!!!!!!!->', attr)
+        // if (this.rawSet.data) {
+        //   const destroyOptions = this.elementSource.attrs.drDestroyOption?.split(',') ?? [];
+        //   debugger;
+        //   RawSet.destroy((this.rawSet.data as ComponentSet).obj, [], this.source.config, destroyOptions);
+        // }
+        if (attr.config?.beforeComponentSet?.obj !== attr.obj) {
+          if (isOnDrThisUnBind(attr.config.beforeComponentSet?.obj)) {
+            attr.config.beforeComponentSet?.obj?.onDrThisUnBind?.();
+          }
+        }
+        // this.rawSet.dataSet ??= {};
+        // this.rawSet.dataSet.data = attr;
+        if (attr.config?.beforeComponentSet?.obj !== attr.obj) {
+          if (isOnDrThisBind(attr.obj)) {
+            attr.obj?.onDrThisBind?.();
+          }
+        }
+        // 중요: componentSet 의 objPath를 보고 판단하는 중요한부분
+        thisPath = `${this.elementSource.attrs.drThis}${attr.config.objPath ? ('.' + attr.config.objPath) : ''}`;
+        // const zthisPath = `${this.elementSource.attrs.drThis}${attr.config.objPath ? ('?.' + attr.config.objPath) : ''}`;
+        // console.log('thisPaththisPaththisPath',thisPath)
+        this.setThisPath(thisPath);
+        const componentBody = await RawSet.drThisCreate(this.rawSet, this.elementSource.element, thisPath, this.elementSource.attrs.drVarOption ?? '', this.elementSource.attrs.drStripOption, this.source.obj, this.source.config, attr);
+        if (componentBody) {
+          this.returnContainer.fag.append(componentBody)
+          this.afterCallBack.onThisComponentSetCallBacks.push(attr);
+        }
+
+      } else {
+        this.setThisPath(thisPath);
+        const fragment = await RawSet.drThisCreate(this.rawSet, this.elementSource.element, this.elementSource.attrs.drThis, this.elementSource.attrs.drVarOption ?? '', this.elementSource.attrs.drStripOption, this.source.obj, this.source.config);
+        if (fragment) {
+          this.returnContainer.fag.append(fragment)
+        }
+      }
+
+
+      // console.log('!!!!!!!!!zzz', Array.from(this.returnContainer.fag.childNodes), this.elementSource.element);
+      const rr = RawSet.checkPointCreates(this.returnContainer.fag, this.source.obj, this.source.config)
+      this.elementSource.element.parentNode?.replaceChild(this.returnContainer.fag, this.elementSource.element);
+      this.returnContainer.raws.push(...rr);
+    } else {
+      this.elementSource.element.remove();
+    }
+    return ExecuteState.EXECUTE;
+  }
+
+
+  setThisPath(thisPath: string) {
+
+    // if (this.rawSet.point.start instanceof HTMLMetaElement && this.rawSet.point.end instanceof HTMLMetaElement) {
+
+    if (this.rawSet.point.start instanceof this.source.config.window.HTMLMetaElement && this.rawSet.point.end instanceof this.source.config.window.HTMLMetaElement) {
+      this.rawSet.point.start.setAttribute('this-path', thisPath)
+      this.rawSet.point.end.setAttribute('this-path', thisPath)
+    }
+  }
+}

package/src/operators/DrThisProperty.ts

@@ -0,0 +1,91 @@
+import {OperatorExecuterAttrRequire} from './OperatorExecuterAttrRequire';
+import {ScriptUtils} from '@dooboostore/core-web/script/ScriptUtils';
+import {RawSet} from '../rawsets/RawSet';
+import {Render} from '../rawsets/Render';
+import {AfterCallBack, ElementSource, ExecuteState, ReturnContainer, Source} from './OperatorExecuter';
+import {DomRenderConfig} from '../configs/DomRenderConfig';
+
+export class DrThisProperty extends OperatorExecuterAttrRequire<string> {
+    constructor(rawSet: RawSet, render: Render, returnContainer: ReturnContainer, elementSource: ElementSource, source: Source, afterCallBack: AfterCallBack) {
+        source.operatorAround = undefined;
+        super(rawSet, render, returnContainer, elementSource, source, afterCallBack, false);
+    }
+
+    async executeAttrRequire(attr: string): Promise<ExecuteState> {
+        const itRandom = RawSet.drItOtherEncoding(this.elementSource.element, 'DrThisProperty');
+        const vars = RawSet.drVarEncoding(this.elementSource.element, this.elementSource.attrs.drVarOption ?? '');
+        const newTemp = this.source.config.window.document.createElement('temp');
+        const dictioanry = ScriptUtils.evaluateReturn(attr, this.source.obj)
+        const dictionaryKey = this.elementSource.attrs.drKeyOption ?? '';
+        // console.log('--->', attr, dictionaryKey)
+        // if (!(dictioanry instanceof Dictionary)) {
+        //     return ExecuteState.STOP;
+        // }
+        // await new Promise(resolve => setTimeout(resolve, 1000));
+        // console.log('!!!!!!!!!!!!!!', this.rawSet);
+        ScriptUtils.evaluate(`
+                    ${this.render.bindScript}
+                    ${this.elementSource.attrs.drBeforeOption ?? ''}
+                    var i = 0; 
+                    const dictionary = ${attr};
+                    const dictionaryKey = '${dictionaryKey}';
+                    const dictionaryStr = \`${attr}\`.trim();
+                    // console.log('----@#!@#@!#', this.__render.oldChild);
+                    if (dictionary) {
+                        for(const it in dictionary) {
+                            var destIt = dictionaryStr + '["' + it + '"]';
+                            const n = this.__render.element.cloneNode(true);
+                            n.setAttribute('dr-this', destIt);
+                            n.setAttribute('${RawSet.DR_KEY_OPTIONNAME}', it);
+                            // n.setAttribute('dr-dictionary-key', it);
+                            this.__render.fag.append(n);
+                            i++;
+                        }
+                         this.__render.rawset.point.start.setAttribute('${RawSet.DR_HAS_KEYS_OPTIONNAME}',Object.keys(dictionary).join(','));
+                    }
+                    ${this.elementSource.attrs.drAfterOption ?? ''}
+                    `, Object.assign(this.source.obj, {
+            __render: Object.freeze({
+                drStripOption: this.elementSource.attrs.drStripOption,
+                drAttr: this.elementSource.attrs,
+                drAttrsOriginName: RawSet.drAttrsOriginName,
+                fag: newTemp,
+                ...this.render
+            } as 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);
+        this.elementSource.element.parentNode?.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;
+    }
+
+
+    public static append(obj: any, fullPath: string, key: string, rawSet: RawSet, config: DomRenderConfig) {
+        const genNode = config.window.document.importNode(rawSet.dataSet.fragment, true);
+        // console.log('---> append', rawSet, genNode);
+        const rawSets: RawSet[] = [];
+        for (const cNode of Array.from(genNode.childNodes.values())) {
+            const element = cNode.cloneNode(true) as Element;
+            element.removeAttribute(RawSet.DR_THIS_PROPERTY_NAME);
+            element.setAttribute(RawSet.DR_THIS_NAME, `this.${fullPath}`);
+            element.setAttribute(RawSet.DR_KEY_OPTIONNAME, key);
+            // rawSet.point.end.after(element);
+            const fg = config.window.document.createDocumentFragment()
+            fg.append(element);
+            rawSets.push(...RawSet.checkPointCreates(fg, obj, config));
+            rawSet.point.end.before(fg);
+            const start = (rawSet.point.start as Element);
+            const keys = start.getAttribute(RawSet.DR_HAS_KEYS_OPTIONNAME)?.split(',') ?? [];
+            keys.push(key);
+            start.setAttribute(RawSet.DR_HAS_KEYS_OPTIONNAME, keys.join(','));
+            rawSets.forEach(async (it) => await it.render(obj, config));
+        }
+        return rawSets;
+    }
+}

package/src/operators/OperatorExecuter.ts

@@ -0,0 +1,66 @@
+import { AttrInitCallBack } from '../rawsets/AttrInitCallBack';
+import { ElementInitCallBack } from '../rawsets/ElementInitCallBack';
+import { ComponentSet } from '../components/ComponentSet';
+import { RawSet } from '../rawsets/RawSet';
+import { Render } from '../rawsets/Render';
+import { Attrs } from '../rawsets/Attrs';
+import { DomRenderConfig } from '../configs/DomRenderConfig';
+import { ObjectUtils } from '@dooboostore/core/object/ObjectUtils';
+
+export interface OperatorAround {
+  beforeAttr?: (value: string | null | undefined, opratorExecutor: OperatorExecuter) => string | null | undefined,
+  before?: (data: any, opratorExecutor: OperatorExecuter) => any,
+  after?: (data: any, opratorExecutor: OperatorExecuter) => void,
+}
+
+export enum ExecuteState {
+  EXECUTE,
+  NO_EXECUTE,
+  STOP
+}
+
+export type AfterCallBack = {
+  onAttrInitCallBacks: AttrInitCallBack[],
+  onElementInitCallBacks: ElementInitCallBack[],
+  onThisComponentSetCallBacks: ComponentSet[]
+}
+export type ReturnContainer = { raws: RawSet[], fag: DocumentFragment };
+
+export type ElementSource = { element: Element, attrs: Attrs, attr?: string | null, attrName?: string | undefined };
+
+export type Source = { config: DomRenderConfig, operatorAround?: OperatorAround, obj: any };
+
+export abstract class OperatorExecuter<T = any> {
+  constructor(public rawSet: RawSet,
+              public render: Render,
+              public returnContainer: ReturnContainer,
+              public elementSource: ElementSource,
+              public source: Source,
+              public afterCallBack: AfterCallBack,
+              public startingExecute = true) {
+  };
+
+  async start(): Promise<ExecuteState> {
+    let attrValue = this.elementSource.attr;
+    // console.log('OperatorExecuter ', attrValue, this);
+    if (this.source.operatorAround?.beforeAttr) {
+      attrValue = this.source.operatorAround.beforeAttr(attrValue, this) ?? '';
+    }
+
+    let r = attrValue;
+    if (r && this.startingExecute) {
+      const optionalPath = ObjectUtils.Path.toOptionalChainPath(attrValue);
+      r = ObjectUtils.Script.evaluate(` ${this.render.bindScript}; return ${optionalPath}`, Object.assign(this.source.obj, {__render: this.render}));
+    }
+    if (this.source.operatorAround?.before) {
+      r = this.source.operatorAround?.before(r, this);
+    }
+
+    const state = await this.execute(r as unknown as T)
+
+    this.source.operatorAround?.after?.(r, this);
+    return state;
+  };
+
+  abstract execute(value: T): Promise<ExecuteState>;
+}

package/src/operators/OperatorExecuterAttrRequire.ts

@@ -0,0 +1,24 @@
+import {RawSet} from '../rawsets/RawSet';
+import {Render} from '../rawsets/Render';
+import {AfterCallBack, ElementSource, ExecuteState, OperatorExecuter, ReturnContainer, Source} from './OperatorExecuter';
+
+export abstract class OperatorExecuterAttrRequire<T> extends OperatorExecuter<T> {
+    constructor(rawSet: RawSet,
+                render: Render,
+                returnContainer: ReturnContainer,
+                elementSource: ElementSource,
+                source: Source,
+                afterCallBack: AfterCallBack,
+                startingExecute = true) {
+        super(rawSet, render, returnContainer, elementSource, source, afterCallBack, startingExecute);
+    };
+
+    async execute(data: T): Promise<ExecuteState> {
+        if (!this.elementSource.attr) {
+            return ExecuteState.NO_EXECUTE;
+        }
+        return await this.executeAttrRequire(data);
+    }
+
+    protected abstract executeAttrRequire(attr: T): Promise<ExecuteState>;
+}

package/src/operators/index.ts

@@ -0,0 +1,19 @@
+export * from './Appender';
+export * from './Dr';
+export * from './DrAppender';
+export * from './DrFor';
+export * from './DrForOf';
+export * from './DrForm';
+export * from './DrIf';
+export * from './DrInnerHTML';
+export * from './DrInnerText';
+export * from './DrPre';
+export * from './DrRepeat';
+export * from './DrStripElement';
+export * from './DrTargetAttr';
+export * from './DrTargetElement';
+export * from './DrTargetElementIsElement';
+export * from './DrThis';
+export * from './DrThisProperty';
+export * from './OperatorExecuter';
+export * from './OperatorExecuterAttrRequire';

package/src/rawsets/AttrInitCallBack.ts

@@ -0,0 +1 @@
+export type AttrInitCallBack = { attrName: string, attrValue: string, obj: any };

package/src/rawsets/Attrs.ts

@@ -0,0 +1,28 @@
+export type Attrs = {
+    dr: string | null;
+    drIf: string | null;
+    drAppender: string | null;
+    drFor: string | null;
+    drForOf: string | null;
+    drThisProperty: string | null;
+    drRepeat: string | null;
+    drThis: string | null;
+    drStripElement: string | null;
+    drReplaceTargetElementIs: string | null;
+    drForm: string | null;
+    drPre: string | null;
+    drInnerHTML: string | null;
+    drInnerText: string | null;
+    drItOption: string | null;
+    drVarOption: string | null;
+    drAfterOption: string | null;
+    drNextOption: string | null;
+    drBeforeOption: string | null;
+    drCompleteOption: string | null;
+    drStripOption: string | null;
+    drIfOption: string | null;
+    drDetectIfOption: string | null;
+    drDestroyOption: string | null;
+    drHasKeysOption: string | null;
+    drKeyOption: string | null;
+}

package/src/rawsets/CreatorMetaData.ts

@@ -0,0 +1,19 @@
+import {Router} from '../routers/Router';
+import {Attrs} from './Attrs';
+import {RawSet} from './RawSet';
+
+/** @deprecated */
+export type CreatorMetaData = {
+    thisVariableName?: string | null;
+    thisFullVariableName?: string | null;
+    componentKey?: string | null;
+    rawSet: RawSet;
+    scripts?: { [n: string]: any };
+    router?: Router;
+    innerHTML: string;
+    drAttrs?: Attrs;
+    rootCreator: any;
+    attribute: any;
+    creator: any;
+    // render?: Render;
+}

package/src/rawsets/DestroyOptionType.ts

@@ -0,0 +1,4 @@
+export enum DestroyOptionType {
+    NO_DESTROY = 'NO_DESTROY',
+    NO_MESSENGER_DESTROY = 'NO_MESSENGER_DESTROY'
+}

package/src/rawsets/ElementInitCallBack.ts

@@ -0,0 +1,4 @@
+import {TargetElement} from '../configs/TargetElement';
+import {CreatorMetaData} from './CreatorMetaData';
+
+export type ElementInitCallBack = { name: string, obj: any, targetElement: TargetElement, creatorMetaData: CreatorMetaData };