amateras 0.4.1 → 0.5.0

package/src/node/$Node.ts

@@ -1,6 +1,7 @@
 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 { _Array_from, _instanceof, _JSON_stringify, _null, _Promise, forEach, isBoolean, isFunction, isNull, isObject, isUndefined } from "#lib/native";
+import { toArray } from "#lib/toArray";
 import { Signal } from "#structure/Signal";
 
 export class $Node {
@@ -12,15 +13,15 @@ export class $Node {
     }
 
     content(children: $NodeContentResolver<this>) {
-        return chain(this, null, null, children, children => {
-            forEach(this.childNodes, node => node.remove());
+        return chain(this, _null, _null, children, children => {
+            forEach(_Array_from(this.childNodes), node => node.remove());
             this.insert(children);
         })
     }
 
     insert(resolver: $NodeContentResolver<this>, position = -1) {
         // process nodes
-        forEach($.toArray(resolver), resolve_child => forEach($Node.process(this, resolve_child), $node => $Node.append(this, $node, position)));
+        forEach(toArray(resolver), resolve_child => forEach($Node.process(this, resolve_child), $node => $Node.append(this, $node, position)));
         return this;
     }
 
@@ -33,7 +34,7 @@ export class $Node {
     replace($node: $NodeContentResolver<$Node>) {
         if ($node) 
             this.replaceWith(
-                ...$.toArray($Node.process(this, $node)).filter($node => $node).map($node => $node?.node) as Node[]
+                ...toArray($Node.process(this, $node)).filter($node => $node).map($node => $node?.node) as Node[]
             )
         return this;
     }
@@ -57,10 +58,22 @@ export class $Node {
         return _instanceof(this, instance) ? this : null;
     }
 
+    on(type: string, listener: any, options?: boolean | AddEventListenerOptions) {
+        return this.addEventListener(type, listener, options);
+    }
+
+    off(type: string, listener: any, options?: boolean | EventListenerOptions) {
+        return this.removeEventListener(type, listener, options);
+    }
+    
+    once(type: string, listener: any, options?: boolean | AddEventListenerOptions) {
+        return this.on(type, listener, { once: true, ...(isBoolean(options) ? {capture: options} : options ?? {}) })
+    }
+
     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))];
+        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;
@@ -86,8 +99,8 @@ export class $Node {
                 }
             } else {
                 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();
+                if (_instanceof(_content, _Promise)) return this.process($node, _content as any);
+                else return toArray(_content).map(content => this.process($node, content)).flat();
             }
         }
         // is nested array

package/src/structure/Signal.ts

@@ -1,4 +1,4 @@
-import { _instanceof, forEach, isUndefined } from "#lib/native";
+import { _instanceof, forEach, isFunction, isUndefined } from "#lib/native";
 
 export class Signal<T> {
     #value: T;
@@ -16,7 +16,7 @@ export class Signal<T> {
             forEach(Signal.listeners, fn => fn(this));
             return this.#value;
         }
-        if (_instanceof(resolver, Function)) this.value(resolver(this.#value));
+        if (isFunction(resolver)) this.value(resolver(this.#value));
         else if (!isUndefined(resolver)) {
             this.#value = resolver;
             this.emit();