amateras 0.5.0 → 0.6.0

package/src/node/$EventTarget.ts

@@ -0,0 +1,45 @@
+import { isBoolean } from "#lib/native";
+
+export class $EventTarget<EvMap = {}> {
+    node: EventTarget;
+    constructor(node: EventTarget) {
+        this.node = node;
+        if (node !== window) (node as Mutable<EventTarget>).$ = this;
+    }
+    
+    on(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | AddEventListenerOptions): this {
+        return this.addEventListener(type, listener, options);
+    }
+
+    off(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | EventListenerOptions): this {
+        return this.removeEventListener(type, listener, options);
+    }
+    
+    once(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | AddEventListenerOptions): this {
+        return this.on(type, listener, { once: true, ...(isBoolean(options) ? {capture: options} : options ?? {}) })
+    }
+}
+
+export type $Event<E extends $EventTarget, Ev = any> = Ev & {currentTarget: {$: E}};
+export type $EventListener<E extends $EventTarget, Ev> = (event: $Event<E, Ev>) => void;
+export type $EventListenerObject<E extends $EventTarget, Ev> = { handleEvent(object: $Event<E, Ev>): void; }
+
+export interface $EventTarget<EvMap = {}> {
+    /** {@link EventTarget.addEventListener} */
+    addEventListener<K extends keyof EvMap, Ev extends EvMap[K]>(type: K, listener: $EventListener<this, Ev> | $EventListenerObject<this, Ev>, options?: boolean | AddEventListenerOptions): this;
+    addEventListener(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | AddEventListenerOptions): this;
+    /** {@link EventTarget.removeEventListener} */
+    removeEventListener<K extends keyof EvMap, Ev extends EvMap[K]>(type: K, listener: $EventListener<this, Ev> | $EventListenerObject<this, Ev>, options?: boolean | EventListenerOptions): this;
+    removeEventListener(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | EventListenerOptions): this;
+    /** {@link EventTarget.dispatchEvent} */
+    dispatchEvent(event: Event): boolean;
+    
+    on<K extends keyof EvMap, Ev extends EvMap[K]>(type: K, listener: $EventListener<this, Ev> | $EventListenerObject<this, Ev>, options?: boolean | AddEventListenerOptions): this;
+    on(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | AddEventListenerOptions): this;
+
+    off<K extends keyof EvMap, Ev extends EvMap[K]>(type: K, listener: $EventListener<this, Ev> | $EventListenerObject<this, Ev>, options?: boolean | EventListenerOptions): this;
+    off(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | EventListenerOptions): this;
+
+    once<K extends keyof EvMap, Ev extends EvMap[K]>(type: K, listener: $EventListener<this, Ev> | $EventListenerObject<this, Ev>, options?: boolean | AddEventListenerOptions): this;
+    once(type: string, listener: $EventListener<this, Event> | $EventListenerObject<this, Event>, options?: boolean | AddEventListenerOptions): this;
+}

package/src/node/$Node.ts

@@ -1,15 +1,15 @@
 import { chain } from "#lib/chain";
 import { _document } from "#lib/env";
-import { _Array_from, _instanceof, _JSON_stringify, _null, _Promise, forEach, isBoolean, isFunction, isNull, isObject, isUndefined } from "#lib/native";
+import { _Array_from, _instanceof, _JSON_stringify, _null, _Promise, forEach, isFunction, isNull, isUndefined } from "#lib/native";
 import { toArray } from "#lib/toArray";
-import { Signal } from "#structure/Signal";
+import { $EventTarget } from "./$EventTarget";
 
-export class $Node {
-    node: Node & ChildNode;
+export class $Node<EvMap = {}> extends $EventTarget<EvMap> {
+    declare node: Node & ChildNode & ParentNode;
+    static processors = new Set<$NodeContentProcessor>();
+    static setters = new Set<$NodeSetterHandler>();
     constructor(node: Node & ChildNode) {
-        this.node = node;
-        //@ts-expect-error
-        this.node.$ = this;
+        super(node);
     }
 
     content(children: $NodeContentResolver<this>) {
@@ -21,7 +21,10 @@ export class $Node {
 
     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);
+            if (position >= 0) position++;
+        }));
         return this;
     }
 
@@ -58,50 +61,19 @@ 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> {
+        for (const processor of this.processors) {
+            const result = processor($node, content);
+            if (result) return result;
+        }
         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];
-                }
-            } 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();
-            }
+            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();
         }
         // is nested array
         if (_instanceof(content, Array)) return content.map(c => this.process($node, c)).flat();
@@ -122,17 +94,18 @@ export class $Node {
 }
 
 export class $Text extends $Node {
-    signals = new Set<Signal<any>>();
     constructor(textContent?: string) {
         super(new Text(textContent));
     }
 }
 
+export type $NodeSetterHandler = (value: any, set: (value: any) => void) => any;
+export type $NodeContentProcessor = <N extends $Node>($node: N, content: $NodeContentResolver<N>) => Array<$Node | undefined | null> | void | undefined;
 export type $NodeContentHandler<T extends $Node> = ($node: T) => OrPromise<$NodeContentResolver<T>>;
-export type $NodeContentTypes = $Node | string | number | boolean | $.SignalFunction<any> | null | undefined;
+export type $NodeContentTypes = $Node | string | number | boolean | $.$NodeContentTypeExtends | null | undefined;
 export type $NodeContentResolver<T extends $Node> = OrPromise<$NodeContentTypes | $NodeContentHandler<T> | $NodeContentResolver<T>[]>;
 
-export interface $Node {
+export interface $Node<EvMap = {}> extends $EventTarget<EvMap> {
     /** {@link Node.baseURI} */
     readonly baseURI: string;
     /** {@link Node.childNodes} */
@@ -157,13 +130,21 @@ export interface $Node {
     readonly parentNode?: ParentNode | null;
     /** {@link Node.previousSibling} */
     readonly previousSibling?: ChildNode | null;
+    /** {@link ParentNode.childElementCount} */
+    readonly childElementCount: number;
+    /** {@link ParentNode.children} */
+    readonly children: HTMLCollection;
+    /** {@link ParentNode.firstElementChild} */
+    readonly firstElementChild: Element | null;
+    /** {@link ParentNode.lastElementChild} */
+    readonly lastElementChild: Element | null;
     
     /** {@link Node.appendChild} */
     appendChild<T extends Node>(node: T): T;
     /** {@link Node.cloneNode} */
     cloneNode(subtree?: boolean): Node;
     /** {@link Node.compareDocumentPosition} */
-    compareDocumentPosition(other: Node): number;
+    compareDocumentPosition(other: $EventTarget | Node): number;
     /** {@link Node.getRootNode} */
     getRootNode(options?: GetRootNodeOptions): Node;
     /** {@link Node.hasChildNodes} */
@@ -173,9 +154,9 @@ export interface $Node {
     /** {@link Node.isDefaultNamespace} */
     isDefaultNamespace(namespace: string | null): boolean;
     /** {@link Node.isEqualNode} */
-    isEqualNode(otherNode: Node | null): boolean;
+    isEqualNode(otherNode: $EventTarget | Node | null): boolean;
     /** {@link Node.isSameNode} */
-    isSameNode(otherNode: Node | null): boolean;
+    isSameNode(otherNode: $EventTarget | Node | null): boolean;
     /** {@link Node.lookupNamespaceURI} */
     lookupNamespaceURI(prefix: string | null): string | null;
     /** {@link Node.lookupPrefix} */
@@ -186,20 +167,34 @@ export interface $Node {
     removeChild<T extends Node>(child: T): T;
     /** {@link Node.replaceChild} */
     replaceChild<T extends Node>(node: Node, child: T): T;
-    /** {@link Node.replaceChild} */
-    after(...nodes: (Node | string)[]): this;
-    /** {@link Node.replaceChild} */
-    before(...nodes: (Node | string)[]): this;
-    /** {@link Node.replaceChild} */
+    /** {@link Node.contains} */
+    contains(other: $EventTarget | Node | null | undefined): boolean;
+
+    /** {@link ChildNode.after} */
+    after(...nodes: ($EventTarget | Node | string)[]): this;
+    /** {@link ChildNode.before} */
+    before(...nodes: ($EventTarget | Node | string)[]): this;
+    /** {@link ChildNode.remove} */
     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 ChildNode.replaceWith} */
+    replaceWith(...nodes: ($EventTarget | Node | string)[]): this;
+    /** {@link ParentNode.append} */
+    append(...nodes: ($EventTarget | Node | string)[]): this;
+    /** {@link ParentNode.prepend} */
+    prepend(...nodes: ($EventTarget | Node | string)[]): this;
+    /** {@link ParentNode.querySelector} */
+    querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+    querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+    querySelector<K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+    querySelector<E extends Element = Element>(selectors: string): E | null;
+    /** {@link ParentNode.querySelectorAll} */
+    querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+    querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+    querySelectorAll<K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+    querySelectorAll<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
+    /** {@link ParentNode.replaceChildren} */
+    replaceChildren(...nodes: ($EventTarget | Node | string)[]): this;
 
     /** {@link Node.nodeValue} */
     nodeValue(nodeValue: $Parameter<string | null>): this;

package/src/node/$Virtual.ts

@@ -0,0 +1,65 @@
+import { chain } from "#lib/chain";
+import { forEach, _Array_from, _instanceof, _null } from "#lib/native";
+import { toArray } from "#lib/toArray";
+import { $HTMLElement } from "#node/$HTMLElement";
+import { $Node, type $NodeContentResolver } from "#node/$Node";
+
+export class $Virtual<Ele extends HTMLElement = HTMLElement, EvMap = HTMLElementEventMap> extends $HTMLElement<Ele, EvMap> {
+    nodes = new Set<$Node>();
+    hiddenNodes = new Set<$Node>();
+    constructor(resolver: string | Ele) {
+        super(resolver);
+    }
+
+    content(children: $NodeContentResolver<this>) {
+        return chain(this, _null, _null, children, children => {
+            this.nodes.clear();
+            forEach(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 => {
+                $Virtual.append(this, $node, position)
+                if (position >= 0) position++;
+            })
+        });
+        return this;
+    }
+
+    hide($node?: $Node | null) {
+        if ($node && this.nodes.has($node)) this.hiddenNodes.add($node);
+        return this;
+    }
+
+    show($node?: $Node | null) {
+        if ($node) this.hiddenNodes.delete($node);
+        return this;
+    }
+
+    render() {
+        // remove hidden node
+        forEach(this.childNodes, node => this.hiddenNodes.has($(node)) && node.remove());
+        // add visible node with position
+        forEach(this.nodes, ($node, i) => {
+            if (
+                !this.hiddenNodes.has($node) // node is not hidden
+                && !$node.inDOM() // node is not in dom tree
+                && $(this.childNodes).at(i) !== $node // node not matched at position
+            ) $Node.append(this, $node, i);
+        })
+        return this;
+    }
+
+    static append($node: $Virtual, child: $Node | undefined | null, position: number) {
+        if (child) {
+            const childList = _Array_from($node.nodes);
+            if (!childList.at(position)) childList.push(child);
+            else childList.splice(position >= 0 ? position : childList.length + 1 + position, 0, child);
+            $node.nodes = new Set(childList);
+        }
+    }
+}

package/src/node.ts

@@ -1,10 +1,11 @@
 import { $HTMLElement } from '#node/$HTMLElement';
-import { assignHelper } from '#lib/assignHelper';
+import { assignProperties } from '#lib/assignProperties';
 import { $Element } from '#node/$Element';
 import { $Node, $Text } from '#node/$Node';
+import { $EventTarget } from '#node/$EventTarget';
 
-assignHelper(EventTarget, $Node);
-assignHelper(Node, $Node);
-assignHelper(Text, $Text);
-assignHelper(Element, $Element);
-assignHelper(HTMLElement, $HTMLElement);
+assignProperties(EventTarget, $EventTarget);
+assignProperties(Node, $Node);
+assignProperties(Text, $Text);
+assignProperties(Element, $Element);
+assignProperties(HTMLElement, $HTMLElement);

package/ext/i18n/src/node/I18nText.ts

@@ -1,35 +0,0 @@
-import { _Array_from, isUndefined } from "amateras/lib/native";
-import { $HTMLElement } from "amateras/node/$HTMLElement";
-import type { I18n } from "#structure/I18n";
-
-export class I18nText extends $HTMLElement<HTMLElement, { i18nupdate: Event }> {
-    i18n: I18n;
-    key: string;
-    options: I18nTextOptions | undefined;
-    constructor(i18n: I18n, key: string, options?: I18nTextOptions) {
-        super('text');
-        this.i18n = i18n;
-        this.key = key;
-        this.options = options;
-        i18n.locale$.signal.subscribe(() => this.update())
-        this.update();
-    }
-    
-    async update() {
-        update: {
-            const {key, i18n} = this;
-            const dictionary = i18n.dictionary();
-            if (!dictionary) {this.content(key); break update}
-            const target = await dictionary.find(key);
-            if (isUndefined(target)) break update;
-            const snippets = target.split(/\$[a-zA-Z0-9_]+\$/);
-            if (snippets.length === 1 || !this.options) {this.content(target); break update}
-            const matches = target.matchAll(/(\$([a-zA-Z0-9_]+)\$)/g);
-            this.content(snippets.map(text => [text, this.options?.[matches.next().value?.at(2)!] ?? null]));
-        }
-        this.dispatchEvent(new Event('i18nupdate'));
-        return this;
-    }
-}
-
-export type I18nTextOptions = {[key: string]: any}

package/ext/markdown/index.ts

@@ -1,121 +0,0 @@
-import { _Array_from, forEach } from "amateras/lib/native";
-
-const blockProcesses = new Set<MarkdownBlockProcessOptions>();
-const inlineProcesses = new Set<MarkdownProcessFunction>();
-
-export class Markdown {
-    blockProcessSet = new Set(blockProcesses);
-    inlineProcessSet = new Set(inlineProcesses);
-    constructor() {}
-
-    blockProcess(options: MarkdownBlockProcessOptions) {
-        this.blockProcessSet.add(options);
-        return this;
-    }
-
-    inlineProcess(handle: MarkdownProcessFunction) {
-        this.inlineProcessSet.add(handle);
-        return this;
-    }
-
-    toHTML(text: string) {
-        const blocks = _Array_from(text.matchAll(/(?:.+?\n?)+/gm));
-        return blocks.map(block => {
-            let matched, blockText = block[0]
-            for (const blockProcess of blockProcesses) {
-                matched = blockText.match(blockProcess.regexp);
-                if (!matched) continue;
-                blockText = blockProcess.handle(blockText);
-                const removeHTML = blockText.replaceAll(/<.+>[^<]+?<\/.+>/gm, '');
-                if (!removeHTML) break;
-            }
-            if (!matched) blockText = paragraph(blockText);
-            inlineProcesses.forEach(fn => blockText = fn(blockText))
-            return blockText;
-        }).join('')
-    }
-
-    toDOM(text: string) {
-        return $('article').innerHTML(this.toHTML(text))
-    }
-}
-
-export type MarkdownProcessFunction = (text: string) => string;
-export interface MarkdownBlockProcessOptions {
-    regexp: RegExp,
-    handle: (text: string) => string;
-}
-
-const blockProcess = (options: MarkdownBlockProcessOptions) => blockProcesses.add(options);
-const inlineProcess = (handle: MarkdownProcessFunction) => inlineProcesses.add(handle);
-const replaceAll = (str: string, searchValue: string | RegExp, replacer: ((substring: string, ...args: any[]) => string) | string): string => str.replaceAll(searchValue, replacer as any);
-const trim = (str: string) => str.trim();
-const paragraph = (str: string) => replaceAll(str, /(?:.+?\n?)+/gm, $0 => `<p>${trim($0)}</p>`);
-// Headings
-blockProcess({
-    regexp: /^(#+) (.+)/gm,
-    handle: text => replaceAll(text, /^(#+) (.+)/gm, (_, $1: string, $2) => `<h${$1.length}>${$2}</h${$1.length}>`)
-});
-blockProcess({
-    regexp: /^(.+)\n==+$/gm,
-    handle: text => replaceAll(text, /^(.+)\n==+$/gm, (_, $1) => `<h1>${$1}</h1>`)
-});
-blockProcess({
-    regexp: /^(.+)\n--+$/gm,
-    handle: text => replaceAll(text, /^(.+)\n--+$/gm, (_, $1) => `<h2>${$1}</h2>`)
-});
-// Blockquote
-blockProcess({
-    regexp: /(?:^> ?.*(?:\n|$))+/gm,
-    handle: text => {
-        const fn = (str: string) => {
-            const blocks = _Array_from(str.matchAll(/(?:^> ?.*(?:\n|$))+/gm));
-            forEach(blocks, block => {
-                const blocked = fn(replaceAll(block[0], /^> ?/gm, ''));
-                str = str.replace(block[0], `<blockquote>\n${paragraph(blocked)}\n</blockquote>`);
-            })
-            return str;
-        }
-        return fn(text);
-    }
-});
-// List
-blockProcess({
-    regexp: /(?:^(?:\t|(?:  )+)?(?:-|[0-9]+\.) (?:.+\n?))+/gm,
-    handle: text => {
-        const fn = (str: string) => {
-            const blocks = _Array_from(str.matchAll(/(?:^(?:\t|(?:  )+)?(?:-|[0-9]+\.) (?:.+\n?))+/gm));
-            forEach(blocks, block => {
-                let haveList = false // check this loop have list
-                const type = block[0].match(/^(-|[0-9]+\.) /)?.[1] === '-' ? 'ul' : 'ol';
-                const listed = replaceAll(block[0], /^(?:-|[0-9]+\.) (.+)/gm, (_, $1: string) => (haveList = true, `<li>\n${trim($1)}\n</li>`));
-                const clearTabbed = replaceAll(listed, /^(?:\t|(?:  ))/gm, '');
-                const convertedList = fn(clearTabbed);
-                str = str.replace(block[0], haveList ? `<${type}>\n${trim(convertedList)}\n</${type}>` : convertedList);
-            })
-            return str;
-        }
-        return fn(text);
-    }
-})
-// Codeblock
-blockProcess({
-    regexp: /^```([^`\n]+)\n([^`]+)?```/gm,
-    handle: text => replaceAll(text, /^```([^`\n]+)\n([^`]+)?```/gm, (_, $1, $2: string) => `<pre><code>\n${trim($2)}\n</code></pre>`)
-})
-// Horizontal Rule
-blockProcess({
-    regexp: /^(?:---|\*\*\*|___)(\s+)?$/gm,
-    handle: text => replaceAll(text, /^(?:---|\*\*\*|___)(\s+)?$/gm, _ => `<hr>`)
-})
-// Bold
-inlineProcess(text => replaceAll(text, /\*\*([^*]+?)\*\*/g, (_, $1) => `<b>${$1}</b>`));
-// Italic
-inlineProcess(text => replaceAll(text, /\*([^*]+?)\*/g, (_, $1) => `<i>${$1}</i>`));
-// Image
-inlineProcess(text => replaceAll(text, /!\[(.+?)\]\((.+?)(?: "(.+?)?")?\)/g, (_, alt, src, title) => `<img src="${src}" alt="${alt}"${title ? ` title="${title}"` : ''}>`));
-// Link
-inlineProcess(text => replaceAll(text, /\[(.+?)\]\((?:(\w\w+?:[^\s]+?)(?: "(.+?)?")?)\)/g, (_, content, href, title) => `<a href="${href}"${title ? ` title="${title}"` : ''}>${content}</a>`));
-inlineProcess(text => replaceAll(text, /\[(.+?)\]\((?:(\w+?@(?:\w|\.\w)+?)(?: "(.+)?")?)\)/g, (_, content, mail, title) => `<a href="mailto:${mail}"${title ? ` title="${title}"` : ''}>${content}</a>`));
-inlineProcess(text => replaceAll(text, /<(\w\w+?:[^\s]+?)>/g, (_, href) => `<a href="${href}">${href}</a>`));
-inlineProcess(text => replaceAll(text, /<(\w+?@(?:\w|\.\w)+?)>/g, (_, mail) => `<a href="mailto:${mail}">${mail}</a>`));

package/ext/router/index.ts

@@ -1,73 +0,0 @@
-import type { AnchorTarget } from "#html/$Anchor";
-import { _bind, _Object_assign, forEach } from "#lib/native";
-import type { $NodeContentResolver } from "#node/$Node";
-import type { Page } from "./node/Page";
-import { Route } from "./node/Route";
-import { Router } from "./node/Router";
-import { RouterAnchor } from "./node/RouterAnchor";
-export * from "./node/Route";
-export * from "./node/Router";
-export * from "./node/Page";
-export * from "./node/RouterAnchor";
-
-declare module 'amateras/core' {
-    export function $<P extends string>(nodeName: 'route', path: P, builder: RouteBuilder<Route<P>, RouteDataResolver<P>>): Route<P>;
-    export function $(nodeName: 'router', page?: Page<any>): Router;
-    export function $(nodeName: 'ra'): RouterAnchor;
-    export namespace $ {
-        export function open(url: string | URL | Nullish, target?: AnchorTarget): typeof Router;
-        export function replace(url: string | URL | Nullish): typeof Router;
-        export function back(): typeof Router;
-        export function forward(): typeof Router;
-    }
-}
-
-declare global {
-    interface GlobalEventHandlersEventMap {
-        'routeopen': Event;
-    }
-}
-
-// assign methods
-_Object_assign($, {
-    open: _bind(Router.open, Router),
-    replace: _bind(Router.replace, Router),
-    back: _bind(Router.back, Router),
-    forward: _bind(Router.forward, Router)
-});
-// define styles
-forEach([
-    `router{display:block}`,
-    `page{display:block}`
-], $.style);
-// assign nodes
-$.assign([
-    ['router', Router],
-    ['route', Route],
-    ['ra', RouterAnchor]
-])
-
-export type RouteData = { params: any, query: any }
-export type RouteDataResolver<P extends string> = { params: Prettify<PathParams<P>>, query: Prettify<PathQuery<P>> }
-export type AsyncRoute<P extends string> = () => Promise<{default: Route<P>}>
-export type RouteBuilder<R extends Route<any>, D extends RouteData> = (page: Page<R, D>) => OrPromise<$NodeContentResolver<Page<R, D>>>;
-
-type PathParams<Path> = Path extends `${infer Segment}/${infer Rest}`
-    ? Segment extends `${string}:${infer Param}` 
-        ? Record<Param, string> & PathParams<Rest> 
-        : PathParams<Rest>
-    : Path extends `${string}:${infer Param}?${infer Query}`
-        ? Record<Param, string> 
-    : Path extends `${string}:${infer Param}` 
-        ? Record<Param, string> 
-        : {}
-
-type PathQuery<Path> = Path extends `${string}?${infer Segment}`
-    ? PathQuery_SetRecord<Segment>
-    : Path extends `&${infer Segment}`
-        ? PathQuery_SetRecord<Segment>
-        : {}
-
-type PathQuery_SetRecord<Segment extends string> = Segment extends `${infer Param}&${infer Rest}` 
-    ? Record<Param, string> & PathQuery<`&${Rest}`>
-    : Record<Segment, string>

package/ext/router/node/Page.ts

@@ -1,27 +0,0 @@
-import { chain } from "#lib/chain";
-import { isUndefined } from "#lib/native";
-import { $HTMLElement } from "#node/$HTMLElement";
-import type { RouteData } from "..";
-import type { Route } from "./Route";
-
-export class Page<R extends Route<any> = any, Data extends RouteData = any> extends $HTMLElement {
-    route: R;
-    page: this;
-    params: Data['params'];
-    query: Data['query'];
-    #pageTitle: null | string = null;
-    initial = false;
-    constructor(route: R, data?: {params: any, query: any}) {
-        super('page');
-        this.route = route;
-        this.page = this;
-        this.params = data?.params ?? {};
-        this.query = data?.query ?? {};
-    }
-
-    pageTitle(): string | null;
-    pageTitle(title: string | null): this;
-    pageTitle(title?: string | null) {
-        return chain(this, arguments, () => this.#pageTitle, title, title => this.#pageTitle = title)
-    }
-}

package/ext/router/node/Route.ts

@@ -1,54 +0,0 @@
-import { _instanceof, _Object_fromEntries, _Array_from, _Promise } from "#lib/native";
-import { $Element } from "#node/$Element";
-import type { AsyncRoute, RouteBuilder, RouteDataResolver } from "..";
-import { Page } from "./Page";
-
-export abstract class BaseRouteNode<Path extends string = string> extends $Element {
-    readonly path: Path;
-    routes = new Map<string, Route<any>>()
-    parent: BaseRouteNode<any> | null = null;
-    builder: RouteBuilder<Route<Path>, RouteDataResolver<Path>> | AsyncRoute<Path>
-    constructor(path: Path, builder: RouteBuilder<Route<Path>, RouteDataResolver<Path>> | AsyncRoute<Path>, nodeName: string) {
-        super(nodeName);
-        this.path = path;
-        this.builder = builder;
-    }
-
-    route<P extends string, J extends `${Path}${P}`>(
-        path: P, 
-        resolver: RouteBuilder<Route<J>, RouteDataResolver<J>> | Route<J> | AsyncRoute<J>, 
-        fn?: (route: Route<J>) => Route<J>
-    ) {
-        const fullPath = `${this.path}${path}`;
-        if (_instanceof(resolver, Route) && fullPath !== resolver.path) throw `Pathname not matched: ${path}`
-        const route = resolver instanceof Route ? resolver : new Route(fullPath as J, resolver);
-        route.parent = this;
-        fn && fn(route);
-        this.routes.set(path, route);
-        return this;
-    }
-}
-
-export class Route<Path extends string = string> extends BaseRouteNode<Path> {
-    constructor(path: Path, builder: RouteBuilder<Route<Path>, RouteDataResolver<Path>> | AsyncRoute<Path>) {
-        super(path, builder, 'route');
-    }
-
-    async build(data: {params: any, query: any} = {params: {}, query: {}}, page?: Page) {
-        page = page ?? new Page(this, data);
-        page.params = data.params;
-        page.initial = true;
-        let resolver: any = this.builder(page);
-        if (_instanceof(resolver, _Promise)) {
-            const result = await resolver as any;
-            // Module import
-            if (result[Symbol.toStringTag] === 'Module') {
-                page.route = this;
-                resolver = result.default.builder(page);
-            }
-            else resolver = result;
-        }
-        if (!_instanceof(resolver, Page)) page.content(resolver);
-        return page;
-    }
-}