amateras 0.3.0 → 0.4.1

package/src/node/$Node.ts

@@ -1,4 +1,6 @@
-import { _Array_from, _document, _instanceof, _JSON_stringify, forEach, isFunction, isNull, isObject, isUndefined } from "#lib/native";
+import { chain } from "#lib/chain";
+import { _document } from "#lib/env";
+import { _Array_from, _instanceof, _JSON_stringify, forEach, isFunction, isNull, isObject, isUndefined } from "#lib/native";
 import { Signal } from "#structure/Signal";
 
 export class $Node {
@@ -10,84 +12,100 @@ export class $Node {
     }
 
     content(children: $NodeContentResolver<this>) {
-        forEach(_Array_from(this.childNodes), node => node.remove());
-        return this.insert(children);
+        return chain(this, null, null, children, children => {
+            forEach(this.childNodes, node => node.remove());
+            this.insert(children);
+        })
     }
 
     insert(resolver: $NodeContentResolver<this>, position = -1) {
-        // insert node helper function for depend position
-        const appendChild = (children: OrArray<$Node | undefined | null>) => {
-            // get child node at position
-            const positionChild = _Array_from(this.childNodes).filter(node => node.nodeType !== node.TEXT_NODE).at(position);
-            forEach($.toArray(children), child => {
-                if (!child) return;
-                if (_instanceof(child, Array)) this.insert(child);
-                else if (!positionChild) this.appendChild(child.node);
-                else this.insertBefore(child.node, position < 0 ? positionChild.nextSibling : positionChild);
-            })
-        }
         // process nodes
-        for (const child of $.toArray(resolver)) !isUndefined(child) && appendChild(processContent(this, child))
+        forEach($.toArray(resolver), resolve_child => forEach($Node.process(this, resolve_child), $node => $Node.append(this, $node, position)));
         return this;
     }
 
-    await<T>(promise: Promise<T>, callback: ($node: this, result: T) => void): this {
-        return promise.then(result => callback(this, result)), this;
+    await<T>(promise: OrPromise<T>, callback: ($node: this, result: T) => void): this {
+        if (_instanceof(promise, Promise)) promise.then(result => callback(this, result));
+        else callback(this, promise);
+        return this;
     }
 
     replace($node: $NodeContentResolver<$Node>) {
-        if (!$node) return this;
-        this.replaceWith(
-            ...$.toArray(processContent(this, $node)).filter($node => $node).map($node => $node?.node) as Node[]
-        )
+        if ($node) 
+            this.replaceWith(
+                ...$.toArray($Node.process(this, $node)).filter($node => $node).map($node => $node?.node) as Node[]
+            )
         return this;
     }
 
+    inDOM() {
+        return _document.contains(this.node);
+    }
+
     toString() {
         return this.textContent();
     }
-}
 
-function processContent<T extends $Node>($node: T, content: $NodeContentResolver<any>): OrArray<$Node | undefined | null> {
-    if (isUndefined(content)) return;
-    if (isNull(content)) return content;
-    // is $Element
-    if (_instanceof(content, $Node)) return content;
-    // is Promise
-    if (_instanceof(content, Promise)) return $('async').await(content, ($async, $child) => $async.replace($child as any));
-    // is SignalFunction or ContentHandler
-    if (isFunction(content)) {
-        const signal = (content as any).signal;
-        if (_instanceof(signal, Signal)) {
-            const resolver = (content as $.SignalFunction<any>)();
-            if (_instanceof(resolver, $Node)) {
-                // handler signal $Node result
-                let node = resolver;
-                const set = (value: any) => {
-                    node.replace(value);
-                    node = value;
+    mounted($parent: $Node) {}
+    
+    use<F extends ($ele: this, ...args: any) => void>(callback: F, ...args: F extends ($ele: this, ...args: infer P) => void ? P : never) {
+        callback(this, ...args);
+        return this;
+    }
+
+    is<T extends (abstract new (...args: any[]) => $Node)>(instance: T): InstanceType<T> | null {
+        return _instanceof(this, instance) ? this : null;
+    }
+
+    static process<T extends $Node>($node: T, content: $NodeContentResolver<any>): Array<$Node | undefined | null> {
+        if (isUndefined(content) || isNull(content) || _instanceof(content, $Node)) return [content];
+        // is Promise
+        if (_instanceof(content, Promise)) return [$('async').await(content, ($async, $child) => $async.replace($child as any))];
+        // is SignalFunction or ContentHandler
+        if (isFunction(content)) {
+            const signal = (content as any).signal;
+            if (_instanceof(signal, Signal)) {
+                const resolver = (content as $.SignalFunction<any>)();
+                if (_instanceof(resolver, $Node)) {
+                    // handler signal $Node result
+                    let node = resolver;
+                    const set = (value: any) => {
+                        node.replace(value);
+                        node = value;
+                    }
+                    signal.subscribe(set);
+                    return [resolver];
+                } else {
+                    // handler signal other type result
+                    const $text = _document ? new $Text() : $('signal').attr({ type: typeof signal.value() });
+                    const set = (value: any) => $text.textContent(isObject(value) ? _JSON_stringify(value) : value);
+                    if (_instanceof($text, $Text)) $text.signals.add(signal);
+                    signal.subscribe(set);
+                    set(resolver);
+                    return [$text];
                 }
-                signal.subscribe(set);
-                return resolver;
             } else {
-                // handler signal other type result
-                const $text = _document ? new $Text() : $('signal').attr({ type: typeof signal.value() });
-                const set = (value: any) => $text.textContent(isObject(value) ? _JSON_stringify(value) : value);
-                if (_instanceof($text, $Text)) $text.signals.add(signal);
-                signal.subscribe(set);
-                set(resolver);
-                return $text;
+                const _content = content($node) as $NodeContentResolver<$Node>;
+                if (_instanceof(_content, Promise)) return this.process($node, _content as any);
+                else return $.toArray(_content).map(content => this.process($node, content)).flat();
             }
-        } else {
-            const _content = content($node) as $NodeContentResolver<$Node>;
-            if (_instanceof(_content, Promise)) return processContent($node, _content as any);
-            else return $.toArray(_content).map(content => processContent($node, content) as $Node);
+        }
+        // is nested array
+        if (_instanceof(content, Array)) return content.map(c => this.process($node, c)).flat();
+        // is string | number | boolean
+        return [new $Text(`${content}`)];
+    }
+
+    /**  */
+    static append($node: $Node, child: $Node | undefined | null, position: number) {
+        if (child) {
+            // get child node at position
+            let positionChild = _Array_from($node.childNodes).at(position);
+            if (!positionChild) $node.appendChild(child.node);
+            else $node.insertBefore(child.node, position < 0 ? positionChild.nextSibling : positionChild);
+            child.mounted($node);
         }
     }
-    // is nested array
-    if (_instanceof(content, Array)) return content.map(c => processContent($node, c) as $Node)
-    // is string | number | boolean
-    return new $Text(`${content}`);
 }
 
 export class $Text extends $Node {
@@ -163,6 +181,12 @@ export interface $Node {
     remove(): this;
     /** {@link Node.replaceChild} */
     replaceWith(...nodes: (Node | string)[]): this;
+    /** {@link EventTarget.addEventListener} */
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+    /** {@link EventTarget.removeEventListener} */
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    /** {@link EventTarget.dispatchEvent} */
+    dispatchEvent(event: Event): boolean;
 
     /** {@link Node.nodeValue} */
     nodeValue(nodeValue: $Parameter<string | null>): this;

package/src/{node/node.ts → node.ts}

@@ -1,12 +1,9 @@
 import { $HTMLElement } from '#node/$HTMLElement';
 import { assignHelper } from '#lib/assignHelper';
 import { $Element } from '#node/$Element';
-import { $Node, $Text } from './$Node';
-
-export * from './$Node';
-export * from './$Element';
-export * from './$HTMLElement';
+import { $Node, $Text } from '#node/$Node';
 
+assignHelper(EventTarget, $Node);
 assignHelper(Node, $Node);
 assignHelper(Text, $Text);
 assignHelper(Element, $Element);