akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/dictionary/dictShape.ts

@@ -0,0 +1,54 @@
+import type { ENDPOINT_DICT_SHAPE, FILTER_DICT_SHAPE, SLICE_DICT_SHAPE } from "akanjs/base";
+import type {
+  FilterCls,
+  FilterDictShape as FilterCompactShape,
+  FilterDictArgShape,
+  FilterInfo,
+  FilterInstance,
+} from "akanjs/document";
+import type {
+  EndpointCls,
+  EndpointDictShape as EndpointCompactShape,
+  EndpointInfo,
+  SliceCls,
+  SliceDictShape as SliceCompactShape,
+  SliceInfo,
+} from "akanjs/signal";
+
+type DictArgShape = { [key: string]: readonly string[] };
+type AnyFilterShape = FilterCompactShape<FilterInstance<Record<string, FilterInfo>, Record<string, unknown>>>;
+type DictFilterShape<Filter> =
+  Filter extends FilterCls<infer FilterShape>
+    ? FilterCompactShape<FilterShape>
+    : Filter extends { readonly [FILTER_DICT_SHAPE]: infer CompactShape extends FilterDictArgShape }
+      ? CompactShape
+      : Filter extends FilterInstance
+        ? FilterCompactShape<Filter>
+        : Filter extends { query: Record<string, FilterInfo>; sort: Record<string, unknown> }
+          ? FilterCompactShape<Filter>
+          : Filter extends { query: DictArgShape; sort: Record<string, true> }
+            ? Filter
+            : AnyFilterShape;
+export type DictSliceShape<Slice> =
+  Slice extends SliceCls<infer _SrvModule, infer SliceInfoObj>
+    ? SliceCompactShape<SliceInfoObj>
+    : Slice extends { readonly [SLICE_DICT_SHAPE]: infer CompactShape extends DictArgShape }
+      ? CompactShape
+      : Slice extends DictArgShape
+        ? Slice
+        : Slice extends Record<string, SliceInfo>
+          ? SliceCompactShape<Slice>
+          : Record<never, never>;
+export type DictEndpointShape<Endpoint> =
+  Endpoint extends EndpointCls<infer _SrvModule, infer EndpointInfoObj>
+    ? EndpointCompactShape<EndpointInfoObj>
+    : Endpoint extends { readonly [ENDPOINT_DICT_SHAPE]: infer CompactShape extends DictArgShape }
+      ? CompactShape
+      : Endpoint extends DictArgShape
+        ? Endpoint
+        : Endpoint extends Record<string, EndpointInfo>
+          ? EndpointCompactShape<Endpoint>
+          : Record<never, never>;
+export type DictArgNames<ArgNames> = ArgNames extends readonly string[] ? ArgNames[number] : never;
+export type DictFilterQuery<Filter> = DictFilterShape<Filter>["query"];
+export type DictFilterSort<Filter> = DictFilterShape<Filter>["sort"];

package/dictionary/dictionary.ts

@@ -1,7 +1,6 @@
 import type { AgentEndpoint, AgentTurn, BaseEndpoint } from "akanjs/signal";
 
-import { agentDictionary } from "./agent.dictionary";
-import { agentTurnDictionary } from "./agentTurn.dictionary";
+import { agentDictionary, agentTurnDictionary } from "./agent.dictionary";
 import { baseDictionary } from "./base.dictionary";
 import { registerScalarTrans, registerServiceTrans } from "./locale";
 import { makeTrans } from "./trans";

package/dictionary/dictionaryRegistry.ts

@@ -1,6 +1,6 @@
 import { parseAkanI18nEnv } from "akanjs/common";
 
-import { ModelDictInfo, ScalarDictInfo, ServiceDictInfo } from "./dictInfo";
+import { ModelDictInfo, ScalarDictInfo } from "./dictInfo";
 import type { DictModule } from "./locale";
 import type { DictionaryNode, RootDictionary } from "./trans";
 
@@ -17,13 +17,6 @@ export interface LocaleGap {
   missing: string[];
 }
 
-/**
- * Collects every dictionary tree built by `makeTrans` so a server process can read the merged result.
- *
- * `makeTrans` keeps its `rootDictionary` in a closure and `AkanLib` carries no dictionary, so without this
- * the i18n tree is unreachable from `AkanServer`. Registration happens at module-evaluation time, which the
- * API process reaches because it imports the generated `server.ts` (which re-exports `lib/dict.ts`) whole.
- */
 export class DictionaryRegistry {
   static readonly #roots: RootDictionary[] = [];
   static readonly #modules = new Map<string, DictionaryModuleInfo>();
@@ -31,21 +24,18 @@ export class DictionaryRegistry {
   /** Registration order is base → libs → app, matching `makeDictionary`, so a later root wins on conflict. */
   static register(root: RootDictionary, transMap: Record<string, DictModule<string, string>>) {
     DictionaryRegistry.#roots.push(root);
-    Object.entries(transMap).forEach(([refName, trans]) => {
+    for (const [refName, trans] of Object.entries(transMap))
       DictionaryRegistry.#modules.set(refName, {
         kind: DictionaryRegistry.#resolveKind(trans),
         languages: [...((trans.dict as { languages?: string[] }).languages ?? [])],
       });
-    });
   }
 
   static getRoot(): RootDictionary {
     const merged = {} as RootDictionary;
-    DictionaryRegistry.#roots.forEach((root) => {
-      Object.entries(root).forEach(([language, models]) => {
+    for (const root of DictionaryRegistry.#roots)
+      for (const [language, models] of Object.entries(root))
         merged[language] = { ...(merged[language] ?? {}), ...models };
-      });
-    });
     return merged;
   }
 
@@ -57,14 +47,7 @@ export class DictionaryRegistry {
     return Object.fromEntries([...DictionaryRegistry.#modules.entries()].map(([key, info]) => [key, { ...info }]));
   }
 
-  /**
-   * Which configured locales the registered dictionaries never wrote, per locale.
-   *
-   * A dictionary declares its own locale tuple — `serviceDictionary(["en", "ko"])` — and a lib ships that tuple to
-   * every app that mounts it, so an app that adds a third locale cannot widen it from the outside. Every key those
-   * modules own then resolves through the default-locale fallback: the screen stays readable and nothing throws,
-   * which is exactly why the gap is invisible without asking.
-   */
+  /** Modules whose own locale tuple lacks a configured locale; their keys silently fall back to the default locale. */
   static getLocaleGaps(locales: string[] = parseAkanI18nEnv().locales): LocaleGap[] {
     const modules = [...DictionaryRegistry.#modules.entries()];
     return locales
@@ -79,11 +62,8 @@ export class DictionaryRegistry {
   /** Flattened dotted paths of every leaf translation, e.g. `"user.signal.createUser.arg.data"`. */
   static getKeys(root: RootDictionary = DictionaryRegistry.getRoot()): string[] {
     const keys = new Set<string>();
-    Object.values(root).forEach((models) => {
-      Object.entries(models).forEach(([refName, node]) => {
-        DictionaryRegistry.#collectKeys(refName, node, keys);
-      });
-    });
+    for (const models of Object.values(root))
+      for (const [refName, node] of Object.entries(models)) DictionaryRegistry.#collectKeys(refName, node, keys);
     return [...keys].sort();
   }
 
@@ -108,7 +88,6 @@ export class DictionaryRegistry {
   static #resolveKind(trans: DictModule<string, string>): DictionaryModuleKind {
     if (trans.dict instanceof ModelDictInfo) return "model";
     if (trans.dict instanceof ScalarDictInfo) return "scalar";
-    if (trans.dict instanceof ServiceDictInfo) return "service";
     return "service";
   }
 }

package/dictionary/locale.ts

@@ -1,29 +1,8 @@
-import type {
-  ENDPOINT_DICT_SHAPE,
-  FILTER_DICT_SHAPE,
-  GetStateObject,
-  MergedValues,
-  SLICE_DICT_SHAPE,
-} from "akanjs/base";
+import type { GetStateObject, MergedValues } from "akanjs/base";
 import type { BaseInsight, BaseObject } from "akanjs/constant";
-import type {
-  FilterCls,
-  FilterDictShape as FilterCompactShape,
-  FilterDictArgShape,
-  FilterInfo,
-  FilterInstance,
-} from "akanjs/document";
-import type {
-  EndpointCls,
-  EndpointDictShape as EndpointCompactShape,
-  EndpointInfo,
-  SliceCls,
-  SliceDictShape as SliceCompactShape,
-  SliceInfo,
-  SliceInfoArgNames,
-  SliceInfoRefName,
-} from "akanjs/signal";
+import type { SliceInfo, SliceInfoArgNames, SliceInfoRefName } from "akanjs/signal";
 import type { ModelDictInfo, ScalarDictInfo, ServiceDictInfo } from ".";
+import type { DictArgNames, DictEndpointShape, DictFilterQuery, DictFilterSort, DictSliceShape } from "./dictShape";
 
 interface Trans {
   t: string;
@@ -37,43 +16,6 @@ interface FnTrans<ArgKey extends string> {
   desc?: string;
   arg?: { [key in ArgKey]: FieldTrans };
 }
-type DictArgShape = { [key: string]: readonly string[] };
-type AnyFilterShape = FilterCompactShape<FilterInstance<Record<string, FilterInfo>, Record<string, unknown>>>;
-type DictFilterShape<Filter> =
-  Filter extends FilterCls<infer FilterShape>
-    ? FilterCompactShape<FilterShape>
-    : Filter extends { readonly [FILTER_DICT_SHAPE]: infer CompactShape extends FilterDictArgShape }
-      ? CompactShape
-      : Filter extends FilterInstance
-        ? FilterCompactShape<Filter>
-        : Filter extends { query: Record<string, FilterInfo>; sort: Record<string, unknown> }
-          ? FilterCompactShape<Filter>
-          : Filter extends { query: DictArgShape; sort: Record<string, true> }
-            ? Filter
-            : AnyFilterShape;
-type DictFilterQuery<Filter> = DictFilterShape<Filter>["query"];
-type DictFilterSort<Filter> = DictFilterShape<Filter>["sort"];
-type DictArgNames<ArgNames> = ArgNames extends readonly string[] ? ArgNames[number] : never;
-type DictEndpointShape<Endpoint> =
-  Endpoint extends EndpointCls<infer _SrvModule, infer EndpointInfoObj>
-    ? EndpointCompactShape<EndpointInfoObj>
-    : Endpoint extends { readonly [ENDPOINT_DICT_SHAPE]: infer CompactShape extends DictArgShape }
-      ? CompactShape
-      : Endpoint extends DictArgShape
-        ? Endpoint
-        : Endpoint extends Record<string, EndpointInfo>
-          ? EndpointCompactShape<Endpoint>
-          : Record<never, never>;
-type DictSliceShape<Slice> =
-  Slice extends SliceCls<infer _SrvModule, infer SliceInfoObj>
-    ? SliceCompactShape<SliceInfoObj>
-    : Slice extends { readonly [SLICE_DICT_SHAPE]: infer CompactShape extends DictArgShape }
-      ? CompactShape
-      : Slice extends DictArgShape
-        ? Slice
-        : Slice extends Record<string, SliceInfo>
-          ? SliceCompactShape<Slice>
-          : Record<never, never>;
 type FilterTranslatorKey<Filter> = {
   [Key in keyof DictFilterQuery<Filter> & string]:
     | `${Key}`
@@ -214,35 +156,8 @@ export interface DictModule<DictKey extends string, ErrorKey extends string> {
     | ServiceDictInfo<[string, ...string[]]>;
 }
 
-export const registerModelTrans = <
-  RefName extends string,
-  Model extends BaseObject,
-  Insight extends BaseInsight,
-  Filter,
-  Slice,
-  Endpoint,
-  ModelDict,
->(
-  modelDict: ModelDict,
-): ModelDict extends ModelDictInfo<
-  infer _Languages,
-  infer _ModelKey,
-  infer _InsightKey,
-  infer _QueryKey,
-  infer _SortKey,
-  infer EnumKey,
-  infer _BaseSignalKey,
-  infer _SliceKey,
-  infer _EndpointKey,
-  infer ErrorKey,
-  infer EtcKey
->
-  ? DictModule<
-      ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
-      `${RefName}.error.${ErrorKey}`
-    >
-  : never => {
-  return { dict: modelDict } as unknown as ModelDict extends ModelDictInfo<
+type ModelDictModule<RefName extends string, Model, Insight, Filter, Slice, Endpoint, ModelDict> =
+  ModelDict extends ModelDictInfo<
     infer _Languages,
     infer _ModelKey,
     infer _InsightKey,
@@ -260,35 +175,28 @@ export const registerModelTrans = <
         `${RefName}.error.${ErrorKey}`
       >
     : never;
-};
+export const registerModelTrans = <
+  RefName extends string,
+  Model extends BaseObject,
+  Insight extends BaseInsight,
+  Filter,
+  Slice,
+  Endpoint,
+  ModelDict,
+>(
+  modelDict: ModelDict,
+) => ({ dict: modelDict }) as unknown as ModelDictModule<RefName, Model, Insight, Filter, Slice, Endpoint, ModelDict>;
 
-export const registerScalarTrans = <T extends string, Model, ScalarDict>(
-  scalarDict: ScalarDict,
-): ScalarDict extends ScalarDictInfo<infer _Languages, infer _ModelKey, infer EnumKey, infer ErrorKey, infer EtcKey>
-  ? DictModule<ScalarTranslatorKey<T, Model, EtcKey> | EnumTranslatorKey<EnumKey>, `${T}.error.${ErrorKey}`>
-  : never => {
-  return { dict: scalarDict } as unknown as ScalarDict extends ScalarDictInfo<
-    infer _Languages,
-    infer _ModelKey,
-    infer EnumKey,
-    infer ErrorKey,
-    infer EtcKey
-  >
+type ScalarDictModule<T extends string, Model, ScalarDict> =
+  ScalarDict extends ScalarDictInfo<infer _Languages, infer _ModelKey, infer EnumKey, infer ErrorKey, infer EtcKey>
     ? DictModule<ScalarTranslatorKey<T, Model, EtcKey> | EnumTranslatorKey<EnumKey>, `${T}.error.${ErrorKey}`>
     : never;
-};
+export const registerScalarTrans = <T extends string, Model, ScalarDict>(scalarDict: ScalarDict) =>
+  ({ dict: scalarDict }) as unknown as ScalarDictModule<T, Model, ScalarDict>;
 
-export const registerServiceTrans = <T extends string, Endpoint, ServiceDict>(
-  serviceDict: ServiceDict,
-): ServiceDict extends ServiceDictInfo<infer _Languages, infer _EndpointKey, infer ErrorKey, infer EtcKey>
-  ? DictModule<ServiceTranslatorKey<T, Endpoint, EtcKey>, `${T}.error.${ErrorKey}`>
-  : never => {
-  return { dict: serviceDict } as unknown as ServiceDict extends ServiceDictInfo<
-    infer _Languages,
-    infer _EndpointKey,
-    infer ErrorKey,
-    infer EtcKey
-  >
+type ServiceDictModule<T extends string, Endpoint, ServiceDict> =
+  ServiceDict extends ServiceDictInfo<infer _Languages, infer _EndpointKey, infer ErrorKey, infer EtcKey>
     ? DictModule<ServiceTranslatorKey<T, Endpoint, EtcKey>, `${T}.error.${ErrorKey}`>
     : never;
-};
+export const registerServiceTrans = <T extends string, Endpoint, ServiceDict>(serviceDict: ServiceDict) =>
+  ({ dict: serviceDict }) as unknown as ServiceDictModule<T, Endpoint, ServiceDict>;

package/dictionary/trans.ts

@@ -19,11 +19,8 @@ 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 const makeDictionary = <Dicts extends Record<string, unknown>[]>(
-  ...dicts: Dicts
-): Prettify<ObjectAssign<Dicts>> => {
-  return Object.assign(...(dicts as unknown as [object, object])) as Prettify<ObjectAssign<Dicts>>;
-};
+export const makeDictionary = <Dicts extends Record<string, unknown>[]>(...dicts: Dicts) =>
+  Object.assign(...(dicts as unknown as [object, object])) as Prettify<ObjectAssign<Dicts>>;
 
 type Language = "en" | "ko" | "zhChs" | "zhCht" | "ja" | (string & {});
 export interface TransMessageOption {
@@ -53,6 +50,9 @@ export type ErrInstance = Error & {
   readonly timestamp?: string;
   toJSON(): ErrPayload & { statusCode: number };
 };
+type MsgApi<Key> = {
+  [Level in "info" | "success" | "error" | "warning" | "loading"]: (key: Key, option?: TransMessageOption) => void;
+};
 
 export type ErrConstructor<ErrorKey extends string> = {
   new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption): ErrInstance;
@@ -65,15 +65,6 @@ export type ErrConstructor<ErrorKey extends string> = {
   Conflict: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
 };
 
-/**
- * The toast API, before anything has claimed it.
- *
- * `<Messages/>` assigns the real implementations onto this object when it mounts, so a call before that — a
- * store action on the first frame — has nowhere to go. It stays a no-op rather than throwing (a dropped toast
- * must not take the render with it) and says so once, because a message that silently never appeared is
- * otherwise indistinguishable from one the user missed. Server code reaches this object too, through
- * `akanjs/dictionary`, and there nothing ever assigns over it.
- */
 const unclaimed = (level: string) => () => {
   if (unclaimed.warned) return null;
   unclaimed.warned = true;
@@ -90,13 +81,7 @@ export const msg = {
   error: unclaimed("error"),
   warning: unclaimed("warning"),
   loading: unclaimed("loading"),
-} as {
-  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;
-};
+} as MsgApi<TransMessage<Record<string, unknown>>>;
 
 export const makeTrans = <
   GlobalTransMap extends Record<string, DictModule<string, string>>,
@@ -108,24 +93,17 @@ export const makeTrans = <
 ): {
   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;
-  };
+  msg: MsgApi<_DictKey>;
   getDictionary: (lang: Language) => object;
   getAllDictionary: () => RootDictionary;
   __Dict_Key__: _DictKey;
   __Error_Key__: _ErrorKey;
 } => {
   const rootDictionary = {} as RootDictionary;
-  Object.entries(transMap).forEach(([refName, trans]) => {
-    trans.dict._registerToRoot(refName, rootDictionary);
-  });
+  for (const [refName, trans] of Object.entries(transMap)) trans.dict._registerToRoot(refName, rootDictionary);
   DictionaryRegistry.register(rootDictionary, transMap);
   class Err extends Error {
+    declare static status?: number;
     readonly error: string;
     readonly statusCode: number;
     readonly details?: unknown;
@@ -137,7 +115,7 @@ export const makeTrans = <
       super(key as string);
       this.name = this.constructor.name;
       this.error = key as string;
-      this.statusCode = option.statusCode ?? 400;
+      this.statusCode = new.target.status ?? option.statusCode ?? 400;
       this.details = option.details;
       this.data = data;
       this.path = option.path;
@@ -160,33 +138,23 @@ export const makeTrans = <
     }
 
     static BadRequest = class BadRequestErr extends Err {
-      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
-        super(key, data, { ...option, statusCode: 400 });
-      }
+      static override status = 400;
     };
 
     static Unauthorized = class UnauthorizedErr extends Err {
-      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
-        super(key, data, { ...option, statusCode: 401 });
-      }
+      static override status = 401;
     };
 
     static Forbidden = class ForbiddenErr extends Err {
-      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
-        super(key, data, { ...option, statusCode: 403 });
-      }
+      static override status = 403;
     };
 
     static NotFound = class NotFoundErr extends Err {
-      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
-        super(key, data, { ...option, statusCode: 404 });
-      }
+      static override status = 404;
     };
 
     static Conflict = class ConflictErr extends Err {
-      constructor(key: _ErrorKey, data?: TranslationData, option: ErrRestoreOption = {}) {
-        super(key, data, { ...option, statusCode: 409 });
-      }
+      static override status = 409;
     };
   }
   const lookup = (lang: string, modelName: string, msgKey: string) => {
@@ -195,7 +163,7 @@ export const makeTrans = <
     const node = pathGetLoose(msgKey, model, ".") as { t?: unknown } | null;
     return typeof node?.t === "string" ? node.t : undefined;
   };
-
+  
   const lookupDefault = (lang: string, modelName: string, msgKey: string) => {
     const { defaultLocale } = parseAkanI18nEnv();
     return defaultLocale === lang ? undefined : lookup(defaultLocale, modelName, msgKey);
@@ -206,18 +174,12 @@ export const makeTrans = <
     const message = lookup(lang, modelName, msgKey) ?? lookupDefault(lang, modelName, msgKey) ?? (key as string);
     return interpolateTranslation(message, data);
   };
-  const getDictionary = (lang: Language) => {
-    return rootDictionary[lang];
-  };
-  const getAllDictionary = () => {
-    return rootDictionary;
-  };
   return {
     Err,
     translate,
     msg,
-    getDictionary,
-    getAllDictionary,
+    getDictionary: (lang: Language) => rootDictionary[lang],
+    getAllDictionary: () => rootDictionary,
     __Dict_Key__: null as unknown as _DictKey,
     __Error_Key__: null as unknown as _ErrorKey,
   };