@dooboostore/dom-render 1.0.107 → 1.0.108

package/src/components/timer/Timer.ts

@@ -0,0 +1,119 @@
+import { ComponentBase } from '../ComponentBase';
+import { DomRender, DomRenderRunConfig } from '../../DomRender';
+import { RawSet } from '../../rawsets/RawSet';
+import { OtherData } from '../../lifecycle/OnChangeAttrRender';
+import { OnDestroyRenderParams } from '../../lifecycle/OnDestroyRender';
+
+
+export namespace Timer {
+  export const selector = 'dr-timer';
+  export type Attribute = {
+    timeSecond?: string;
+  }
+
+  // class RadioBase extends ComponentBase<Attribute> {
+  //   public hidden = true;
+  //
+  // }
+
+  // @Component({
+  //   template: '<div dr-if="!@this@.hidden" dr-strip="true">#innerHTML#</div>',
+  //   styles: '',
+  //   selector: `${selector}.Checked`
+  // })
+  // export class RadioChecked extends RadioBase {
+  //   public name = 'Checked';
+  //
+  //   constructor() {
+  //     super({ onlyParentType: Radio });
+  //   }
+  // }
+  //
+  // @Component({
+  //   template: '<div dr-if="!@this@.hidden" dr-strip="true">#innerHTML#</div>',
+  //   styles: '',
+  //   selector: `${selector}.UnChecked`
+  // })
+  // export class UnChecked extends RadioBase {
+  //   public name = 'unChecked';
+  //
+  //   constructor() {
+  //     super({ onlyParentType: Radio });
+  //   }
+  // }
+
+  // @Component({
+  //   template: '#innerHTML#',
+  //   selector: `${selector}`,
+  //   noStrip: true
+  // })
+  export class Timer extends ComponentBase<Attribute> {
+    private interval?: any;
+    private timeSecond?: number;
+
+
+    onInitRender(param: any, rawSet: RawSet) {
+      super.onInitRender(param, rawSet);
+      console.log('---2', this.getElement()?.isConnected)
+      // const element = this.getElement();
+      // if(element){
+      //   (element as any).component = this;
+      // }
+    }
+
+    isRunning() {
+      return this.timeSecond !== undefined;
+    }
+
+    start() {
+      const timeSecond = this.getAttribute('timeSecond');
+      if (timeSecond) {
+        this.timeSecond = parseInt(timeSecond);
+        this.interval = setInterval(() => {
+          // console.log('--------->',this.timeSecond)
+          if (this.timeSecond) {
+            this.timeSecond--;
+          } else {
+            clearInterval(this.interval);
+            this.timeSecond = undefined;
+            this.interval = undefined;
+          }
+        }, 1000)
+      }
+    }
+
+
+    stop() {
+      if (this.interval) {
+        clearInterval(this.interval);
+        this.interval = undefined;
+        this.timeSecond = undefined;
+      }
+    }
+
+    onChangeAttrRender(name: string, val: any, other: OtherData) {
+      super.onChangeAttrRender(name, val, other);
+      console.log('-----', name, val, this.getElement())
+    }
+
+    onDestroyRender(data: OnDestroyRenderParams) {
+      super.onDestroyRender(data);
+      if (this.interval){
+        clearInterval(this.interval);
+      }
+    }
+  }
+}
+
+
+export default {
+  choose: (config?: DomRenderRunConfig) => {
+    return RawSet.createComponentTargetElement({
+      name: `${Timer.selector}`,
+      template: '#innerHTML#',
+      objFactory: (e,o,r2, counstructorParam) => {
+        return DomRender.run({rootObject: new Timer.Timer(...counstructorParam), config: config});
+      }
+    })
+  },
+}

package/src/components/timer/index.ts

@@ -0,0 +1 @@
+export * from './Timer';

package/src/configs/DomRenderConfig.ts

@@ -0,0 +1,30 @@
+import { ConstructorType } from '@dooboostore/core/types';
+import { RawSet } from '../rawsets/RawSet';
+import { Router } from '../routers/Router';
+import { Messenger } from '../messenger/Messenger';
+import { TargetElement } from './TargetElement';
+import { TargetAttr } from './TargetAttr';
+import { Attrs } from '../rawsets/Attrs';
+import { OperatorAround } from '../operators/OperatorExecuter';
+import { EventManager } from '../events/EventManager';
+
+export type DomRenderConfig<T = any> = {
+  window: Window;
+  targetElements?: TargetElement[];
+  targetAttrs?: TargetAttr[];
+  operatorAround?: { [key in keyof Attrs]?: OperatorAround },
+  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[];
+  uuid: string;
+  scripts?: { [n: string]: any };
+  root: any;
+  rootElement?: Element | null;
+  router?: Router;
+  messenger: Messenger;
+  eventManager: EventManager;
+  eventVariables?: { [n: string]: any };
+  applyEvents?: { attrName: string, callBack: (elements: Element, attrValue: string, obj: any) => void }[];
+}

package/{dist/esm/configs/TargetAttr.d.ts → src/configs/TargetAttr.ts}

@@ -1,7 +1,7 @@
-import { RawSet } from '../rawsets/RawSet';
+import {RawSet} from '../rawsets/RawSet';
+
 export type TargetAttr = {
     name: string;
     callBack: (target: Element, attrValue: string, obj: any, rawSet: RawSet) => DocumentFragment;
     complete?: (target: Element, attrValue: string, obj: any, rawSet: RawSet) => void;
-};
-//# sourceMappingURL=TargetAttr.d.ts.map
+};

package/{dist/esm/configs/TargetElement.d.ts → src/configs/TargetElement.ts}

@@ -1,11 +1,12 @@
-import { RawSet } from '../rawsets/RawSet';
-import { DomRenderConfig } from '../configs/DomRenderConfig';
-import { Attrs } from '../rawsets/Attrs';
-import { CreatorMetaData } from '../rawsets/CreatorMetaData';
-import { Render } from '../rawsets/Render';
+import {RawSet} from '../rawsets/RawSet';
+import {DomRenderConfig} from '../configs/DomRenderConfig';
+import {Attrs} from '../rawsets/Attrs';
+import {CreatorMetaData} from '../rawsets/CreatorMetaData';
+import {Render} from '../rawsets/Render';
+
 export type TargetElement = {
     name: string;
-    noStrip?: boolean;
+    noStrip?:boolean;
     template?: string;
     styles?: string | (string[]);
     callBack: (target: Element, obj: any, rawSet: RawSet, attrs: Attrs, config: DomRenderConfig) => Promise<DocumentFragment | undefined>;
@@ -13,4 +14,3 @@ export type TargetElement = {
     __render?: Render;
     __creatorMetaData?: CreatorMetaData;
 };
-//# sourceMappingURL=TargetElement.d.ts.map

package/{dist/esm/configs/index.d.ts → src/configs/index.ts}

@@ -1,4 +1,3 @@
 export * from './DomRenderConfig';
 export * from './TargetAttr';
 export * from './TargetElement';
-//# sourceMappingURL=index.d.ts.map

package/src/decorators/DomRenderNoProxy.ts

@@ -0,0 +1,30 @@
+export const DomRenderNoProxyKey = 'DomRender:NoProxy'
+export const DomRenderNoProxy = (target: any, propertyKey?: string | symbol) => {
+    // 클래스 데코레이터로 사용된 경우
+    if (propertyKey === undefined) {
+      // target은 클래스 생성자
+      Reflect.defineMetadata(DomRenderNoProxyKey, true, target);
+      return;
+    }
+
+    // 프로퍼티 데코레이터로 사용된 경우
+    // target은 프로토타입, propertyKey는 프로퍼티 이름
+    Reflect.defineMetadata(DomRenderNoProxyKey, true, target, propertyKey);
+};
+
+export const getDomRenderNoProxy = (target: any, propertyKey?: string | symbol) => {
+  // if (ValidUtils.isNotNullUndefined(target)) {
+    // 클래스 데코레이터
+    if (propertyKey === undefined) {
+      return Reflect.getMetadata(DomRenderNoProxyKey, target);
+    }
+    // 프로퍼티 데코레이터
+    return Reflect.getMetadata(DomRenderNoProxyKey, target, propertyKey);
+  // } else {
+  //   return undefined;
+  // }
+}
+
+export const isDomRenderNoProxy = (target: any, propertyKey?: string | symbol) => {
+  return getDomRenderNoProxy(target, propertyKey) === true;
+}

package/{dist/esm/decorators/index.d.ts → src/decorators/index.ts}

@@ -1,2 +1 @@
 export * from './DomRenderNoProxy';
-//# sourceMappingURL=index.d.ts.map