@dooboostore/dom-render 1.0.98

package/components/select/Select.js

@@ -0,0 +1,52 @@
+import { ComponentBase } from '../ComponentBase';
+import { DomRender } from '../../DomRender';
+import { RawSet } from '../../rawsets/RawSet';
+export var Select;
+(function (Select_1) {
+    Select_1.selector = 'dr-select';
+    // @Component({
+    //   template: '<option class="${`${@this@.getAttribute(\'class\')} select-option-container`}$">#innerHTML#</option>',
+    //   styles: '',
+    //   selector: `${selector}.Option`
+    // })
+    class Option extends ComponentBase {
+        constructor() {
+            super({ onlyParentType: [Select] });
+        }
+    }
+    Select_1.Option = Option;
+    // @Component({
+    //   template: '',
+    //   styles: '',
+    //   selector: `${selector}`
+    // })
+    class Select extends ComponentBase {
+        onCreateRender(...param) {
+        }
+        onDestroyRender(...metaData) {
+        }
+    }
+    Select_1.Select = Select;
+})(Select || (Select = {}));
+// 아직 사용한적없으니 사용할때 만드세유~
+export default {
+    selectOption: (config) => {
+        return RawSet.createComponentTargetElement({
+            name: `${Select.selector}-other-wise`,
+            template: '<option class="${`${@this@.getAttribute(\'class\')} select-option-container`}$">#innerHTML#</option>',
+            objFactory: (e, o, r2, counstructorParam) => {
+                return DomRender.run({ rootObject: new Select.Option(), config: config });
+            }
+        });
+    },
+    select: (config) => {
+        return RawSet.createComponentTargetElement({
+            name: `${Select.selector}`,
+            template: '',
+            objFactory: (e, o, r2, counstructorParam) => {
+                return DomRender.run({ rootObject: new Select.Select(...counstructorParam), config: config });
+            }
+        });
+    },
+};
+//# sourceMappingURL=Select.js.map

package/components/this/This.d.ts

@@ -0,0 +1,24 @@
+import { ComponentBase } from '../ComponentBase';
+import { RunConfig } from '../../DomRender';
+import { RawSet } from '../../rawsets/RawSet';
+import { OtherData } from '../../lifecycle/OnChangeAttrRender';
+import { OnInitRender } from '../../lifecycle/OnInitRender';
+import { ComponentSet } from '../../components/ComponentSet';
+export declare namespace This {
+    const selector = "dr-this";
+    type Attribute = {
+        value: ComponentSet;
+        createArguments: any[];
+    };
+    class This extends ComponentBase<Attribute> implements OnInitRender {
+        private value?;
+        private createArguments?;
+        onInitRender(param: any, rawSet: RawSet): void;
+        onChangeAttrRender(name: string, value: any, other: OtherData): void;
+    }
+}
+declare const _default: {
+    this: (config?: RunConfig) => import("../../configs/TargetElement").TargetElement;
+};
+export default _default;
+//# sourceMappingURL=This.d.ts.map

package/components/this/This.js

@@ -0,0 +1,62 @@
+import { ComponentBase } from '../ComponentBase';
+import { DomRender } from '../../DomRender';
+import { RawSet } from '../../rawsets/RawSet';
+export var This;
+(function (This_1) {
+    This_1.selector = 'dr-this';
+    // @Component({
+    //   template: '<div dr-this="@this@.this" dr-option-strip="true" dr-on-create:arguments="@this@.createArguments">#innerHTML#</div>',
+    //   selector: `${selector}`
+    // })
+    class This extends ComponentBase {
+        // onCreateRender(...param: any) {
+        //   console.log('--onCreateRender')
+        // }
+        // test() {
+        //   console.log('t', this.getAttribute('appender'))
+        // }
+        onInitRender(param, rawSet) {
+            // console.log('--onInitRender onInitRender')
+            super.onInitRender(param, rawSet);
+        }
+        // push(...data:D[]) {
+        //   console.log('push/////', data);
+        //   this.appender.push(...data);
+        // }
+        //
+        // set(key: string, v: D): void {
+        //   this.appender.set(key, v)
+        // }
+        //
+        // delete(key: string): void {
+        //   this.appender.delete(key);
+        // }
+        //
+        // clear(): void {
+        //   this.appender.clear();
+        // }
+        onChangeAttrRender(name, value, other) {
+            super.onChangeAttrRender(name, value, other);
+            if (this.equalsAttributeName(name, 'value')) {
+                this.value = value;
+            }
+            if (this.equalsAttributeName(name, 'createArguments')) {
+                this.createArguments = value;
+            }
+            // console.log('------>appender', name, value);
+        }
+    }
+    This_1.This = This;
+})(This || (This = {}));
+export default {
+    this: (config) => {
+        return RawSet.createComponentTargetElement({
+            name: This.selector,
+            template: '<div dr-this="@this@.value" dr-option-strip="true" dr-on-create:arguments="@this@.createArguments">#innerHTML#</div>',
+            objFactory: (e, o, r2, counstructorParam) => {
+                return DomRender.run({ rootObject: new This.This(...counstructorParam), config: config });
+            }
+        });
+    },
+};
+//# sourceMappingURL=This.js.map

package/components/timer/Timer.d.ts

@@ -0,0 +1,26 @@
+import { ComponentBase } from '../ComponentBase';
+import { RunConfig } from '../../DomRender';
+import { RawSet } from '../../rawsets/RawSet';
+import { OtherData } from '../../lifecycle/OnChangeAttrRender';
+import { OnDestroyRenderParams } from 'lifecycle/OnDestroyRender';
+export declare namespace Timer {
+    const selector = "dr-timer";
+    type Attribute = {
+        timeSecond?: string;
+    };
+    class Timer extends ComponentBase<Attribute> {
+        private interval?;
+        private timeSecond?;
+        onInitRender(param: any, rawSet: RawSet): void;
+        isRunning(): boolean;
+        start(): void;
+        stop(): void;
+        onChangeAttrRender(name: string, val: any, other: OtherData): void;
+        onDestroyRender(data: OnDestroyRenderParams): void;
+    }
+}
+declare const _default: {
+    choose: (config?: RunConfig) => import("../../configs/TargetElement").TargetElement;
+};
+export default _default;
+//# sourceMappingURL=Timer.d.ts.map

package/components/timer/Timer.js

@@ -0,0 +1,102 @@
+import { ComponentBase } from '../ComponentBase';
+import { DomRender } from '../../DomRender';
+import { RawSet } from '../../rawsets/RawSet';
+export var Timer;
+(function (Timer_1) {
+    Timer_1.selector = 'dr-timer';
+    // 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
+    // })
+    class Timer extends ComponentBase {
+        onInitRender(param, rawSet) {
+            var _a;
+            super.onInitRender(param, rawSet);
+            console.log('---2', (_a = this.getElement()) === null || _a === void 0 ? void 0 : _a.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, val, other) {
+            super.onChangeAttrRender(name, val, other);
+            console.log('-----', name, val, this.getElement());
+        }
+        onDestroyRender(data) {
+            super.onDestroyRender(data);
+            if (this.interval) {
+                clearInterval(this.interval);
+            }
+        }
+    }
+    Timer_1.Timer = Timer;
+})(Timer || (Timer = {}));
+export default {
+    choose: (config) => {
+        return RawSet.createComponentTargetElement({
+            name: `${Timer.selector}`,
+            template: '#innerHTML#',
+            objFactory: (e, o, r2, counstructorParam) => {
+                return DomRender.run({ rootObject: new Timer.Timer(...counstructorParam), config: config });
+            }
+        });
+    },
+};
+//# sourceMappingURL=Timer.js.map

package/configs/Config.d.ts

@@ -0,0 +1,34 @@
+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';
+export type Config<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[];
+    scripts?: {
+        [n: string]: any;
+    };
+    router?: Router;
+    messenger?: Messenger;
+    eventVariables?: {
+        [n: string]: any;
+    };
+    applyEvents?: {
+        attrName: string;
+        callBack: (elements: Element, attrValue: string, obj: any) => void;
+    }[];
+};
+//# sourceMappingURL=Config.d.ts.map

package/configs/Config.js

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

package/configs/TargetAttr.d.ts

@@ -0,0 +1,7 @@
+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/configs/TargetAttr.js

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

package/configs/TargetElement.d.ts

@@ -0,0 +1,16 @@
+import { RawSet } from '../rawsets/RawSet';
+import { Config } from './Config';
+import { Attrs } from '../rawsets/Attrs';
+import { CreatorMetaData } from '../rawsets/CreatorMetaData';
+import { Render } from '../rawsets/Render';
+export type TargetElement = {
+    name: string;
+    noStrip?: boolean;
+    template?: string;
+    styles?: string | (string[]);
+    callBack: (target: Element, obj: any, rawSet: RawSet, attrs: Attrs, config: Config) => Promise<DocumentFragment>;
+    complete?: (target: Element, obj: any, rawSet: RawSet) => void;
+    __render?: Render;
+    __creatorMetaData?: CreatorMetaData;
+};
+//# sourceMappingURL=TargetElement.d.ts.map

package/configs/TargetElement.js

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

package/css/parse/index.d.ts

@@ -0,0 +1,49 @@
+export interface Position {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+    source?: string;
+    content: string;
+}
+export interface ParseOptions {
+    source?: string;
+    silent?: boolean;
+}
+export interface StyleSheet {
+    type: 'stylesheet';
+    stylesheet: {
+        source?: string;
+        rules: Rule[];
+        parsingErrors: Error[];
+    };
+}
+export interface Rule {
+    type: string;
+    selectors?: string[];
+    declarations?: Declaration[];
+    values?: string[];
+    name?: string;
+    vendor?: string;
+    keyframes?: Rule[];
+    media?: string;
+    rules?: Rule[];
+    supports?: string;
+    document?: string;
+    comment?: string;
+    position?: Position;
+    [key: string]: any;
+}
+interface Declaration {
+    type: 'declaration';
+    property: string;
+    value: string;
+    position?: Position;
+}
+export default function parse(css: string, options?: ParseOptions): StyleSheet;
+export {};
+//# sourceMappingURL=index.d.ts.map