amateras 0.13.2 → 0.14.0

package/packages/for/src/global.ts

@@ -1,7 +1,16 @@
-import * as proto from "#structure/For";
+import * as _For from "#structure/For";
 
 declare global {
-    export var For: typeof proto.For
+    export var For: typeof _For.For
+    // export function $<T>(For: typeof proto.For, signal: proto.ForList<T>, layout: proto.ForLayout<T>): proto.For<T>
 
-    export function $<T>(For: typeof proto.For, signal: proto.ForList<T>, layout: proto.ForLayout<T>): proto.For<T>
+    export namespace $ {
+        export interface Overload<I> {
+            for: [
+                input: [typeof _For.For, _For.ForList<any>],
+                output: _For.For,
+                args: [layout: I[1] extends _For.ForList<infer T> ? _For.ForLayout<T> : never]
+            ]
+        }
+    }
 }

package/packages/for/src/structure/For.ts

@@ -27,12 +27,14 @@ export class For<T = any> extends ProxyProto {
                 let nodes = this.toDOM();
                 let arr = _Array_from(parentNode.childNodes);
                 let currentPosition = arr.indexOf(thisNode);
+                let nextNode: Node | null = _null;
                 forEach(nodes, node => {
                     if (node !== thisNode) {
                         let currentNode = parentNode.childNodes[currentPosition];
                         if (currentNode !== node) {
-                            let nextNode = parentNode.childNodes[currentPosition + 1] ?? _null;
-                            parentNode.insertBefore(node, nextNode)
+                            if (!nodes.includes(currentNode as any)) nextNode = currentNode ?? _null;
+                            else nextNode = parentNode.childNodes[currentPosition + 1] ?? _null;
+                            parentNode.insertBefore(node, nextNode);
                         }
                     }
                     currentPosition++;
@@ -42,7 +44,7 @@ export class For<T = any> extends ProxyProto {
         }
 
         this.list$.subscribe(update);
-        this.ondispose(() => this.list$.unsubscribe(update));
+        this.listen('dispose', () => this.list$.unsubscribe(update));
     }
 
     override build() {

package/packages/i18n/README.md

@@ -1,37 +1,33 @@
 # amateras/i18n
 
-## Usage
+## Import
 ```ts
 import 'amateras';
 import 'amateras/i18n';
+```
 
-const $t = $.i18n()
-// add 'en' locale dictionary context
+## Usage
+```ts
+const i18n = $.i18n('en')
 .add('en', {
     homepage: {
         _: 'Home',
         hello: 'Hello, $name$!',
     }
 })
-// set 'en' as locale language
-.locale('en')
 
-$(document.body).content([
-    $('h1').content( $t('homepage') )
-    // <h1><text>Home</text></h1>
-    $t('homepage.hello', {name: 'Amateras'}) 
-    // <text>Hello, Amateras!</text>
-])
+$('div', $$ => {
+    $('h1', $$ => $([ i18n.t('homepage') ]))
+    $('p', $$ => $([ i18n.t('homepage.hello', { name: 'Amateras' }) ]))
+})
 ```
 
 ## Change Language
 ```ts
-$t.locale('zh')
-// all translation text will be updated
+i18n.locale('zh');
 ```
 
 ## Import Dictionary Context
-
 ```ts
 // ./i18n/en.ts
 export default {
@@ -47,27 +43,23 @@ export default {
 const $t = $.i18n()
 .add('en', () => import('./i18n/en.ts'))
 .add('zh', () => import('./i18n/zh.ts'))
-// set 'zh' as locale language
-// and fetch file automatically from path
-.locale('zh');
 ```
 
-## Directory Shortcut
-
+## Translation Directory Shortcut
 ```ts
-const $t = $.i18n('en')
+const i18n = $.i18n('en')
 .add('en', {
     page1: {
         section2: {
             button3: {
-                text: 'Too deep!'
+                text: 'Deep Button Text'
             }
         }
     }
 })
 
-const $t_button = $t.dir('page1.section2.button3');
+const i18n_button = i18n.dir('page1.section2.button3');
 
-$t_button('text') // Too deep!
-$t('page1.section2.button3.text') // Too deep!
+i18n.t('page1.section2.button3.text') // Deep Button Text
+i18n_button.t('text') // Deep Button Text
 ```

package/packages/i18n/src/index.ts

@@ -1,7 +1,7 @@
 import { I18n } from "#structure/I18n";
 import { I18nTranslation as _I18nTranslation, I18nTranslation } from "#structure/I18nTranslation";
-import { _instanceof, _null, _Object_assign } from "@amateras/utils";
-import { GlobalState } from "@amateras/core";
+import { _instanceof, _null, _Object_assign, forEach } from "@amateras/utils";
+import { GlobalState, Proto, ProxyProto } from "@amateras/core";
 import type { I18nSession } from "#structure/I18nSession";
 
 declare global {
@@ -13,7 +13,7 @@ declare global {
             i18n: I18nTranslation
         }
 
-        export interface ProtoEventMap {
+        export interface ProtoEventMap<P extends Proto> {
             i18nupdate: [I18nTranslation]
         }
     }
@@ -31,10 +31,14 @@ declare module '@amateras/core' {
     }
 }
 
-GlobalState.assign({
+GlobalState.assign(() => ({
     i18n: {
         session: _null
     }
+}))
+
+GlobalState.disposers.add(global => {
+    global.i18n.session = _null;
 })
 
 _Object_assign($, {
@@ -45,7 +49,24 @@ _Object_assign($, {
 
 $.process.text.add(value => {
     if (_instanceof(value, I18nTranslation)) {
-        return value
+        const $proxy = new ProxyProto();
+        value.onupdate(result => {
+            $proxy.layout = () => $([ ...result ]);
+            forEach($proxy.protos, proto => proto.removeNode());
+            $proxy.build();
+            $proxy.node?.replaceWith(...$proxy.toDOM());
+            $proxy.dispatch('i18nupdate', [this], {bubbles: true})
+        })
+        value.update();
+        return $proxy;
+    }
+})
+$.process.attr.add((name, value, proto) => {
+    if (_instanceof(value, I18nTranslation)) {
+        value.onupdate((result) => {
+            proto.attr(name, result.join(''))
+        })
+        value.update();
     }
 })
 

package/packages/i18n/src/structure/I18n.ts

@@ -10,13 +10,11 @@ export class I18n<D extends I18nDictionaryContext = {}> {
     dictionaries = new Map<string, I18nDictionary>();
     defaultLocale: string;
     sessions = new Set<I18nSession>();
-    session = new I18nSession(this);
     path = '';
     static key = '__locale__';
     constructor(defaultLocale: string) {
         this.defaultLocale = defaultLocale;
         this.#locale = defaultLocale;
-        this.sessions.add(this.session);
     }
 
     add(lang: string, dictionary: I18nDictionaryContext | I18nDictionaryContextImporter) {
@@ -75,11 +73,11 @@ export class I18n<D extends I18nDictionaryContext = {}> {
     private getSession() {
         let parentProto = Proto.proto;
         if (parentProto) {
-            let session = parentProto.global.i18n.session ?? new I18nSession(this);
+            let session = parentProto.global.i18n.session ?? new I18nSession(this, parentProto.global);
             parentProto.global.i18n.session = session;
             return session;
         }
-        else return this.session;
+        else throw 'I18n.getSession(): session not found from Proto.proto'
     }
 
     private readStoreLocale() {

package/packages/i18n/src/structure/I18nSession.ts

@@ -2,14 +2,16 @@ import { isUndefined, map } from "@amateras/utils";
 import type { I18nTranslationResult } from "../types";
 import type { I18n } from "./I18n";
 import type { I18nTranslation, I18nTranslationOptions } from "./I18nTranslation";
-import { onclient } from "@amateras/core";
+import { GlobalState, onclient } from "@amateras/core";
 
 export class I18nSession {
     translations = new Set<I18nTranslation>()
     i18n: I18n;
     #locale: string;
-    constructor(i18n: I18n) {
+    global: GlobalState;
+    constructor(i18n: I18n, global: GlobalState) {
         this.i18n = i18n;
+        this.global = global;
         this.#locale = i18n.locale();
         i18n.sessions.add(this);
     }

package/packages/i18n/src/structure/I18nTranslation.ts

@@ -1,45 +1,34 @@
-import { ProxyProto } from "@amateras/core";
-import { forEach } from "@amateras/utils";
+import { forEach, map } from "@amateras/utils";
 import type { I18nSession } from "./I18nSession";
 
-export class I18nTranslation extends ProxyProto {
+export class I18nTranslation {
     session: I18nSession;
     key: string;
     options: I18nTranslationOptions | undefined;
+    private updating = false;
+    private updaters: ((result: any[]) => void)[] = [];
     constructor(session: I18nSession, key: string, options?: I18nTranslationOptions) {
-        super()
         this.session = session;
         this.key = key;
         this.options = options;
-        session.translations.add(this);
-    }
-
-    override dispose(): void {
-        super.dispose();
-        this.session.translations.delete(this)
-    }
-    
-    override build(): this {
-        this.update();
-        return this;
+        this.session.translations.add(this);
     }
     
     async update() {
+        if (this.updating) return;
+        this.updating = true;
         const request = this.session.fetch(this.key, this.options);
-        this.global.asyncTask(request);
+        this.session.global.asyncTask(request);
         const {text, args} = await request;
-        this.layout = () => {
-            // make this array become Template String Array;
-            //@ts-ignore
-            text.raw = text;
-            $(text as any, ...args);
-        }
-        forEach(this.protos, proto => proto.removeNode());
-        super.build();
-        this.node?.replaceWith(...this.toDOM());
-        this.dispatch('i18nupdate', this, {bubbles: true})
+        const arr = map(text, (str, index) => index < args.length ? [str, args[index]] : [str]).flat();
+        forEach(this.updaters, updaters => updaters(arr))
+        this.updating = false;
         return this;
     }
+
+    onupdate(handle: (result: any[]) => void) {
+        this.updaters.push(handle);
+    }
 }
 
 export type I18nTranslationOptions = {[key: string]: any}

package/packages/idb/src/structure/$IDBStore.ts

@@ -1,4 +1,4 @@
-import { _instanceof, _Object_assign, _Promise } from "@amateras/utils";
+import { _Object_assign } from "@amateras/utils";
 import { $IDBIndex, type $IDBIndexConfig } from "./$IDBIndex";
 import { $IDBRequest } from "#lib/$IDBRequest";
 import { $IDBStoreBase } from "./$IDBStoreBase";
@@ -59,7 +59,7 @@ export interface $IDBStore<Config extends $IDBStoreConfig = any> {
     count(query?: $IDBStoreKey<Config> | IDBKeyRange): Promise<number>;
 
     /** {@link IDBObjectStore.get} */
-    get(query: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema']>
+    get(query: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema'] | undefined>
 
     /** {@link IDBObjectStore.getAll} */
     getAll(query?: $IDBStoreKey<Config> | IDBKeyRange): Promise<Config['schema'][]>

package/packages/if/src/global.ts

@@ -2,7 +2,7 @@ import type { Condition } from "#structure/Condition";
 import * as _Else from "#structure/Else";
 import * as _ElseIf from "#structure/ElseIf";
 import * as _If from "#structure/If";
-import type { Signal, SignalObject } from "@amateras/signal";
+import type { Signal } from "@amateras/signal";
 import type { IfLayout } from ".";
 
 declare global {
@@ -10,7 +10,18 @@ declare global {
     export var Else: typeof _Else.Else
     export var ElseIf: typeof _ElseIf.ElseIf
 
-    export function $<T extends Signal | SignalObject<any>>(statement: typeof _If.If, signal: T, layout: IfLayout<T>): Condition;
-    export function $<T extends Signal | SignalObject<any>>(statement: typeof _ElseIf.ElseIf, signal: T, layout: IfLayout<T>): Condition;
-    export function $(statement: typeof _Else.Else, layout: _Else.ElseLayout): Condition;
+    export namespace $ {
+        export interface Overload<I> {
+            if: [
+                input: [typeof _If.If | typeof _ElseIf.ElseIf, signal: OrArray<Signal>],
+                output: Condition,
+                args: [layout: I[1] extends OrArray<Signal> ? IfLayout<I[1]> : never]
+            ]
+            else: [
+                input: [typeof _Else.Else],
+                output: Condition,
+                args: [layout: _Else.ElseLayout]
+            ]
+        }
+    }
 }

package/packages/if/src/index.ts

@@ -1,7 +1,7 @@
 import './global';
 import { If } from "#structure/If";
-import { _instanceof, _null, isIncluded } from "@amateras/utils";
-import { Signal, type SignalObject, type SignalTypes } from '@amateras/signal';
+import { _instanceof, _null, isArray, isIncluded } from "@amateras/utils";
+import { Signal, type SignalObject } from '@amateras/signal';
 import { ElseIf } from '#structure/ElseIf';
 import { Else } from '#structure/Else';
 import { Condition } from '#structure/Condition';
@@ -10,13 +10,24 @@ globalThis.If = If;
 globalThis.Else = Else;
 globalThis.ElseIf = ElseIf;
 
-export type IfLayout<T> = (value: T extends SignalTypes<infer V>
+export type IfLayout<T> = (...value: T extends any[]
+    ?   ResolveArray<T>
+    :   [ResolveSignal<T>]
+) => void;
+
+type ResolveArray<T> = T extends [infer A, ...infer Rest] 
+    ?   [A] extends [Signal<any>]
+        ?   [ResolveSignal<A>, ...ResolveArray<Rest>]
+        :   []
+    :   [];
+
+type ResolveSignal<T> = [T] extends [Signal<infer V>]
     ?   V extends object
         ?   SignalObject<V> 
-        :   V extends null 
+        :   V extends null
             ?   never
             :   Signal<V>
-    : never) => void;
+    :   T;
 
 /**This map store condition with parent Proto,
  * all related Statement should be under same parent Proto.
@@ -39,10 +50,9 @@ $.process.craft.add((value, arg1, arg2) => {
     // handle If/Else/ElseIf constructor
     // add them into condition child statements
     if (isIncluded(value, [If, Else, ElseIf])) {
-        let args: [Signal | null, () => void] = _instanceof(arg1, Signal) ? [arg1, arg2] : [_null, arg1];
+        let args: [Signal | Signal[] | null, () => void] = (_instanceof(arg1, Signal) || isArray(arg1)) ? [arg1, arg2] : [_null, arg1];
         let statement = new value(...args);
-        condition.statements = condition.statements ?? [];
-        condition.statements?.push(statement);
+        condition.append(statement);
     }
     else {
         condition = _null;

package/packages/if/src/structure/Condition.ts

@@ -5,13 +5,12 @@ import type { ConditionStatement } from "./ConditionStatement";
 
 export class Condition extends ProxyProto {
     static override [symbol_Statement] = true;
-    statements: ConditionStatement[] | null = _null;
     declare layout: null;
     statement: ConditionStatement | null = _null;
 
     override build() {
         // run base build method with empty protos
-        super.build(false);
+        super.build(false, false);
         // set condition matched proto
         this.validate()?.build();
         // update function for Signal subscribe
@@ -20,32 +19,36 @@ export class Condition extends ProxyProto {
             if (!matchProto?.builded) matchProto?.build();
             if (this.statement === matchProto) return;
             this.statement = matchProto ?? _null;
-            forEach(this.statements, proto => proto !== matchProto && proto.removeNode())
+            forEach(this.protos, proto => !proto.visible && proto.removeNode());
             this.node?.replaceWith(...this.toDOM());
             this.parent?.mutate();
         }
         // build statements proto and subscribe expression signal
-        forEach(this.statements, proto => {
-            proto.exp$?.subscribe(update);
-            proto.ondispose(() => {
-                proto.exp$?.unsubscribe(update)
-            });
+        forEach(this.protos, proto => {
+            forEach(proto.exps, exp$ => {
+                exp$?.subscribe(update);
+                proto.listen('dispose', () => {
+                    exp$?.unsubscribe(update)
+                });
+            })
         })
         return this;
     }
 
+    override get protos(): Set<ConditionStatement> {
+        return super.protos as Set<ConditionStatement>
+    }
+
     override dispose(): void {
         super.dispose();
-        forEach(this.statements, statement => statement.dispose());
         this.statement = _null;
-        this.statements = _null;
     }
 
     validate() {
-        this.clear();
-        if (this.statements) for (let proto of this.statements) {
+        forEach(this.protos, proto => proto.visible = false);
+        for (let proto of this.protos) {
             if (proto.validate()) {
-                this.append(proto);
+                proto.visible = true;
                 return proto;
             }
         }

package/packages/if/src/structure/ConditionStatement.ts

@@ -1,25 +1,25 @@
 import { symbol_Statement } from "@amateras/core";
 import { Proto } from "@amateras/core";
 import type { Signal } from "@amateras/signal";
-import { _null } from "@amateras/utils";
+import { _null, toArray } from "@amateras/utils";
 
-export type ConditionLayout = (value: Signal<any> | null) => void;
+export type ConditionLayout = (...value: Signal<any>[]) => void;
 
 export abstract class ConditionStatement extends Proto {
     static override [symbol_Statement] = true;
-    exp$: Signal<any> | null;
-    constructor(expression: Signal<any> | null, layout: ConditionLayout) {
-        super(() => layout(this.exp$));
-        this.exp$ = expression;
+    exps: Signal<any>[] | null;
+    constructor(expression: OrArray<Signal<any>> | null, layout: ConditionLayout) {
+        super(() => layout(...this.exps ?? []));
+        this.exps = expression ? toArray(expression) : _null;
     }
 
     override dispose(): void {
         super.dispose();
-        this.exp$ = _null;
+        this.exps = _null;
     }
 
     validate() {
-        if (!this.exp$) return true;
-        return !!this.exp$.value;
+        if (!this.exps) return true;
+        return !this.exps.find(exp$ => !exp$.value)
     }
 }

package/packages/match/src/global.ts

@@ -8,7 +8,13 @@ declare global {
     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;
+    export namespace $ {
+        export interface Overload<I> {
+            match: [
+                input: [typeof _Match.Match, Signal],
+                output: I[1] extends Signal<infer T> ? _Match.Match<T> : never,
+                args: [layout: I[1] extends Signal<infer T> ? _Match.MatchLayout<T> : never]
+            ]
+        }
+    }
 }

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

@@ -51,7 +51,7 @@ export class Match<T = any> extends ProxyProto {
         // build cases proto and subscribe expression signal
         forEach(this.cases, proto => {
             this.exp$.subscribe(update);
-            proto.ondispose(() => this.exp$.unsubscribe(update));
+            proto.listen('dispose', () => this.exp$.unsubscribe(update));
         })
         return this;
     }

package/packages/meta/src/index.ts

@@ -6,7 +6,7 @@ import type { MetaConfig } from "./types";
 
 declare global {
     export namespace $ {
-        function meta(config: MetaConfig): void
+        function meta(config: MetaConfig, parent?: Proto | null): void
         
         export namespace meta {
             function resolve(config: MetaConfig): void
@@ -22,11 +22,10 @@ declare module '@amateras/core' {
 }
 
 _Object_assign($, {
-    meta(config: MetaConfig) {
+    meta(config: MetaConfig, parent = Proto.proto) {
         if (onclient()) return;
-        let proto = Proto.proto;
-        if (!proto) return;
-        proto.global.meta = deepMerge(proto.global.meta ?? {}, config);
+        if (!parent) return;
+        parent.global.meta = deepMerge(parent.global.meta ?? {}, config);
     },
 })
 

package/packages/prefetch/src/index.ts

@@ -5,7 +5,12 @@ import { _null, _Object_assign, isAsyncFunction, toURL } from "@amateras/utils";
 
 declare global {
     export namespace $ {
-        export function fetch<T, R>(url: string | URL, options?: RequestInit & FetchOptions<T, R>): Promise<FetchResult<T, R>>
+        export function fetch<T, R>(url: string | URL, options?: RequestInit & FetchOptions<T, R>, proto?: Proto | null): Promise<FetchResult<T, R>>
+
+        export namespace fetch {
+            export let origin: string;
+            export let server: Bun.Server<undefined> | null
+        }
     }
     export var prefetch: {[key: string]: { expired: number, data: any }}
 }
@@ -13,7 +18,8 @@ declare global {
 declare module "@amateras/core" {
     export interface GlobalState {
         prefetch: {
-            caches: {[key: string]: { expired: number, data: any }}
+            caches: {[key: string]: { expired: number, data: any }};
+            req: null | Request
         }
     }
 }
@@ -28,11 +34,12 @@ export type FetchResult<T, R> = {
     result: R;
 }
 
-GlobalState.assign({
+GlobalState.assign(() => ({
     prefetch: {
-        caches: {}
+        caches: {},
+        req: null
     }
-})
+}))
 
 if (!globalThis.prefetch) globalThis.prefetch = {}
 
@@ -41,9 +48,8 @@ _Object_assign($, {
     // 保证每次全局渲染都在抓取完毕之后：将 Promise 添加到 global.prefetch.fetches 让根原型能确保所有 fetch 运行结束
     // 将已抓取的资料发送到客户端：从 record 函数回传的资料将会被记录在 global.prefetch.caches 当中，并且以抓取 URL 作为索引。
     // 客户端不会用到过时的资料：每个发送到客户端的资料缓存都附上了过期时间
-    async fetch<T, R>(url: string | URL, options?: RequestInit & FetchOptions<T, R>) {
-        url = toURL(url);
-        let proto = Proto.proto;
+    async fetch<T, R>(url: string | URL, options?: RequestInit & FetchOptions<T, R>, proto = Proto.proto) {
+        url = toURL(url, $.fetch.origin);
         let cache = onclient() ? prefetch[url.href] : _null;
         let then = options?.then;
         let request = new Promise(async (resolve) => {
@@ -52,7 +58,17 @@ _Object_assign($, {
                 resolve({record: cache.data, result});
                 return ;
             }
-            let response = await fetch(url, options);
+            let { origin, server } = $.fetch;
+            let cookies = proto?.global.prefetch.req?.headers.get('cookie') || '';
+            let response = url.origin === origin && server 
+            ?   await server.fetch(new Request(url, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    'Cookie': cookies
+                }
+            }))
+            :   await fetch(url, options);
             let recordFn = options?.record;
             if (recordFn) {
                 let record = isAsyncFunction(recordFn) ? await recordFn(response) : recordFn(response);
@@ -67,4 +83,9 @@ _Object_assign($, {
         if (onserver()) proto?.global.asyncTask(request)
         return request
     }
+})
+
+_Object_assign($.fetch, {
+    origin: onclient() ? location.origin : 'http://localhost',
+    server: null
 })