akanjs 2.2.4 → 2.2.6

package/types/dictionary/dictInfo.d.ts

@@ -0,0 +1,206 @@
+import type { GetStateObject } from "akanjs/base";
+import type { BaseInsight, BaseObject } from "akanjs/constant";
+import type { BaseFilterQueryKey, BaseFilterSortKey, FilterInfo, FilterInstance } from "akanjs/document";
+import type { EndpointInfo, SliceInfo } from "akanjs/signal";
+import type { RootDictionary } from "./trans.d.ts";
+type EnumValueKey = string | number;
+declare class FieldTranslation<Languages extends [string, ...string[]]> {
+    static translate: <Languages_1 extends [string, ...string[]]>(trans: Languages_1) => FieldTranslation<Languages_1>;
+    trans: Languages;
+    descTrans?: Languages;
+    constructor(trans: Languages);
+    desc(descTrans: Languages): this;
+}
+declare class FunctionTranslation<Languages extends [string, ...string[]], ArgName extends string = never> {
+    trans: Languages;
+    descTrans?: Languages;
+    argTrans: {
+        [key in ArgName]: FieldTranslation<Languages>;
+    };
+    constructor(trans: Languages);
+    desc(descTrans: Languages): this;
+    arg<TransMap extends {
+        [key: string]: FieldTranslation<Languages>;
+    }>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => TransMap): FunctionTranslation<Languages, keyof TransMap & string>;
+}
+type BaseModelCrudGetSignalTranslation<T extends string, Languages extends [string, ...string[]] = [string], _CapitalizedRefName extends string = Capitalize<T>> = {
+    [K in T]: FunctionTranslation<Languages, `${T}Id`>;
+} & {
+    [K in `light${_CapitalizedRefName}`]: FunctionTranslation<Languages, `${T}Id`>;
+} & {
+    [K in `create${_CapitalizedRefName}`]: FunctionTranslation<Languages, "data">;
+} & {
+    [K in `update${_CapitalizedRefName}`]: FunctionTranslation<Languages, `${T}Id` | "data">;
+} & {
+    [K in `remove${_CapitalizedRefName}`]: FunctionTranslation<Languages, `${T}Id`>;
+};
+type GetBaseSignalKey<T extends string> = keyof BaseModelCrudGetSignalTranslation<T>;
+export declare class ModelDictInfo<Languages extends [string, ...string[]] = [string], ModelKey extends string = keyof BaseObject, InsightKey extends string = keyof BaseInsight, QueryKey extends string = BaseFilterQueryKey, SortKey extends string = BaseFilterSortKey, EnumKey extends string = never, BaseSignalKey extends string = never, SliceKey extends string = never, EndpointKey extends string = never, ErrorKey extends string = never, EtcKey extends string = never> {
+    #private;
+    static baseModelDictionary: {
+        [key in keyof BaseObject]: FieldTranslation<[string, string]>;
+    };
+    static baseInsightDictionary: {
+        [key in keyof BaseInsight]: FieldTranslation<[string, string]>;
+    };
+    static baseQueryDictionary: {
+        [key in BaseFilterQueryKey]: FieldTranslation<[string, string]>;
+    };
+    static baseSortDictionary: {
+        [key in BaseFilterSortKey]: FieldTranslation<[string, string]>;
+    };
+    static getBaseSignalDictionary<T extends string>(refName: T): BaseModelCrudGetSignalTranslation<T, [string, string]>;
+    static baseSliceDictionary: {
+        [key in ""]: FunctionTranslation<[string, string], "query">;
+    };
+    languages: Languages;
+    modelTranslation?: FieldTranslation<Languages>;
+    modelDictionary: {
+        [K in ModelKey]: FieldTranslation<Languages>;
+    };
+    insightDictionary: {
+        [K in InsightKey]: FieldTranslation<Languages>;
+    };
+    queryDictionary: {
+        [K in QueryKey]: FunctionTranslation<Languages>;
+    };
+    sortDictionary: {
+        [K in SortKey]: FieldTranslation<Languages>;
+    };
+    enumDictionary: {
+        [K in EnumKey]: {
+            [key: string]: FieldTranslation<Languages>;
+        };
+    };
+    baseSignalDictionary: {
+        [K in BaseSignalKey]: FunctionTranslation<Languages>;
+    };
+    sliceDictionary: {
+        [K in SliceKey]: FunctionTranslation<Languages>;
+    };
+    endpointDictionary: {
+        [K in EndpointKey]: FunctionTranslation<Languages>;
+    };
+    errorDictionary: {
+        [K in ErrorKey]: Languages;
+    };
+    etcDictionary: {
+        [K in EtcKey]: Languages;
+    };
+    constructor(languages: Languages);
+    of(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => FieldTranslation<Languages>): this;
+    model<Model extends object>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in Exclude<keyof GetStateObject<Model>, ModelKey>]: FieldTranslation<Languages>;
+    }): ModelDictInfo<Languages, keyof GetStateObject<Model> & string, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    insight<Insight extends object>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in Exclude<keyof GetStateObject<Insight>, InsightKey>]: FieldTranslation<Languages>;
+    }): ModelDictInfo<Languages, ModelKey, keyof GetStateObject<Insight> & string, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    query<Filter extends FilterInstance>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
+        [K in Exclude<keyof Filter["query"], QueryKey>]: Filter["query"][K] extends FilterInfo<infer ArgNames, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, keyof Filter["query"] & string, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    sort<Filter extends FilterInstance>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in Exclude<keyof Filter["sort"], SortKey>]: FieldTranslation<Languages>;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, keyof Filter["sort"] & string, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    enum<Enum extends {
+        refName: string;
+        value: EnumValueKey;
+    }>(enumName: Enum["refName"], translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in Enum["value"]]: FieldTranslation<Languages>;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey | Enum["refName"], BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    slice<Slice>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
+        [K in Exclude<keyof Slice, SliceKey>]: Slice[K] extends SliceInfo<any, any, any, any, any, any, any, infer ArgNames, any, any, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, keyof Slice & string, EndpointKey, ErrorKey, EtcKey>;
+    endpoint<Endpoint>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
+        [K in Exclude<keyof Endpoint, EndpointKey>]: Endpoint[K] extends EndpointInfo<any, any, infer ArgNames, any, any, any, any, any, any, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, keyof Endpoint & string, ErrorKey, EtcKey>;
+    error<ErrorDict extends {
+        [key: string]: Languages;
+    }>(errorDictionary: ErrorDict): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey | (keyof ErrorDict & string), EtcKey>;
+    translate<EtcDict extends {
+        [key: string]: Languages;
+    }>(etcDictionary: EtcDict): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey | (keyof EtcDict & string)>;
+    applyBaseSignal<RefName extends string>(refName: RefName): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, GetBaseSignalKey<RefName>, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    _registerToRoot(refName: string, rootDict: RootDictionary): void;
+    getEnum<Enum extends {
+        refName: string;
+        value: EnumValueKey;
+    }>(enumName: EnumKey): {
+        [K in Enum["value"]]: FieldTranslation<Languages>;
+    };
+}
+type AnyModelDictInfo = ModelDictInfo<any, any, any, any, any, any, any, any, any, any, any>;
+type MergeTwoModelDicts<ModelDict1, ModelDict2> = ModelDict1 extends ModelDictInfo<infer Languages1, infer ModelKey1, infer InsightKey1, infer QueryKey1, infer SortKey1, infer EnumKey1, infer BaseSignalKey1, infer SliceKey1, infer EndpointKey1, infer ErrorKey1, infer EtcKey1> ? ModelDict2 extends ModelDictInfo<any, infer ModelKey2, infer InsightKey2, infer QueryKey2, infer SortKey2, infer EnumKey2, infer BaseSignalKey2, infer SliceKey2, infer EndpointKey2, infer ErrorKey2, infer EtcKey2> ? ModelDictInfo<Languages1, ModelKey1 | ModelKey2, InsightKey1 | InsightKey2, QueryKey1 | QueryKey2, SortKey1 | SortKey2, EnumKey1 | EnumKey2, BaseSignalKey1 | BaseSignalKey2, SliceKey1 | SliceKey2, EndpointKey1 | EndpointKey2, ErrorKey1 | ErrorKey2, EtcKey1 | EtcKey2> : ModelDict1 : never;
+type MergeModelDicts<ModelDicts extends AnyModelDictInfo[]> = ModelDicts extends [
+    infer First extends AnyModelDictInfo,
+    ...infer Rest extends AnyModelDictInfo[]
+] ? Rest extends [] ? First : MergeTwoModelDicts<First, MergeModelDicts<Rest>> : never;
+export declare const modelDictionary: <Languages extends [string, ...string[]] = [string], ExtendModelDicts extends AnyModelDictInfo[] = []>(languages?: Languages, ...extendModelDicts: ExtendModelDicts) => MergeModelDicts<[ModelDictInfo<Languages>, ...ExtendModelDicts]>;
+export declare class ScalarDictInfo<Languages extends [string, ...string[]] = [string], ModelKey extends string = keyof BaseObject, EnumKey extends string = never, ErrorKey extends string = never, EtcKey extends string = never> {
+    #private;
+    languages: Languages;
+    modelTranslation?: FieldTranslation<Languages>;
+    modelDictionary: {
+        [K in ModelKey]: FieldTranslation<Languages>;
+    };
+    enumDictionary: {
+        [K in EnumKey]: {
+            [key: string]: FieldTranslation<Languages>;
+        };
+    };
+    errorDictionary: {
+        [K in ErrorKey]: Languages;
+    };
+    etcDictionary: {
+        [K in EtcKey]: Languages;
+    };
+    constructor(languages: Languages);
+    of(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => FieldTranslation<Languages>): this;
+    model<Model>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in keyof GetStateObject<Model>]: FieldTranslation<Languages>;
+    }): ScalarDictInfo<Languages, keyof GetStateObject<Model> & string, EnumKey, ErrorKey, EtcKey>;
+    enum<Enum extends {
+        refName: string;
+        value: EnumValueKey;
+    }>(enumName: Enum["refName"], translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in Enum["value"]]: FieldTranslation<Languages>;
+    }): ScalarDictInfo<Languages, ModelKey, EnumKey | Enum["refName"], ErrorKey, EtcKey>;
+    error<ErrorDict extends {
+        [key: string]: Languages;
+    }>(errorDictionary: ErrorDict): ScalarDictInfo<Languages, ModelKey, EnumKey, keyof ErrorDict & string, EtcKey>;
+    translate<EtcDict extends {
+        [key: string]: Languages;
+    }>(etcDictionary: EtcDict): ScalarDictInfo<Languages, ModelKey, EnumKey, ErrorKey, keyof EtcDict & string>;
+    _registerToRoot(refName: string, rootDict: RootDictionary): void;
+}
+export declare const scalarDictionary: <Languages extends [string, ...string[]] = [string]>(languages?: Languages) => ScalarDictInfo<Languages, keyof BaseObject, never, never, never>;
+export declare class ServiceDictInfo<Languages extends [string, ...string[]] = [string], EndpointKey extends string = never, ErrorKey extends string = never, EtcKey extends string = never> {
+    #private;
+    languages: Languages;
+    endpointDictionary: {
+        [K in EndpointKey]: FunctionTranslation<Languages>;
+    };
+    errorDictionary: {
+        [K in ErrorKey]: Languages;
+    };
+    etcDictionary: {
+        [K in EtcKey]: Languages;
+    };
+    constructor(languages: Languages);
+    endpoint<Endpoint extends {
+        [key: string]: EndpointInfo;
+    }>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
+        [K in keyof Endpoint]: FunctionTranslation<Languages, Endpoint[K]["argNames"][number]>;
+    }): ServiceDictInfo<Languages, keyof Endpoint & string, ErrorKey, EtcKey>;
+    error<ErrorDict extends {
+        [key: string]: Languages;
+    }>(errorDictionary: ErrorDict): ServiceDictInfo<Languages, EndpointKey, keyof ErrorDict & string, EtcKey>;
+    translate<EtcDict extends {
+        [key: string]: Languages;
+    }>(etcDictionary: EtcDict): ServiceDictInfo<Languages, EndpointKey, ErrorKey, keyof EtcDict & string>;
+    _toTranslation(): {
+        [key: string]: string[];
+    };
+    _registerToRoot(refName: string, rootDict: RootDictionary): void;
+}
+export declare const serviceDictionary: <Languages extends [string, ...string[]] = [string]>(languages?: Languages) => ServiceDictInfo<Languages, never, never, never>;
+export {};

package/types/dictionary/dictionary.d.ts

@@ -0,0 +1,11 @@
+import type { BaseEndpoint } from "akanjs/signal";
+export declare const dictionary: {
+    base: import("./locale.d.ts").DictModule<import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, never>;
+};
+export declare const Err: import("./trans.d.ts").ErrConstructor<never>, translate: (lang: "en" | "ko" | "zhChs" | "zhCht" | "ja", key: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, data?: import("./trans.d.ts").TranslationData) => string, msg: {
+    info: (key: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, option?: import("./trans.d.ts").TransMessageOption) => void;
+    success: (key: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, option?: import("./trans.d.ts").TransMessageOption) => void;
+    error: (key: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, option?: import("./trans.d.ts").TransMessageOption) => void;
+    warning: (key: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, option?: import("./trans.d.ts").TransMessageOption) => void;
+    loading: (key: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, option?: import("./trans.d.ts").TransMessageOption) => void;
+}, getDictionary: (lang: "en" | "ko" | "zhChs" | "zhCht" | "ja") => object, getAllDictionary: () => import("./trans.d.ts").RootDictionary, __Dict_Key__: import("./locale.d.ts").ServiceTranslatorKey<"base", BaseEndpoint, "error" | "save" | "password" | "remove" | "ok" | "connecting" | "failed" | "success" | "edit" | "view" | "somethingWrong" | "connected" | "serverDisconnected" | "refreshing" | "tryReconnecting" | "serverHasProblem" | "checkServerStatus" | "processing" | "processed" | "noData" | "invalidValueError" | "emailInvalidError" | "phoneInvalidError" | "cancel" | "unauthorized" | "confirmClose" | "textTooShortError" | "textTooLongError" | "selectTooShortError" | "selectTooLongError" | "numberTooSmallError" | "numberTooBigError" | "passwordNotMatchError" | "selectDateError" | "priceUnit" | "passwordConfirm" | "noOptions" | "addModel" | "createModel" | "createSuccess" | "updateModel" | "removeModel" | "updateSuccess" | "removeSuccess" | "sureToRemove" | "irreversibleOps" | "typeNameToRemove" | "yesRemove" | "removeMsg" | "confirmMsg" | "perPage" | "actions" | "new">, __Error_Key__: never;

package/types/dictionary/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./dictInfo.d.ts";
+export { __Dict_Key__, __Error_Key__, dictionary, Err, getAllDictionary, getDictionary, translate, } from "./dictionary.d.ts";
+export * from "./locale.d.ts";
+export * from "./trans.d.ts";

package/types/dictionary/locale.d.ts

@@ -0,0 +1,128 @@
+import type { GetStateObject, MergedValues } from "akanjs/base";
+import type { BaseInsight, BaseObject } from "akanjs/constant";
+import type { FilterInfo, FilterInstance } from "akanjs/document";
+import type { EndpointInfo, SliceInfo } from "akanjs/signal";
+import type { ModelDictInfo, ScalarDictInfo, ServiceDictInfo } from ".";
+interface Trans {
+    t: string;
+}
+interface FieldTrans {
+    t: string;
+    desc?: string;
+}
+interface FnTrans<ArgKey extends string> {
+    t: string;
+    desc?: string;
+    arg?: {
+        [key in ArgKey]: FieldTrans;
+    };
+}
+type FilterTranslatorKey<Filter extends FilterInstance> = {
+    [Key in keyof Filter["query"] & string]: `${Key}` | `${Key}.desc` | (Filter["query"][Key] extends FilterInfo<infer ArgNames, any> ? ArgNames[number] extends string ? `${Key}.arg.${ArgNames[number]}` | `${Key}.arg.${ArgNames[number]}.desc` : never : never);
+}[keyof Filter["query"] & string];
+type EndpointTranslatorKey<Endpoint extends {
+    [key: string]: EndpointInfo;
+}> = {
+    [Key in keyof Endpoint & string]: `${Key}` | `${Key}.desc` | `${Key}.arg.${Endpoint[Key]["argNames"][number]}` | `${Key}.arg.${Endpoint[Key]["argNames"][number]}.desc`;
+}[keyof Endpoint & string];
+type SliceTranslatorKey<Slice> = {
+    [Key in keyof Slice & string]: Slice[Key] extends SliceInfo<infer T, any, any, any, any, any, any, infer ArgNames, any, any, any> ? `${T}List${Capitalize<Key>}` | `${T}List${Capitalize<Key>}.desc` | `${T}List${Capitalize<Key>}.arg.${ArgNames[number] | "skip" | "limit" | "sort"}` | `${T}List${Capitalize<Key>}.arg.${ArgNames[number] | "skip" | "limit" | "sort"}.desc` | `${T}Insight${Capitalize<Key>}` | `${T}Insight${Capitalize<Key>}.desc` | `${T}Insight${Capitalize<Key>}.arg.${ArgNames[number]}` | `${T}Insight${Capitalize<Key>}.arg.${ArgNames[number]}.desc` : never;
+}[keyof Slice & string];
+type SliceApiTrans<T extends string, Suffix extends string, ArgName extends string, _CapitalizedSuffix extends string = Capitalize<Suffix>> = {
+    [K in `${T}List${_CapitalizedSuffix}`]: FnTrans<ArgName | "skip" | "limit" | "sort">;
+} & {
+    [K in `${T}Insight${_CapitalizedSuffix}`]: FnTrans<ArgName>;
+};
+type BaseModelCrudGetApiTrans<T extends string> = {
+    [K in T]: FnTrans<`${T}Id`>;
+} & {
+    [K in `light${T}`]: FnTrans<`${T}Id`>;
+} & {
+    [K in `create${T}`]: FnTrans<"data">;
+} & {
+    [K in `update${T}`]: FnTrans<`${T}Id` | "data">;
+} & {
+    [K in `remove${T}`]: FnTrans<`${T}Id`>;
+};
+export type ModelTrans<T extends string, Model extends BaseObject, Insight extends BaseInsight, Filter extends FilterInstance, Slice extends {
+    [key: string]: SliceInfo;
+}, Endpoint extends {
+    [key: string]: EndpointInfo;
+}, ErrorKey extends string, EtcKey extends string> = {
+    modelName: Trans;
+    modelDesc: Trans;
+    model: {
+        [K in keyof GetStateObject<Model>]: FieldTrans;
+    };
+    insight: {
+        [K in keyof GetStateObject<Insight>]: FieldTrans;
+    };
+    query: {
+        [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<infer ArgNames, any> ? FnTrans<ArgNames[number]> : never;
+    };
+    sort: {
+        [K in keyof Filter["sort"]]: FieldTrans;
+    };
+    api: {
+        [K in keyof Endpoint]: FnTrans<Endpoint[K]["argNames"][number]>;
+    } & BaseModelCrudGetApiTrans<T> & MergedValues<{
+        [K in keyof Slice]: SliceApiTrans<Slice[K]["refName"], K & string, Slice[K]["argNames"][number]>;
+    }>;
+    error: {
+        [K in ErrorKey]: Trans;
+    };
+} & {
+    [K in EtcKey]: Trans;
+};
+export type ModelTranslatorKey<T extends string, Model, Insight, Filter extends FilterInstance, Slice extends {
+    [key: string]: SliceInfo;
+}, Endpoint extends {
+    [key: string]: EndpointInfo;
+}, EtcKey extends string> = `${T}.modelName` | `${T}.modelDesc` | `${T}.${keyof GetStateObject<Model> & string}${"" | ".desc"}` | `${T}.insight.${keyof GetStateObject<Insight> & string}${"" | ".desc"}` | `${T}.query.${FilterTranslatorKey<Filter>}` | `${T}.sort.${keyof Filter["sort"] & string}${"" | ".desc"}` | `${T}.signal.${EndpointTranslatorKey<Endpoint> | SliceTranslatorKey<Slice>}` | `${T}.${EtcKey}`;
+export type ScalarTrans<T extends string, Model, ErrorKey extends string, EtcKey extends string> = {
+    name: Trans;
+    desc: Trans;
+    model: {
+        [K in keyof GetStateObject<Model>]: FieldTrans;
+    };
+    error: {
+        [K in ErrorKey]: Trans;
+    };
+} & {
+    [K in EtcKey]: Trans;
+};
+export type ScalarTranslatorKey<T extends string, Model, EtcKey extends string> = `${T}.modelName` | `${T}.modelDesc` | `${T}.${keyof GetStateObject<Model> & string}${"" | ".desc"}` | `${T}.${EtcKey}`;
+export type ServiceTrans<T extends string, Endpoint extends {
+    [key: string]: EndpointInfo;
+}, ErrorKey extends string, EtcKey extends string> = {
+    api: {
+        [K in keyof Endpoint]: FnTrans<Endpoint[K]["argNames"][number]>;
+    };
+    error: {
+        [K in ErrorKey]: Trans;
+    };
+} & {
+    [K in EtcKey]: Trans;
+};
+export type ServiceTranslatorKey<T extends string, Endpoint extends {
+    [key: string]: EndpointInfo;
+}, EtcKey extends string> = `${T}.signal.${EndpointTranslatorKey<Endpoint>}` | `${T}.${EtcKey}`;
+export type EnumTrans<EnumValue extends string | number> = {
+    [key in EnumValue]: Trans;
+};
+export type EnumTranslatorKey<EnumKey extends string> = `${EnumKey}.${string}${"" | ".desc"}`;
+export interface DictModule<DictKey extends string, ErrorKey extends string> {
+    __Dict_Key__: DictKey;
+    __Error_Key__: ErrorKey;
+    dict: ModelDictInfo<any> | ScalarDictInfo<any> | ServiceDictInfo<any>;
+}
+export declare const registerModelTrans: <RefName extends string, Model extends BaseObject, Insight extends BaseInsight, Filter extends FilterInstance, Slice extends {
+    [key: string]: SliceInfo;
+}, Endpoint extends {
+    [key: string]: EndpointInfo;
+}, ModelDict extends ModelDictInfo<any>>(modelDict: ModelDict) => ModelDict extends ModelDictInfo<any, any, any, any, any, infer EnumKey, any, any, any, infer ErrorKey, infer EtcKey> ? DictModule<ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>, `${RefName}.error.${ErrorKey}`> : never;
+export declare const registerScalarTrans: <T extends string, Model, ScalarDict>(scalarDict: ScalarDict) => ScalarDict extends ScalarDictInfo<any, any, infer EnumKey, infer ErrorKey, infer EtcKey> ? DictModule<ScalarTranslatorKey<T, Model, EtcKey> | EnumTranslatorKey<EnumKey>, `${T}.error.${ErrorKey}`> : never;
+export declare const registerServiceTrans: <T extends string, Endpoint extends {
+    [key: string]: EndpointInfo;
+}, ServiceDict>(serviceDict: ServiceDict) => ServiceDict extends ServiceDictInfo<any, any, infer ErrorKey, infer EtcKey> ? DictModule<ServiceTranslatorKey<T, Endpoint, EtcKey>, `${T}.error.${ErrorKey}`> : never;
+export {};

package/types/dictionary/trans.d.ts

@@ -0,0 +1,82 @@
+import type { GetStateObject, ObjectAssign, Prettify } from "akanjs/base";
+import type { DictModule } from "./locale.d.ts";
+type TranslationSingle = readonly [string, string] | readonly [string, string, string, string];
+type TranslationWithParam = readonly [string, string, {
+    [key: string]: string | number;
+}];
+export type Translation = TranslationSingle | TranslationWithParam;
+export type TranslationData = Record<string, unknown>;
+export type DictionaryNode = Record<string, unknown>;
+export type RootDictionary = Record<string, Record<string, DictionaryNode>>;
+export type Translate<Checker> = {
+    [K in keyof GetStateObject<Checker>]: Translation;
+} & Record<string, Translation> & {
+    modelName: Translation;
+};
+export type TransMessage<Locale extends Record<string, unknown>> = {
+    [K in keyof Locale]-?: `${K & string}${Locale[K] extends Record<string, unknown> ? `.${keyof Locale[K] extends string ? keyof Locale[K] : never}` : ""}`;
+}[keyof Locale];
+export declare const makeDictionary: <Dicts extends Record<string, unknown>[]>(...dicts: Dicts) => Prettify<ObjectAssign<Dicts>>;
+declare const languages: readonly ["en", "ko", "zhChs", "zhCht", "ja"];
+type Language = (typeof languages)[number];
+export interface TransMessageOption {
+    key?: string;
+    duration?: number;
+    data?: TranslationData;
+}
+export interface ErrRestoreOption {
+    statusCode?: number;
+    details?: unknown;
+    path?: string;
+    timestamp?: string;
+}
+export interface ErrPayload extends ErrRestoreOption {
+    error: string;
+    data?: TranslationData;
+}
+export type ErrInstance = Error & {
+    readonly error: string;
+    readonly statusCode: number;
+    readonly details?: unknown;
+    readonly data?: TranslationData;
+    readonly path?: string;
+    readonly timestamp?: string;
+    toJSON(): ErrPayload & {
+        statusCode: number;
+    };
+};
+export type ErrConstructor<ErrorKey extends string> = {
+    new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption): ErrInstance;
+    prototype: ErrInstance;
+    fromJSON(payload: ErrPayload): ErrInstance;
+    BadRequest: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+    Unauthorized: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+    Forbidden: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+    NotFound: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+    Conflict: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
+};
+export declare const msg: {
+    info: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+    success: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+    error: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+    warning: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+    loading: (key: TransMessage<Record<string, unknown>>, option?: TransMessageOption) => void;
+};
+export declare const makeTrans: <GlobalTransMap extends Record<string, DictModule<string, string>>, _DictKey extends string = GlobalTransMap[keyof GlobalTransMap]["__Dict_Key__"], _ErrorKey extends string = GlobalTransMap[keyof GlobalTransMap]["__Error_Key__"]>(transMap: GlobalTransMap, { build }?: {
+    build?: boolean;
+}) => {
+    Err: ErrConstructor<_ErrorKey>;
+    translate: (lang: Language, key: _DictKey, data?: TranslationData) => string;
+    msg: {
+        info: (key: _DictKey, option?: TransMessageOption) => void;
+        success: (key: _DictKey, option?: TransMessageOption) => void;
+        error: (key: _DictKey, option?: TransMessageOption) => void;
+        warning: (key: _DictKey, option?: TransMessageOption) => void;
+        loading: (key: _DictKey, option?: TransMessageOption) => void;
+    };
+    getDictionary: (lang: Language) => object;
+    getAllDictionary: () => RootDictionary;
+    __Dict_Key__: _DictKey;
+    __Error_Key__: _ErrorKey;
+};
+export {};

package/types/dictionary.d.ts

@@ -0,0 +1 @@
+export * from "./dictionary/index.d.ts";

package/types/document/by.d.ts

@@ -0,0 +1,20 @@
+import { type Cls, FIELD_META, type MergeAllActionTypes, type UnCls } from "akanjs/base";
+import { type BaseObject, type DocumentModel, type FieldObject } from "akanjs/constant";
+export type DatabaseCls<Schema = any> = Cls<Schema, {
+    refName: string;
+    [FIELD_META]: FieldObject;
+}>;
+export interface DefaultDocMtds<TDocument> {
+    refresh(): Promise<this>;
+    isModified(field?: keyof TDocument & string): boolean;
+    set(data: Partial<TDocument>): this;
+    save(): Promise<this>;
+    toJSON(): DocumentModel<TDocument>;
+    toObject(): DocumentModel<TDocument>;
+}
+type HydratedDocumentWithId<TDocument> = TDocument & {
+    id: string;
+} & DefaultDocMtds<TDocument>;
+export type Doc<M = any> = HydratedDocumentWithId<DocumentModel<M>>;
+export declare const by: <ModelCls, AddDbModels extends DatabaseCls[], _DocModel = UnCls<ModelCls> extends BaseObject ? Doc<UnCls<ModelCls>> : DocumentModel<UnCls<ModelCls>>>(modelRef: ModelCls, ...addRefs: AddDbModels) => DatabaseCls<MergeAllActionTypes<AddDbModels, keyof _DocModel & string> & _DocModel>;
+export {};

package/types/document/dataLoader.d.ts

@@ -0,0 +1,36 @@
+import type { QueryOf } from "akanjs/constant";
+export declare const Id: StringConstructor;
+export declare const ObjectId: StringConstructor;
+export declare const Mixed: ObjectConstructor;
+type LoaderItem = Record<string, unknown>;
+type LoaderModel = {
+    find: (query: QueryOf<unknown>) => Promise<LoaderItem[]> | {
+        then: Promise<LoaderItem[]>["then"];
+    };
+};
+type BatchLoadFn<Key, Value> = (keys: readonly Key[]) => PromiseLike<ReadonlyArray<Value | Error>> | ReadonlyArray<Value | Error>;
+interface DataLoaderOptions<Key, CacheKey> {
+    cache?: boolean;
+    cacheKeyFn?: (key: Key) => CacheKey;
+    batch?: boolean;
+    batchScheduleFn?: (callback: () => void) => void;
+    maxBatchSize?: number;
+    name?: string;
+}
+/** Minimal DataLoader-compatible batch loader used by Akan document resolvers. */
+export declare class DataLoader<Key, Value, CacheKey = Key> {
+    #private;
+    readonly name?: string;
+    constructor(batchLoadFn: BatchLoadFn<Key, Value>, options?: DataLoaderOptions<Key, CacheKey>);
+    load(key: Key): Promise<Value>;
+    loadMany(keys: readonly Key[]): Promise<Array<Value | Error>>;
+    clear(key: Key): this;
+    clearAll(): this;
+    prime(key: Key, value: Value | Error): this;
+}
+export declare const createLoader: <Key, Value>(model: LoaderModel, fieldName?: string, defaultQuery?: QueryOf<unknown>) => DataLoader<Key, Value, Key>;
+export declare const createArrayLoader: <K, V>(model: LoaderModel, fieldName?: string, defaultQuery?: QueryOf<unknown>) => DataLoader<K, V, K>;
+export declare const createArrayElementLoader: <K, V>(model: LoaderModel, fieldName?: string, defaultQuery?: QueryOf<unknown>) => DataLoader<K, V, K>;
+export declare const createQueryLoader: <Key, Value>(model: LoaderModel, queryKeys: string[], defaultQuery?: QueryOf<unknown>) => DataLoader<Key, Value, Key>;
+export type Loader<Field, Value> = DataLoader<Field, Value | null>;
+export {};

package/types/document/database.d.ts

@@ -0,0 +1,96 @@
+import type { Dayjs, MergedValues, PromiseOrObject } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type { DocumentModel, QueryOf } from "akanjs/constant";
+import type { CacheAdaptor } from "akanjs/service";
+import type { DataLoader } from "./dataLoader.d.ts";
+import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta.d.ts";
+import type { CRUDEventType, Mdl, SaveEventType } from "./into.d.ts";
+import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types.d.ts";
+export interface RedisSetOptions {
+    expireAt?: Dayjs;
+}
+export declare class CacheDatabase<T = unknown> {
+    private readonly refName;
+    private readonly cache;
+    private logger;
+    constructor(refName: string, cache: CacheAdaptor);
+    set(topic: string, key: string, value: string | number | Buffer, option?: RedisSetOptions): Promise<void>;
+    get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
+    delete(topic: string, key: string): Promise<void>;
+}
+type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends any[], _ListArgs extends any[], _FindArgs extends any[], _QueryOfDoc = QueryOf<Doc>> = {
+    [K in `list${CapitalizedK}`]: (...args: _ListArgs) => Promise<Doc[]>;
+} & {
+    [K in `listIds${CapitalizedK}`]: (...args: _ListArgs) => Promise<string[]>;
+} & {
+    [K in `find${CapitalizedK}`]: (...args: _FindArgs) => Promise<Doc | null>;
+} & {
+    [K in `findId${CapitalizedK}`]: (...args: _FindArgs) => Promise<string | null>;
+} & {
+    [K in `pick${CapitalizedK}`]: (...args: _FindArgs) => Promise<Doc>;
+} & {
+    [K in `pickId${CapitalizedK}`]: (...args: _FindArgs) => Promise<string>;
+} & {
+    [K in `exists${CapitalizedK}`]: (...args: _Args) => Promise<string | null>;
+} & {
+    [K in `count${CapitalizedK}`]: (...args: _Args) => Promise<number>;
+} & {
+    [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
+} & {
+    [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
+};
+export type QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption = FindQueryOption<Sort, Obj>, _ListQueryOption = ListQueryOption<Sort, Obj>, _QueryOfDoc = QueryOf<Doc>> = MergedValues<{
+    [K in keyof Query]: K extends string ? Query[K] extends (...args: infer Args) => any ? QueryMethodOfKey<Capitalize<K>, Doc, Insight, Args, [
+        ...Args,
+        queryOption?: _ListQueryOption
+    ], [
+        ...Args,
+        queryOption?: _FindQueryOption
+    ]> : never : never;
+}>;
+type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Query, Sort, _CapitalizedRefName extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _DataInput = DataInputOf<Input, DocumentModel<Obj>>, _FindQueryOption = FindQueryOption<Sort, Obj>, _ListQueryOption = ListQueryOption<Sort, Obj>> = {
+    logger: Logger;
+    __model: Mdl<Doc, Obj>;
+    __cache: CacheDatabase<T>;
+    __loader: DataLoader<string, Doc, string>;
+    __get: (id: string) => Promise<Doc>;
+    __load: (id?: string) => Promise<Doc | null>;
+    __loadMany: (ids: string[]) => Promise<Doc[]>;
+    __create: (data: _DataInput) => Promise<Doc>;
+    __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
+    __remove: (id: string) => Promise<Doc>;
+    __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
+    __listIds(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
+    __find(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;
+    __findId(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string | null>;
+    __pick(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc>;
+    __pickId(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string>;
+    __exists(query: _QueryOfDoc): Promise<string | null>;
+    __count(query: _QueryOfDoc): Promise<number>;
+    __insight(query: _QueryOfDoc): Promise<Insight>;
+    clone(data: _DataInput & {
+        id: string;
+    }): Promise<Doc>;
+    listenPre: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+    listenPost: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+} & {
+    [key in _CapitalizedRefName]: Mdl<Doc, Obj>;
+} & {
+    [key in `${T}Loader`]: DataLoader<string, Doc, string>;
+} & {
+    [key in `${T}Cache`]: CacheDatabase<T>;
+} & {
+    [K in `get${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `load${_CapitalizedRefName}`]: (id?: string) => Promise<Doc | null>;
+} & {
+    [K in `load${_CapitalizedRefName}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+    [K in `create${_CapitalizedRefName}`]: (data: _DataInput) => Promise<Doc>;
+} & {
+    [K in `update${_CapitalizedRefName}`]: (id: string, data: _DataInput) => Promise<Doc>;
+} & {
+    [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>;
+export type DatabaseInstance<T extends string = string, Input = any, Doc = any, Obj = any, Insight = any, Filter extends FilterInstance = FilterInstance, _CapitalizedRefName extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _Query = ExtractQuery<Filter>, _Sort = ExtractSort<Filter>, _DataInput = DataInputOf<Input, DocumentModel<Obj>>, _FindQueryOption = FindQueryOption<_Sort, Obj>, _ListQueryOption = ListQueryOption<_Sort, Obj>> = DatabaseModelWithQuerySort<T, Input, Doc, Obj, Insight, _Query, _Sort, _CapitalizedRefName, _QueryOfDoc, _DataInput, _FindQueryOption, _ListQueryOption>;
+export {};