amateras 0.5.0 → 0.7.0

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/markdown/package.json

@@ -1,8 +0,0 @@
-{
-    "name": "@amateras/markdown",
-    "peerDependencies": {
-        "amateras": "../../"
-    },
-    "imports": {
-    }
-}

package/ext/router/README.md

@@ -1,81 +0,0 @@
-# amateras/router
-
-## Usage
-```ts
-import 'amateras';
-import 'amateras/router';
-```
-
-## Create Route Map
-```ts
-// create home page route
-const HomePage = $('route', '/', page => page
-    .pageTitle('Home')
-    .content([
-        $('h1').content('Home')
-    ])
-)
-// append router and mapping home page route into router
-$(document.body).content([
-    $('router')
-    .route('/', HomePage)
-    .route('/hello', page => 'Hello!')
-    .listen() // start to listen path change
-])
-```
-
-## Router Anchor
-Use `RouterAnchor` to prevent load page when open link by default `HTMLAnchorElement` element.
-```ts
-$('ra').content('Contact').href('/contact');
-```
-
-## Common Methods
-- `$.open(url)`: Open page without load page.
-- `$.replace(url)`: Replace history state with url and open page.
-- `$.forward()`: Forward page.
-- `$.back()`: Back page.
-
-## Path Parameter and Query
-```ts
-$('router')
-.route('/user/@:username', page => {
-    console.log(page.params)
-})
-.route('/posts?search'), page => {
-    console.log(page.query)
-}
-.listen()
-// simulate page open
-.resolve('/user/@amateras') // { username: 'amateras' }
-.resolve('/posts"') // { }
-.resolve('/posts?search=tsukimi&user') // { search: 'tsukimi', user: '' }
-```
-
-## Nesting Route
-```ts
-const ContactPage = $('route', '/contact', page => page
-    .pageTitle('Home')
-    .content([
-        $('h1').content('Contact'),
-        // append router with page, nested routes will show in this router
-        $('router', page)
-    ])
-)
-
-const ContactEmailPage = $('route', '/contact/email', () => 'amateras@example.com')
-
-$('router')
-.route('/', HomePage)
-.route('/contact', ContactPage, route => route
-    .route('/', () => 'My name is Amateras.')
-    .route('/phone', () => '0123456789')
-    .route('/email', ContactEmailPage)
-)
-```
-
-## Async Route
-```ts
-$('router')
-.route('/about', () => import('./pages/about.ts'))
-```

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;
-    }
-}

package/ext/router/node/Router.ts

@@ -1,149 +0,0 @@
-import type { AnchorTarget } from "#html/$Anchor";
-import { _document } from "#lib/env";
-import { _Array_from, _instanceof, _JSON_parse, _JSON_stringify, _Object_entries, _Object_fromEntries, forEach, startsWith } from "#lib/native";
-import { Page } from "./Page";
-import { BaseRouteNode, Route } from "./Route";
-
-// history index
-let index = 0;
-const _addEventListener = addEventListener;
-const _location = location;
-const {origin} = _location;
-const _history = history;
-const _sessionStorage = sessionStorage;
-const documentElement = _document.documentElement;
-const [PUSH, REPLACE] = [1, 2] as const;
-const [FORWARD, BACK] = ['forward', 'back'] as const;
-const scrollStorageKey = '__scroll__';
-/** convert path string to URL object */
-const toURL = (path: string | URL) => 
-    _instanceof(path, URL) ? path : startsWith(path, 'http') ? new URL(path) : new URL(startsWith(path, origin) ? path : origin + path);
-
-type ScrollData = {[key: number]: {x: number, y: number}};
-const scrollRecord = (e?: Event) => {
-    const data = _JSON_parse(_sessionStorage.getItem(scrollStorageKey) ?? '{}') as ScrollData;
-    data[index] = { x: documentElement.scrollLeft, y: documentElement.scrollTop };
-    // e is Event when called from scroll or beforeload
-    if (!e) forEach(_Object_entries(data), ([i]) => +i > index && delete data[+i])
-    _sessionStorage.setItem(scrollStorageKey, _JSON_stringify(data));
-}
-/** handle history state with push and replace state. */
-const historyHandler = async (path: string | URL | Nullish, mode: 1 | 2, target?: AnchorTarget) => {
-    if (!path) return;
-    const url = toURL(path);
-    if (url.href === _location.href) return;
-    if (target && target !== '_self') return open(url, target);
-    if (url.origin !== origin) return open(url, target);
-    scrollRecord();
-    if (mode === PUSH) index += 1;
-    Router.direction = FORWARD;
-    _history[mode === PUSH ? 'pushState' : 'replaceState']({index}, '' , url);
-    for (let router of Router.routers) router.routes.size && await router.resolve(path);
-}
-// disable browser scroll restoration
-_history.scrollRestoration = 'manual';
-
-export class Router extends BaseRouteNode<''> {
-    static pageRouters = new Map<Page, Router>();
-    static routers = new Set<Router>();
-    pageMap = new Map<string, Page>();
-    static direction: 'back' | 'forward' = FORWARD;
-    constructor(page?: Page) {
-        super('', () => [], 'router')
-        Router.routers.add(this);
-        if (page) Router.pageRouters.set(page, this);
-    }
-
-    static open(path: string | URL | Nullish, target?: AnchorTarget) {
-        historyHandler(path, PUSH, target);
-        return this;
-    }
-
-    static back() {
-        _history.back();
-        return this;
-    }
-
-    static forward() {
-        _history.forward();
-        return this;
-    }
-
-    static replace(path: string | URL | Nullish) {
-        historyHandler(path, REPLACE);
-        return this;
-    }
-
-    async resolve(path: string | URL) {
-        const {pathname, searchParams, hash, href} = toURL(path);
-        const routeData = { params: {} as {[key: string]: string}, query: _Object_fromEntries(searchParams) }
-        const split = (p: string) => p.replaceAll(/\/+/g, '/').split('/').map(path => `/${path}`);
-
-        function determineRoute(parentRoute: BaseRouteNode<any>, path: string, hash: string | undefined): [route: Route | null, pathId: string][] {
-            const targetPathSplit = split(path);
-            hash && targetPathSplit.push(hash);
-            if (!parentRoute.routes.size) return [];
-            routeLoop: for (const route of _Array_from(parentRoute.routes.values()).sort((a, b) => b.path.length - a.path.length)) {
-                const routePathSplit = split(route.path);
-                let pathId = '';
-                splitLoop: for (let i = 0; i < routePathSplit.length; i++) {
-                    const pass = () => pathId += targetSnippet;
-                    const [routeSnippet, targetSnippet] = [routePathSplit[i], targetPathSplit[i]];
-                    if (!routeSnippet || !targetSnippet) continue routeLoop;
-                    // process params in path
-                    if (routeSnippet.includes(':')) {
-                        if (targetSnippet === '/') continue routeLoop;
-                        const [prefix, paramName] = routeSnippet.split(':') as [string, string];
-                        if (!startsWith(targetSnippet, prefix)) continue routeLoop;
-                        routeData.params[paramName] = targetSnippet.replace(`${prefix}`, '');
-                        pass();
-                        continue splitLoop;
-                    }
-                    if (routeSnippet === '/' && route.routes.size) continue splitLoop;
-                    if (routeSnippet !== targetSnippet) continue routeLoop;
-                    pass()
-                }
-                return [[route, pathId], ...determineRoute(route, path, hash)];
-            }
-            return [[null, parentRoute.path + '$$NOT_FOUND$$']];
-        }
-        // analytics
-        const targetRoutes = determineRoute(this, pathname + '/', hash);
-        // build pages
-        let prevPage: null | Page = null, prevRoute: BaseRouteNode<any> = this;
-        const appendPage = (prevRouter: Router | undefined, page: Page) => page.parentNode !== prevRouter?.node && prevRouter?.content(page);
-
-        for (const [route, pathId] of targetRoutes) {
-            const page = this.pageMap.get(pathId) ?? new Page(route ?? prevRoute.routes.get('404') ?? new Route('404', () => null), routeData);
-            if (!page.initial) await route?.build(routeData, page);
-            _document && (_document.title = page.pageTitle() ?? _document.title);
-            this.pageMap.set(pathId, page);
-            if (href === _location.href) appendPage(prevPage ? Router.pageRouters.get(prevPage) : this, page);
-            prevPage = page;
-            if (route) prevRoute = route;
-        }
-        let { x, y } = Router.scroll ?? {x: 0, y: 0};
-        scrollTo(x, y);
-        this.dispatchEvent(new Event('routeopen', {bubbles: true}));
-        return this;
-    }
-
-    listen() {
-        const resolve = () => {
-            const stateIndex = _history.state?.index ?? 0;
-            if (index > stateIndex) Router.direction = BACK;
-            if (index < stateIndex) Router.direction = FORWARD;
-            index = stateIndex;
-            this.resolve(_location.href);
-        }
-        _addEventListener('popstate', resolve);
-        _addEventListener('beforeunload', scrollRecord);
-        _addEventListener('scroll', scrollRecord, false);
-        resolve();
-        return this;
-    }
-
-    static get scroll(): ScrollData[number] {
-        return _JSON_parse(_sessionStorage.getItem(scrollStorageKey) ?? '{}')[index] ?? {x: 0, y: 0}
-    }
-}

package/ext/ssr/env.ts

@@ -1,61 +0,0 @@
-import { NODE } from "esm-env";
-import { _Array_from, _Object_assign, _Object_entries, isNull } from "../../src/lib/native";
-import type { $Node } from "../../src/node/$Node";
-
-if (NODE) {
-    //@ts-expect-error
-    global.window = undefined;
-    //@ts-expect-error
-    global.document = undefined;
-    //@ts-expect-error
-    global.Node = class Node {
-        nodeName: string;
-        attributes = {};
-        childNodes = new Set<Node>();
-        parent?: Node;
-        $!: $Node;
-        constructor(nodeName: string) {
-            this.nodeName = nodeName.toUpperCase();
-        }
-        get textContent() { return _Array_from(this.childNodes.values()).map(node => node.textContent).join() }
-        set textContent(content: string | null) { 
-            this.childNodes.clear();
-            content && this.childNodes.add(new Text(content) as unknown as Node);
-        }
-        appendChild(node: Node) {
-            if (this.childNodes.has(node)) this.childNodes.delete(node);
-            this.childNodes.add(node);
-            node.parent = this;
-        }
-        addEventListener(type: string, cb: () => void) { }
-        setAttribute(key: string, value: string) { _Object_assign(this.attributes, {[key]: value}) }
-        remove() {
-            this.parent?.removeChild(this);
-        }
-        removeChild(node: Node) {
-            this.childNodes.delete(node);
-        }
-
-        get outerHTML() {
-            const attr = _Object_entries(this.attributes).map(([key, value]) => `${key}="${value}"`).join(' ');
-            const tagName = this.nodeName.toLowerCase();
-            const IS_VOID_ELEMENT = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'].includes(tagName);
-            return `<${tagName}${attr ? ` ${attr}` : ''}>${_Array_from(this.childNodes).map(node => `${node.$}`).join('')}${IS_VOID_ELEMENT && !this.childNodes.size ? '' : `</${tagName}>`}`;
-        }
-    }
-    //@ts-expect-error
-    global.Element = class Element {}
-    //@ts-expect-error
-    global.HTMLElement = class HTMLElement {}
-    //@ts-expect-error
-    global.Text = class Text {
-        textContent: string;
-        $: this;
-        constructor(textContent: string) {
-            this.textContent = textContent;
-            this.$ = this;
-        }
-
-        toString() { return this.textContent }
-    }
-}

package/ext/ssr/index.ts

@@ -1,49 +0,0 @@
-import './env';
-import 'amateras';
-import { _Array_from, _instanceof, _Object_assign, _Object_defineProperty, forEach } from "amateras/lib/native";
-import { $Element } from 'amateras/node/$Element';
-import { BROWSER, NODE } from 'esm-env';
-import { $Node, $Text } from 'amateras/node/$Node';
-import { _document } from '../../src/lib/env';
-
-declare module 'amateras/core' {
-    export namespace $ {
-        export function mount(id: string, $node: $Element): void;
-        export function serverSide(cb: () => any): void;
-    }
-}
-
-export function onserver<T>(cb: () => T): T | '' {
-    if (NODE) return cb();
-    return '';
-}
-
-export function onclient<T>(cb: () => T): T | undefined {
-    if (BROWSER) return cb();
-    return;
-}
-
-_Object_assign($, {
-    mount(id: string, $node: $Element) {
-        if (!BROWSER) return;
-        const node = _document.querySelector(`#${id}`);
-        if (!node) throw 'Target node of mounting not found';
-        getData(node, $node);
-        node.replaceWith($node.node);
-    
-        function getData(node: Node, $node: $Node) {
-            if (node.nodeName === 'SIGNAL' && _instanceof(node, Element) && _instanceof($node, $Text)) {
-                const type = $(node).attr()['type'];
-                return forEach($node.signals, signal => signal.value(type === 'number' ? Number(node.textContent) : type === 'boolean' ? node.textContent == 'true' ? true : false : node.textContent));
-            }
-            if (_instanceof(node, Text)) return $node.textContent(node.textContent);
-            if (_instanceof(node, Element) && _instanceof($node, $Element)) $node.attr($(node).attr());
-            const arr = _Array_from($node.childNodes);
-            forEach(node.childNodes, (_node, i) => {
-                const targetChildNode = arr.at(i);
-                if (!targetChildNode) throw 'Target DOM tree not matched';
-                getData(_node, targetChildNode.$)
-            })
-        }
-    }
-})

package/ext/ssr/package.json

@@ -1,10 +0,0 @@
-{
-    "name": "@amateras/ssr",
-    "peerDependencies": {
-        "amateras": "../../",
-        "esm-env": "^1.2.2"
-    },
-    "imports": {
-        "#structure/*": "./src/structure/*.ts"
-    }
-}