akanjs 0.0.1 → 2.0.0-beta.0

package/store/baseSt.ts

@@ -0,0 +1,81 @@
+import type { PageState } from "akanjs/client";
+import { Responsive, responsiveWidths } from "akanjs/constant";
+import { type Account, getDefaultAccount } from "akanjs/fetch";
+import type { SignalType } from "akanjs/signal";
+import { store } from "./store";
+import { StoreRegistry } from "./storeRegistry";
+
+const defaultMessage = {
+  type: "info" as "info" | "success" | "error" | "warning" | "loading",
+  content: "",
+  duration: 3, // seconds
+  key: Math.random().toString(36).slice(2, 15),
+};
+
+export type BaseSearchParamsState = { [key: string]: string | string[] };
+
+export const getBaseSearchParam = (searchParams: BaseSearchParamsState, key: string) => {
+  const value = searchParams[key];
+  return Array.isArray(value) ? value[0] : value;
+};
+
+export class BaseStore extends store("base" as const, () => ({
+  csrLoaded: false,
+  path: "/",
+  pathname: typeof window !== "undefined" ? window.location.pathname : "/",
+  params: {} as { [key: string]: string },
+  searchParams: {} as BaseSearchParamsState,
+  theme: "system",
+  innerWidth: 0,
+  innerHeight: 0,
+  responsive: "md" as Responsive["value"],
+  uiOperation: "sleep" as "sleep" | "loading" | "idle",
+  messages: [] as (typeof defaultMessage)[],
+  tryJwt: null as string | null,
+  trySignalType: "restapi" as SignalType,
+  tryRoles: [] as string[], //[...roleTypes] as RoleType[],
+  tryAccount: getDefaultAccount() as Account<{ [key: string]: string | undefined }>,
+  keyboardHeight: 0,
+  pageState: {
+    transition: "none",
+    topSafeArea: 0,
+    bottomSafeArea: 0,
+    topInset: 0,
+    bottomInset: 0,
+    gesture: true,
+    cache: false,
+    topSafeAreaColor: "transparent",
+    bottomSafeAreaColor: "transparent",
+  } as PageState,
+  devMode: false,
+  deviceToken: "" as string,
+  currentPath: "" as string,
+})) {
+  setDevMode(value: boolean) {
+    this.set({ devMode: value });
+    localStorage.setItem("devMode", value.toString());
+  }
+  setWindowSize() {
+    if (typeof window === "undefined") return;
+    const responsive = Responsive.values[responsiveWidths.findIndex((w) => w < window.innerWidth)];
+    this.set({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, responsive });
+  }
+  showMessage(message: { content: string | string[] } & Partial<typeof defaultMessage>) {
+    message.key ??= Math.random().toString(36).slice(2, 15);
+    const { messages } = this.get();
+    const newMessage = { ...defaultMessage, ...message };
+
+    if (messages.some((m) => m.key === newMessage.key))
+      this.set({ messages: messages.map((m) => (m.key === newMessage.key ? newMessage : m)) });
+    else this.set({ messages: [...(messages.length > 6 ? messages.slice(1) : messages), newMessage] });
+  }
+  hideMessage(key: string) {
+    const { messages } = this.get();
+    this.set({ messages: messages.filter((m) => m.key !== key) });
+  }
+}
+export const base = StoreRegistry.register(BaseStore);
+
+export class RootStore extends StoreRegistry.merge("root" as const, BaseStore) {}
+
+export const st = StoreRegistry.build(RootStore);

package/store/hooks.ts

@@ -0,0 +1,2 @@
+"use client";
+export { useEffect, useRef, useSyncExternalStore } from "react";

package/store/index.ts

@@ -0,0 +1,8 @@
+export * from "./action";
+export * from "./baseSt";
+export * from "./rootStore";
+export * from "./state";
+export * from "./stateBuilder";
+export * from "./store";
+export * from "./storeRegistry";
+export * from "./types";

package/store/rootStore.ts

@@ -0,0 +1,26 @@
+import type { ACTION_META, Cls, STATE_DERIVED_META, STATE_INIT_META, STATE_META } from "akanjs/base";
+import type { SerializedSlice } from "akanjs/signal";
+import type { StateDerivedMeta, StateInitializerMap } from "./stateBuilder";
+import type { SetGetWritable } from "./types";
+
+export type RootStoreCls<
+  RefName extends string = any,
+  WritableState = any,
+  Action = any,
+  InternalSliceObj = any,
+  SliceInfoObj = any,
+  DerivedState = unknown,
+  State = WritableState & DerivedState,
+> = Cls<
+  SetGetWritable<WritableState, State> & Action & { slice: InternalSliceObj },
+  {
+    readonly type: "root";
+    refName: RefName;
+    [STATE_META]: State;
+    [STATE_INIT_META]: StateInitializerMap;
+    [STATE_DERIVED_META]: StateDerivedMeta;
+    [ACTION_META]: { [key: string]: (...args: any[]) => any };
+    slice: { [key: string]: { [key: string]: SerializedSlice } };
+    _slice: SliceInfoObj;
+  }
+>;

package/store/state.ts

@@ -0,0 +1,226 @@
+import { DataList, PRIMITIVE_DEFAULT_VALUE, PrimitiveRegistry, type SLICE_META } from "akanjs/base";
+import { capitalize } from "akanjs/common";
+import { type ConstantCls, ConstantRegistry, type DefaultOf } from "akanjs/constant";
+import type { ExtractSort, FilterInstance } from "akanjs/document";
+import type { SerializedSlice, SliceCls, SliceInfoArgs } from "akanjs/signal";
+import type { Submit } from "./types";
+
+export type SliceStateKey =
+  | "defaultModel"
+  | "modelInsight"
+  | "modelList"
+  | "modelListLoading"
+  | "modelInitList"
+  | "modelInitAt"
+  | "modelSelection"
+  | "lastPageOfModel"
+  | "pageOfModel"
+  | "limitOfModel"
+  | "queryArgsOfModel"
+  | "sortOfModel";
+type BaseState<RefName extends string, Full, _Default = DefaultOf<Full>> = {
+  [K in RefName]: Full | null;
+} & {
+  [K in `${RefName}Loading`]: string | boolean;
+} & {
+  [K in `${RefName}Form`]: _Default;
+} & {
+  [K in `${RefName}FormLoading`]: string | boolean;
+} & {
+  [K in `${RefName}Submit`]: Submit;
+} & {
+  [K in `${RefName}ViewAt`]: Date;
+} & {
+  [K in `${RefName}Modal`]: string | null;
+} & {
+  [K in `${RefName}Operation`]: "sleep" | "reset" | "idle" | "error" | "loading";
+};
+export type SliceState<
+  RefName extends string,
+  Suffix extends string,
+  Full,
+  Light extends { id: string },
+  Args,
+  Insight,
+  Filter extends FilterInstance,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _CapitalizedSuffix extends string = Capitalize<Suffix>,
+  _Default = DefaultOf<Full>,
+  _Sort = ExtractSort<Filter>,
+> = {
+  [K in `default${_CapitalizedRefName}${_CapitalizedSuffix}`]: _Default;
+} & {
+  [K in `${RefName}List${_CapitalizedSuffix}`]: DataList<Light>;
+} & {
+  [K in `${RefName}ListLoading${_CapitalizedSuffix}`]: boolean;
+} & {
+  [K in `${RefName}InitList${_CapitalizedSuffix}`]: DataList<Light>;
+} & {
+  [K in `${RefName}InitAt${_CapitalizedSuffix}`]: Date;
+} & {
+  [K in `${RefName}Selection${_CapitalizedSuffix}`]: DataList<Light>;
+} & {
+  [K in `${RefName}Insight${_CapitalizedSuffix}`]: Insight;
+} & {
+  [K in `lastPageOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: number;
+} & {
+  [K in `pageOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: number;
+} & {
+  [K in `limitOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: number;
+} & {
+  [K in `queryArgsOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: Args;
+} & {
+  [K in `sortOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: _Sort;
+};
+
+type _SliceMap<SlceCls extends SliceCls> = SlceCls[typeof SLICE_META];
+type _SuffixStr<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = Suffix & string;
+type _SuffixCap<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = Capitalize<
+  _SuffixStr<SlceCls, Suffix>
+>;
+type _ArgsOf<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = SliceInfoArgs<
+  _SliceMap<SlceCls>[Suffix]
+>;
+
+type DefaultSliceStateFields<
+  SlceCls extends SliceCls,
+  _RefName extends string,
+  _CapRefName extends string,
+  _Full,
+  _Light extends { id: string },
+  _Insight,
+  _Default,
+  _Sort,
+> = {
+  [Suffix in keyof _SliceMap<SlceCls> as `default${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _Default;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}List${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}ListLoading${_SuffixCap<SlceCls, Suffix>}`]: boolean;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitList${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitAt${_SuffixCap<SlceCls, Suffix>}`]: Date;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Selection${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Insight${_SuffixCap<SlceCls, Suffix>}`]: _Insight;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `lastPageOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `pageOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `limitOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `queryArgsOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _ArgsOf<
+    SlceCls,
+    Suffix
+  >;
+} & {
+  [Suffix in keyof _SliceMap<SlceCls> as `sortOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _Sort;
+};
+
+export type DefaultState<
+  SlceCls extends SliceCls,
+  _RefName extends SlceCls["srv"]["cnst"]["refName"] = SlceCls["srv"]["cnst"]["refName"],
+  _Full = NonNullable<SlceCls["srv"]["cnst"]>["_Full"],
+  _Light extends { id: string } = SlceCls["srv"]["cnst"]["_Light"],
+  _Insight = SlceCls["srv"]["cnst"]["_Insight"],
+  _Filter extends FilterInstance = SlceCls["srv"]["db"]["_Filter"],
+  _CapitalizedRefName extends string = Capitalize<_RefName>,
+  _Default = SlceCls["srv"]["cnst"]["_Default"],
+  _Sort = SlceCls["srv"]["db"]["_Sort"],
+> = BaseState<_RefName, _Full, _Default> &
+  DefaultSliceStateFields<SlceCls, _RefName, _CapitalizedRefName, _Full, _Light, _Insight, _Default, _Sort>;
+
+export const createDatabaseState = (refName: string) => {
+  const cnst = ConstantRegistry.getDatabase(refName);
+  const [fieldName, className] = [refName, capitalize(refName)];
+  const names = {
+    model: fieldName,
+    Model: className,
+    modelLoading: `${fieldName}Loading`,
+    modelForm: `${fieldName}Form`,
+    modelFormLoading: `${fieldName}FormLoading`,
+    modelSubmit: `${fieldName}Submit`,
+    modelViewAt: `${fieldName}ViewAt`,
+    modelModal: `${fieldName}Modal`,
+    modelOperation: `${fieldName}Operation`,
+  };
+  const baseState = {
+    [names.model]: null,
+    [names.modelLoading]: true,
+    [names.modelForm]: new cnst.input() as object,
+    [names.modelFormLoading]: true,
+    [names.modelSubmit]: { disabled: true, loading: false, times: 0 },
+    [names.modelViewAt]: new Date(0),
+    [names.modelModal]: null,
+    [names.modelOperation]: "sleep",
+  };
+  return baseState;
+};
+export const createSliceState = (refName: string, slice: { [key: string]: SerializedSlice }) => {
+  const cnst = ConstantRegistry.getDatabase(refName);
+  const [fieldName, className] = [refName, capitalize(refName)];
+  const names = {
+    model: fieldName,
+    Model: className,
+    defaultModel: `default${className}`,
+    defaultModelInsight: `default${className}Insight`,
+    modelList: `${fieldName}List`,
+    modelListLoading: `${fieldName}ListLoading`,
+    modelInitList: `${fieldName}InitList`,
+    modelInitAt: `${fieldName}InitAt`,
+    modelSelection: `${fieldName}Selection`,
+    modelInsight: `${fieldName}Insight`,
+    lastPageOfModel: `lastPageOf${className}`,
+    pageOfModel: `pageOf${className}`,
+    limitOfModel: `limitOf${className}`,
+    queryArgsOfModel: `queryArgsOf${className}`,
+    sortOfModel: `sortOf${className}`,
+  };
+  const sliceState: Record<string, unknown> = {};
+  Object.entries(slice).forEach(([suffix, serializedSlice]) => {
+    const defaultArgs = serializedSlice.args.map((arg) => {
+      if (arg.modelType) {
+        const modelRef = ConstantRegistry.getModelRef(arg.refName, arg.modelType) as ConstantCls;
+        return modelRef.getDefault();
+      } else {
+        const modelRef = PrimitiveRegistry.get(arg.refName);
+        return modelRef[PRIMITIVE_DEFAULT_VALUE];
+      }
+    });
+    const sliceName = `${refName}${capitalize(suffix)}`;
+    const SliceName = capitalize(sliceName);
+    const namesOfSlice: { [key in SliceStateKey]: string } = {
+      defaultModel: SliceName.replace(names.Model, names.defaultModel), //clusterInSelf Cluster
+      modelList: sliceName.replace(names.model, names.modelList),
+      modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+      modelInitList: sliceName.replace(names.model, names.modelInitList),
+      modelInitAt: sliceName.replace(names.model, names.modelInitAt),
+      modelSelection: sliceName.replace(names.model, names.modelSelection),
+      modelInsight: sliceName.replace(names.model, names.modelInsight),
+      lastPageOfModel: SliceName.replace(names.Model, names.lastPageOfModel),
+      pageOfModel: SliceName.replace(names.Model, names.pageOfModel),
+      limitOfModel: SliceName.replace(names.Model, names.limitOfModel),
+      queryArgsOfModel: SliceName.replace(names.Model, names.queryArgsOfModel),
+      sortOfModel: SliceName.replace(names.Model, names.sortOfModel),
+    };
+    const singleSliceState = {
+      [namesOfSlice.defaultModel]: new cnst.full(),
+      [namesOfSlice.modelList]: new DataList(),
+      [namesOfSlice.modelListLoading]: true,
+      [namesOfSlice.modelInitList]: new DataList(),
+      [namesOfSlice.modelInitAt]: new Date(0),
+      [namesOfSlice.modelSelection]: new DataList(),
+      [namesOfSlice.modelInsight]: new cnst.insight(),
+      [namesOfSlice.lastPageOfModel]: 1,
+      [namesOfSlice.pageOfModel]: 1,
+      [namesOfSlice.limitOfModel]: 20,
+      [namesOfSlice.queryArgsOfModel]: defaultArgs,
+      [namesOfSlice.sortOfModel]: "latest",
+    };
+    Object.assign(sliceState, singleSliceState);
+  });
+  return sliceState;
+};