amateras 0.10.1 → 0.10.2

package/packages/markdown/src/syntax/horizontalRule.ts

@@ -0,0 +1,11 @@
+import { HORIZONTAL_RULE } from "#lib/type";
+import { setBlockTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const horizontalRuleProcessor = (parser: MarkdownParser) => setProcessor(parser, HORIZONTAL_RULE, _ => `<hr>`)
+
+export const horizontalRuleTokenizer = (lexer: MarkdownLexer) => setBlockTokenizer(lexer, HORIZONTAL_RULE, {
+    regex: /^---/,
+    handle: _ => ({ content: [] })
+})

package/packages/markdown/src/syntax/image.ts

@@ -0,0 +1,23 @@
+import { IMAGE } from "#lib/type";
+import { setInlineTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const imageProcessor = (parser: MarkdownParser) => setProcessor(parser, IMAGE, token => {
+    const { url, title } = token.data!;
+    return `<img alt="${parser.parse(token.content!)}" src="${url}"${title ? ` title="${title}"` : ''}>`
+})
+
+export const imageTokenizer = (lexer: MarkdownLexer) => setInlineTokenizer(lexer, IMAGE, {
+    regex: /^!\[(.+?)\]\((.+?)\)/,
+    handle: matches => {
+        const [_, alt, detail] = matches as [string, string, string];
+        const [__, url, title] = detail.match(/(\w\w+?:\/\/[^\s]+)(?: "(.+?)")?/) as [string, string, string];
+        return {
+            content: lexer.inlineTokenize(alt),
+            data: {
+                url, title
+            }
+        }
+    }
+})

package/packages/markdown/src/syntax/italic.ts

@@ -0,0 +1,11 @@
+import { ITALIC } from "#lib/type";
+import { setInlineTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const italicProcessor = (parser: MarkdownParser) => setProcessor(parser, ITALIC, token => `<i>${parser.parse(token.content!)}</i>`)
+
+export const italicTokenizer = (lexer: MarkdownLexer) => setInlineTokenizer(lexer, ITALIC, {
+    regex: /\*(.+?)\*/,
+    handle: matches => ({ content: lexer.inlineTokenize(matches[1]!) })
+})

package/packages/markdown/src/syntax/link.ts

@@ -0,0 +1,46 @@
+import { LINK, QUICK_LINK } from "#lib/type";
+import { setInlineTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer, Token } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+import { isUndefined } from "@amateras/utils";
+
+export const linkProcessor = (parser: MarkdownParser) => {
+    const linkProcessor = (token: Token) => {
+        const {href, email, title} = token.data!;
+        return `<a href="${isUndefined(href) ? `mailto:${email}` : href}"${title ? ` title="${title}"` : ''}>${token.text ?? parser.parse(token.content!)}</a>`
+    }
+    setProcessor(parser, QUICK_LINK, linkProcessor)
+    setProcessor(parser, LINK, linkProcessor)
+}
+
+export const linkTokenizer = (lexer: MarkdownLexer) => {
+
+    setInlineTokenizer(lexer, LINK, {
+        regex: /\[(.+?)\]\(((?:\w+?@(?:\w|\.\w)+)|(?:\w\w+?:[^\s)]+))(?: "(.+)?")?\)/,
+        handle: matches => {
+            const [_, alt, detail, title] = matches as [string, string, string, string];
+            const match = detail.match(/(?:\w+?@(?:\w|\.\w)+)|(?:\w\w+?:\/\/[^\s]+)/);
+            const [resolver] = match!;
+            const email_or_href = resolver.includes('@') ? { email: resolver }: { href: resolver };
+            return {
+                content: lexer.inlineTokenize(alt),
+                data: {
+                    title, ...email_or_href
+                }
+            }
+        }
+    })
+    setInlineTokenizer(lexer, QUICK_LINK, {
+        regex: /<((?:\w+?@(?:\w|\.\w)+)|(?:\w\w+?:[^\s>]+))>/,
+        handle: matches => {
+            const [_, detail] = matches as [string, string];
+            const match = detail.match(/(?:\w+?@(?:\w|\.\w)+)|(?:\w\w+?:\/\/[^\s]+)/);
+            const [resolver] = match!;
+            const email_or_href = resolver.includes('@') ? { email: resolver }: { href: resolver };
+            return {
+                content: resolver,
+                data: email_or_href
+            }
+        }
+    })
+}

package/packages/markdown/src/syntax/list.ts

@@ -0,0 +1,121 @@
+import { EMPTY_LINE, ORDERED_LIST_ITEM, TEXT_LINE, UNORDERED_LIST_ITEM } from "#lib/type";
+import { htmltag, setBlockTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer, Token } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+import { isEqual, isString } from "@amateras/utils";
+
+export const listProcessor = (parser: MarkdownParser) => {
+    const listType = (type: string) => type === ORDERED_LIST_ITEM ? 'ol' : 'ul'
+    const listProcessor = (token: Token, tokens: Token[]) => {
+        let i = 0;
+        // cache the list by deep number
+        const deepListMap = new Map<number, List>();
+
+        const listGenerator = (type: string, deep: number) => {
+            const getList = deepListMap.get(deep)
+            const list = getList && listType(type) === getList.tagname ? getList : List(listType(type), []);
+            deepListMap.set(deep, list);
+
+            while (i < tokens.length) {
+                const token = tokens[i]!;
+                const tokenType = token.type;
+                // if token type not equal list item / empty line / text line, then finish loop
+                if (!isEqual(tokenType, [ORDERED_LIST_ITEM, UNORDERED_LIST_ITEM, EMPTY_LINE, TEXT_LINE])) { i--; break};
+                // if token type equal text line
+                if (tokenType === TEXT_LINE) {
+                    const text = token.content![0]?.text;
+                    // if text start with double space
+                    if (text?.match(/^\s\s/)) {
+                        const match = text.match(/^(\s+)(.+)?/)!;
+                        // if no content, then next token
+                        if (!match[2]) { i++; continue }
+                        token.data = { deep: Math.trunc(match[1]!.length / 2) - 1 }
+                    }
+                    // if text start with tab
+                    else if (text?.match(/^\t/)) {
+                        const match = text.match(/^(\t+)(.+)?/)!;
+                        // if no content, then next token
+                        if (!match[2]) { i++; continue }
+                        token.data = { deep: match[1]!.length - 1 }
+                    }
+                    // else break 
+                    else {i--; break};
+                }
+                // if token type equal empty line, jump to next token
+                if (tokenType === EMPTY_LINE) i++;
+                // if token deep number not equal latest deep of list
+                else if (token.data!.deep !== deep) {
+                    // if bigger, push deeper list into current list item
+                    if (token.data!.deep > deep) deepListMap.get(deep)?.items.at(-1)?.content.push(listGenerator(tokenType, token.data!.deep))
+                    // else delete current deep cache and return to upper list
+                    else { deepListMap.delete(deep); break; }
+                }
+                // if token type equal text line, convert this list to paragraph mode
+                else if (tokenType === TEXT_LINE) {
+                    list.paragraph = true;
+                    list.items.at(-1)?.content.push(parser.parse(token.content!))
+                    i++
+                }
+                // if list type not equal, then finish loop
+                else if (tokenType !== type) {
+                    deepListMap.delete(deep);
+                    break;
+                }
+                // push list item
+                else {
+                    list.items.push(ListItem([parser.parse(token.content!)]));
+                    i++
+                }
+            }
+            return list;
+        }
+
+        return {
+            html: `${listGenerator(token.type, token.data!.deep)}`,
+            skipTokens: i
+        }
+    }
+
+    interface ListItem { content: (string | List)[], toString(): string }
+    const ListItem = (content: (string | List)[]): ListItem => ({
+        content: content,
+        toString() { return htmltag('li', this.content.join('')) }
+    })
+
+    interface List { tagname: string, items: ListItem[], paragraph: boolean, toString(): string }
+    const List = (tagname: 'ul' | 'ol', items: ListItem[]): List => ({
+        tagname: tagname,
+        items: items,
+        paragraph: false,
+        toString() {
+            if (this.paragraph) this.items.forEach(item => item.content.forEach((text, i) => isString(text) && (item.content[i] = htmltag('p', text))))
+            return htmltag(this.tagname, this.items.join(''))
+        }
+    })
+
+    setProcessor(parser, UNORDERED_LIST_ITEM, listProcessor);
+    setProcessor(parser, ORDERED_LIST_ITEM, listProcessor);
+}
+
+export const listTokenizer = (lexer: MarkdownLexer) => {
+    const listHandle = (matches: RegExpMatchArray) => {
+        const prefix = matches[0].split(/[-*]/)[0]!;
+        const spaces = prefix.match(/\s/)?.length ?? 0;
+        const tabs = prefix.match(/\t/)?.length ?? 0;
+        return ({
+        content: lexer.inlineTokenize(matches[1]!),
+        data: {
+            deep: Math.trunc(tabs + spaces / 2)
+        }
+    })
+    }
+    setBlockTokenizer(lexer, UNORDERED_LIST_ITEM, {
+        regex: /^(?:[\s\t]+)?[-*] (.+)/,
+        handle: listHandle
+    })
+
+    setBlockTokenizer(lexer, ORDERED_LIST_ITEM, {
+        regex: /^(?:[\s\t]+)?\d+\. (.+)/,
+        handle: listHandle
+    })
+}

package/packages/markdown/src/syntax/table.ts

@@ -0,0 +1,67 @@
+import { BLOCK, TABLE, TABLE_COLUMN, TABLE_ROW } from "#lib/type";
+import { htmltag, setBlockTokenizer, setProcessor } from "#lib/util";
+import type { BlockToken, MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+import { _Array_from } from "@amateras/utils";
+
+export const tableProcessor = (parser: MarkdownParser) => setProcessor(parser, TABLE, (token) => {
+        let thead = '';
+        let tbody = '';
+        let rowIndex = 0;
+        for (const row of token.content!) {
+            let rowHTML = '';
+            for (let i = 0; i < row.content!.length; i++) {
+                const col = row.content![i]!;
+                const align = token.data!.align[i];
+                const tagname = rowIndex === 0 ? 'th' : 'td';
+                rowHTML += `<${tagname} align="${align ?? 'left'}">${parser.parse(col.content!)}</${tagname}>`
+            }
+            if (rowIndex === 0) thead += htmltag('thead', htmltag('tr', rowHTML));
+            else tbody += htmltag('tr', rowHTML);
+            rowIndex++
+        }
+        tbody = htmltag('tbody', tbody);
+        return htmltag('table', thead + tbody)
+    })
+
+export const tableTokenizer = (lexer: MarkdownLexer) => setBlockTokenizer(lexer, TABLE, {
+        regex: /\|(?:.+\|)+/,
+        handle(_, position, lines) {
+            const tokens: BlockToken[] = [];
+            const align = []
+            while (position < lines.length) {
+                const row: BlockToken = {
+                    type: TABLE_ROW,
+                    layout: BLOCK,
+                    content: []
+                }
+                const line = lines[position]!;
+                const matches = _Array_from(line.matchAll(/\| ([^|]+)/g));
+                if (!matches.length) break;
+                for (const match of matches) {
+                    const text = match[1]!;
+                    const separator = text.match(/(:)?---+(:)?/);
+                    if (separator) {
+                        const [_, LEFT, RIGHT] = separator;
+                        align.push(RIGHT ? LEFT ? 'center' : 'right' : 'left');
+                        continue;
+                    }
+                    row.content.push({
+                        type: TABLE_COLUMN,
+                        content: lexer.inlineTokenize(text.trim()),
+                        layout: BLOCK
+                    })
+                }
+                if (row.content.length) tokens.push(row);
+                position++
+            }
+            return {
+                content: tokens,
+                data: { align },
+                multiLine: {
+                    skip: position,
+                    tokens: []
+                }
+            }
+        },
+    })

package/packages/markdown/src/syntax/text.ts

@@ -0,0 +1,19 @@
+import { EMPTY_LINE, TEXT, TEXT_LINE } from "#lib/type";
+import { htmltag, setProcessor } from "#lib/util";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const textProcessor = (parser: MarkdownParser) => setProcessor(parser, TEXT, token => token.text!);
+
+export const textLineProcessor = (parser: MarkdownParser) => setProcessor(parser, TEXT_LINE, (_, tokens) => {
+    let html = '';
+    let i = 0;
+    for (const token of tokens) {
+        if (token.type === EMPTY_LINE) break;
+        html += parser.parse(token.content!);
+        i++;
+    }
+    return {
+        html: htmltag('p', html),
+        skipTokens: i
+    };
+})

package/packages/match/package.json

@@ -0,0 +1,15 @@
+{
+    "name": "@amateras/match",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/signal": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts"
+    },
+    "exports": {
+      ".": "./src/index.ts"
+    }
+}

package/packages/match/src/global.ts

@@ -0,0 +1,14 @@
+import * as _Case from "#structure/Case";
+import * as _Default from "#structure/Default";
+import * as _Match from "#structure/Match";
+import type { Signal } from "@amateras/signal";
+
+declare global {
+    export var Match: typeof _Match.Match
+    export var Case: typeof _Case.Case
+    export var Default: typeof _Default.Default
+
+    export function $<T>(Match: typeof _Match.Match, expression: Signal<T>, layout: _Match.MatchLayout<T>): _Match.Match<T>
+    export function $(Case: typeof _Case.Case, condition: any, layout: _Case.CaseLayout): _Case.Case;
+    export function $(Default: typeof _Default.Default, layout: _Default.DefaultLayout): _Default.Default;
+}

package/packages/match/src/index.ts

@@ -0,0 +1,33 @@
+import { Case } from "#structure/Case";
+import { Default } from "#structure/Default";
+import { Match } from "#structure/Match";
+import { Proto } from '@amateras/core';
+import { _instanceof, is, isEqual } from '@amateras/utils';
+import './global';
+
+globalThis.Match = Match;
+globalThis.Case = Case;
+globalThis.Default = Default;
+
+$.process.craft.add((value, arg1, arg2) => {
+    if (import.meta.hot) {
+        if (_instanceof(Proto.proto, Match)) {
+            if (!isEqual(value, [Case, Default])) throw 'Match layout only includes Case and Default';
+        }
+        else {
+            if (value === Case) throw 'Case must be inside Match layout';
+            if (value === Default) throw 'Default must be inside Match layout';
+        }
+    }
+    if (value === Match) {
+        let proto = new Match(arg1, arg2);
+        proto.parent = Proto.proto;
+        return proto
+    }
+    if (value === Case) {
+        return is(Proto.proto, Match)?.case(arg1, arg2)
+    }
+    if (value === Default) {
+        return is(Proto.proto, Match)?.default(arg1)
+    }
+})

package/packages/match/src/structure/Case.ts

@@ -0,0 +1,15 @@
+import { symbol_Statement } from "@amateras/core";
+import { Proto } from "@amateras/core";
+import { isArray } from "@amateras/utils";
+
+export type CaseLayout = () => void;
+
+export class Case extends Proto {
+    static override [symbol_Statement] = true;
+    declare statementType: 'Case';
+    condition: any[]
+    constructor(condition: any, layout: CaseLayout) {
+        super(layout);
+        this.condition = isArray(condition) ? condition : [condition];
+    }
+}

package/packages/match/src/structure/Default.ts

@@ -0,0 +1,12 @@
+import { symbol_Statement } from "@amateras/core";
+import { Proto } from "@amateras/core";
+
+export type DefaultLayout = () => void;
+
+export class Default extends Proto {
+    static override [symbol_Statement] = true;
+    declare statementType: 'Default';
+    constructor(layout: DefaultLayout) {
+        super(layout);
+    }
+}

package/packages/match/src/structure/Match.ts

@@ -0,0 +1,78 @@
+import { symbol_Statement } from "@amateras/core";
+import { ProxyProto } from "@amateras/core";
+import type { Signal } from "@amateras/signal";
+import { _null, forEach } from "@amateras/utils";
+import { Case, type CaseLayout } from "./Case";
+import { Default, type DefaultLayout } from "./Default";
+
+export type MatchLayout<T> = (match: MatchCraftFunction<T>) => void;
+export interface MatchCraftFunction<T> {
+    (d: typeof Default, layout: DefaultLayout): void;
+    (c: typeof Case, condition: T | T[], layout: CaseLayout): void;
+}
+
+export class Match<T = any> extends ProxyProto {
+    static override [symbol_Statement] = true;
+    declare statementType: 'Match';
+    exp$: Signal<T>
+    declare protos: Set<Case>;
+    cases = new Set<Case>();
+    matched: Case | Default | null = _null;
+    #default: Default | null = _null;
+    constructor(expression: Signal<T>, layout: MatchLayout<T>) {
+        super(() => {
+            layout((constructor, arg1, arg2?) => {
+                $(constructor as any, arg1, arg2);
+            });
+        });
+        this.exp$ = expression;
+    }
+
+    override build(): this {
+        super.build();
+        this.validate();
+        // update function for Signal subscribe
+        let update = () => {
+            let prevMatchedProto = this.matched;
+            let matchProto = this.validate();
+            if (prevMatchedProto === matchProto) return;
+            forEach(this.cases, proto => proto !== matchProto && proto.removeNode())
+            if (matchProto !== this.#default) this.#default?.removeNode();
+            this.node?.replaceWith(...this.toDOM());
+        }
+        // build cases proto and subscribe expression signal
+        forEach(this.cases, proto => {
+            proto.build();
+            this.exp$.subscribe(update);
+            proto.disposers.add(() => this.exp$.unsubscribe(update));
+        })
+        this.#default?.build();
+        return this;
+    }
+
+    case(condition: T, layout: CaseLayout) {
+        let caseProto = new Case(condition, layout);
+        this.cases.add(caseProto);
+        return caseProto;
+    }
+
+    default(layout: DefaultLayout) {
+        let defaultProto = new Default(layout);
+        this.#default = defaultProto;
+        return defaultProto;
+    }
+
+    validate() {
+        this.clear();
+        for (let proto of this.cases) {
+            if (proto.condition.includes(this.exp$.value)) {
+                proto.parent = this;
+                return this.matched = proto;
+            }
+        }
+        if (this.#default) {
+            this.#default.parent = this;
+            return this.matched = this.#default;
+        }
+    }
+}

package/packages/meta/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "@amateras/meta",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts"
+    },
+    "exports": {
+      ".": "./src/index.ts"
+    }
+}

package/packages/meta/src/index.ts

@@ -0,0 +1,36 @@
+import { resolveMeta } from "#lib/resolveMeta";
+import { onclient, onserver } from "@amateras/core";
+import { Proto } from "@amateras/core";
+import { _Object_assign } from "@amateras/utils";
+import type { MetaConfig } from "./types";
+
+declare global {
+    export namespace $ {
+        function meta(config: MetaConfig): void
+        
+        export namespace meta {
+            function resolve(config: MetaConfig): void
+            
+        }
+    }
+}
+
+declare module '@amateras/core' {
+    export interface GlobalState {
+        meta: MetaConfig;
+    }
+}
+
+_Object_assign($, {
+    meta(config: MetaConfig) {
+        if (onclient()) return;
+        let proto = Proto.proto;
+        if (proto) proto.global.meta = config;
+    },
+})
+
+if (onserver()) {
+    _Object_assign($.meta, {
+        resolve: resolveMeta
+    })
+}

package/packages/meta/src/lib/resolveMeta.ts

@@ -0,0 +1,27 @@
+import { _Object_entries, forEach, isArray, isString } from "@amateras/utils";
+import type { MetaConfig, MetaOutput } from "../types";
+
+export function resolveMeta(config: MetaConfig) {
+    let metaList: MetaOutput[] = [];
+
+    let {description, og, twitter} = config;
+    if (description) metaList.push({name: 'description', content: description});
+    if (og) determine(og, metaList, 'og', 'property');
+    if (twitter) determine(twitter as any, metaList, 'twitter', 'name')
+    return metaList;
+}
+
+const determine = (obj: MetaConfig, metaList: MetaOutput[], context: string, propName: 'name' | 'property') => {
+    let getProperty = (property: string) => context ? `${context}:${property}` : property;
+    let push = (property: string, content: string) => metaList.push({[propName]: getProperty(property), content} as MetaOutput);
+    for (const [property, content] of _Object_entries(obj)) {
+        if (isString(content)) push(property, content);
+        else {
+            if (isArray(content)) forEach(content as [], c => {
+                if (isString(c)) push(property, c);
+                else determine(c, metaList, getProperty(property), propName)
+            });
+            else determine(content as any, metaList, getProperty(property), propName);
+        }
+    }
+}

package/packages/meta/src/types.ts

@@ -0,0 +1,36 @@
+export type MetaConfig = {
+    description?: string;
+    og?: {
+        title?: string;
+        type?: string;
+        image?: string | string[] | OpenGraphMediaConfig | OpenGraphMediaConfig[];
+        url?: string;
+        audio?: string | string[] | OpenGraphAudioConfig | OpenGraphAudioConfig[];
+        description?: string;
+        determiner?: string;
+        locale?: string | {
+            alternate?: string;
+        };
+        site_name?: string;
+        video?: string | string[] | OpenGraphVideoConfig | OpenGraphVideoConfig[];
+    }
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: `@${string}`;
+        creator?: `@${string}`;
+    }
+}
+
+export type OpenGraphMediaConfig = {
+    url?: string;
+    secure_url?: string;
+    type?: string;
+    width?: string;
+    height?: string;
+    alt?: string;
+}
+
+export type OpenGraphAudioConfig = Pick<OpenGraphMediaConfig, 'url' | 'secure_url' | 'type'>;
+export type OpenGraphVideoConfig = Omit<OpenGraphMediaConfig, 'alt'>
+
+export type MetaOutput = {property: string, content: string} | {name: string, content: string};

package/packages/prefetch/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "@amateras/prefetch",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts"
+    },
+    "exports": {
+      ".": "./src/index.ts"
+    }
+}