akanjs 0.0.1 → 2.0.0-beta.1

package/cli/workspace/workspace.script.ts

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { Logger } from "akanjs/common";
+import { AppExecutor, type Exec, LibExecutor, PkgExecutor, script, type Workspace } from "akanjs/devkit";
+
+import { ApplicationScript } from "../application/application.script";
+import { LibraryScript } from "../library/library.script";
+import { WorkspaceRunner } from "./workspace.runner";
+
+export class WorkspaceScript extends script("workspace", [WorkspaceRunner, ApplicationScript, LibraryScript]) {
+  async createWorkspace(
+    repoName: string,
+    appName: string,
+    {
+      dirname = ".",
+      installLibs = false,
+      tag = "latest",
+      init = true,
+    }: { dirname?: string; installLibs?: boolean; tag?: string; init?: boolean },
+  ) {
+    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, { dirname, tag, init });
+    if (installLibs) {
+      await this.libraryScript.installLibrary(workspace, "util");
+      await this.libraryScript.installLibrary(workspace, "shared");
+    }
+    await this.applicationScript.createApplication(appName, workspace, { libs: installLibs ? ["util", "shared"] : [] });
+    const gitSpinner = workspace.spinning("Initializing git repository and commit...");
+    try {
+      await workspace.commit("Initial commit", { init: true });
+      gitSpinner.succeed("Git repository initialized and committed");
+    } catch (_) {
+      gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
+    }
+    const workspacePath = path.join(dirname, repoName);
+    Logger.rawLog(`\n🎉 Welcome aboard! Workspace created in ${dirname}/${repoName}`);
+    Logger.rawLog(`🚀 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
+    
+    Logger.rawLog(`\n👋 Happy coding!`);
+  }
+  async lint(exec: Exec, workspace: Workspace, { fix = true }: { fix?: boolean } = {}) {
+    if (exec instanceof AppExecutor) await this.applicationScript.sync(exec);
+    else if (exec instanceof LibExecutor) await this.libraryScript.syncLibrary(exec);
+    const spinner = workspace.spinning(`Linting${fix ? " with fix" : ""}...`);
+    try {
+      await this.workspaceRunner.lint(exec, workspace, { fix });
+      spinner.succeed("Lint completed with no errors");
+    } catch (error) {
+      spinner.fail("Lint failed with errors");
+      throw error;
+    }
+  }
+  async lintAll(workspace: Workspace, { fix = true }: { fix?: boolean } = {}) {
+    const [appNames, libNames, pkgNames] = await workspace.getExecs();
+    await Promise.all(appNames.map((appName) => this.applicationScript.sync(AppExecutor.from(workspace, appName))));
+    await Promise.all(libNames.map((libName) => this.libraryScript.syncLibrary(LibExecutor.from(workspace, libName))));
+    await Promise.all([
+      ...appNames.map((appName) => this.workspaceRunner.lint(AppExecutor.from(workspace, appName), workspace, { fix })),
+      ...libNames.map((libName) => this.workspaceRunner.lint(LibExecutor.from(workspace, libName), workspace, { fix })),
+      ...pkgNames
+        .filter((pkgName) => pkgName !== "contract") 
+        .map((pkgName) => this.workspaceRunner.lint(PkgExecutor.from(workspace, pkgName), workspace, { fix })),
+    ]);
+  }
+  async syncAll(workspace: Workspace) {
+    const [appNames, libNames] = await workspace.getExecs();
+    for (const libName of libNames) await this.libraryScript.syncLibrary(LibExecutor.from(workspace, libName));
+    for (const appName of appNames) await this.applicationScript.sync(AppExecutor.from(workspace, appName));
+  }
+}

package/client/capacitor.ts

@@ -0,0 +1,68 @@
+type CapacitorModuleMap = {
+  app: typeof import("@capacitor/app");
+  browser: typeof import("@capacitor/browser");
+  camera: typeof import("@capacitor/camera");
+  contacts: typeof import("@capacitor-community/contacts");
+  device: typeof import("@capacitor/device");
+  fcm: typeof import("@capacitor-community/fcm");
+  geolocation: typeof import("@capacitor/geolocation");
+  haptics: typeof import("@capacitor/haptics");
+  keyboard: typeof import("@capacitor/keyboard");
+  pushNotifications: typeof import("@capacitor/push-notifications");
+  safeArea: typeof import("capacitor-plugin-safe-area");
+  updater: typeof import("@capgo/capacitor-updater");
+};
+
+type CapacitorImportCache = Partial<{
+  [K in keyof CapacitorModuleMap]: Promise<CapacitorModuleMap[keyof CapacitorModuleMap]>;
+}>;
+
+declare global {
+  
+  var __AKAN_CAPACITOR_IMPORTS__: CapacitorImportCache | undefined;
+}
+
+const getCapacitorImportCache = () => {
+  globalThis.__AKAN_CAPACITOR_IMPORTS__ ??= {};
+  return globalThis.__AKAN_CAPACITOR_IMPORTS__;
+};
+
+const loadCapacitorModule = <K extends keyof CapacitorModuleMap>(
+  name: K,
+  loader: () => Promise<CapacitorModuleMap[K]>,
+) => {
+  const cache = getCapacitorImportCache();
+  const cached = cache[name] as Promise<CapacitorModuleMap[K]> | undefined;
+  if (cached) return cached;
+
+  const loaded = loader();
+  cache[name] = loaded;
+  return loaded;
+};
+
+export const loadCapacitorApp = () => loadCapacitorModule("app", () => import("@capacitor/app"));
+
+export const loadCapacitorBrowser = () => loadCapacitorModule("browser", () => import("@capacitor/browser"));
+
+export const loadCapacitorCamera = () => loadCapacitorModule("camera", () => import("@capacitor/camera"));
+
+export const loadCapacitorContacts = () =>
+  loadCapacitorModule("contacts", () => import("@capacitor-community/contacts"));
+
+export const loadCapacitorDevice = () => loadCapacitorModule("device", () => import("@capacitor/device"));
+
+export const loadCapacitorFcm = () => loadCapacitorModule("fcm", () => import("@capacitor-community/fcm"));
+
+export const loadCapacitorGeolocation = () =>
+  loadCapacitorModule("geolocation", () => import("@capacitor/geolocation"));
+
+export const loadCapacitorHaptics = () => loadCapacitorModule("haptics", () => import("@capacitor/haptics"));
+
+export const loadCapacitorKeyboard = () => loadCapacitorModule("keyboard", () => import("@capacitor/keyboard"));
+
+export const loadCapacitorPushNotifications = () =>
+  loadCapacitorModule("pushNotifications", () => import("@capacitor/push-notifications"));
+
+export const loadCapacitorSafeArea = () => loadCapacitorModule("safeArea", () => import("capacitor-plugin-safe-area"));
+
+export const loadCapacitorUpdater = () => loadCapacitorModule("updater", () => import("@capgo/capacitor-updater"));

package/client/clientRuntime.ts

@@ -0,0 +1,141 @@
+import type { SliceMeta } from "akanjs/fetch";
+import type { ReactNode } from "react";
+import type { TransMessageOption } from "./makePageProto";
+
+type RuntimeTranslate = ((key: string, param?: Record<string, string | number>) => string) & {
+  _: (key: string, param?: Record<string, string | number>) => string;
+  rich: (key: string, param?: Record<string, string | number>) => ReactNode;
+  trans: <Returns extends ReactNode>(
+    translation: Record<"en" | "ko" | (string & {}), Returns>,
+  ) => Returns extends string ? string : Returns;
+};
+
+type RuntimePage = {
+  path: string;
+  l: RuntimeTranslate;
+  lang: string;
+};
+
+type RuntimeMsg = {
+  info: (key: string, option?: TransMessageOption) => void;
+  success: (key: string, option?: TransMessageOption) => void;
+  error: (key: string, option?: TransMessageOption) => void;
+  warning: (key: string, option?: TransMessageOption) => void;
+  loading: (key: string, option?: TransMessageOption) => void;
+};
+
+type RuntimeErr = {
+  new (key: string, data?: Record<string, unknown>, option?: Record<string, unknown>): Error;
+  BadRequest?: RuntimeErr;
+  Conflict?: RuntimeErr;
+  Forbidden?: RuntimeErr;
+  NotFound?: RuntimeErr;
+  Unauthorized?: RuntimeErr;
+  fromJSON?: (payload: Record<string, unknown>) => Error;
+  [key: string]: unknown;
+};
+
+type RuntimeWs = {
+  connected: boolean;
+  on: (event: string, handler: (...args: unknown[]) => void) => void;
+  off: (event: string, handler: (...args: unknown[]) => void) => void;
+};
+
+type RuntimeFetch = typeof globalThis.fetch & {
+  instance: unknown;
+  origin: string;
+  serializedSignal: Record<string, unknown>;
+  setJwt: (jwt: string | null) => void;
+  slice: Record<string, SliceMeta>;
+  ws: RuntimeWs;
+  [key: string]: unknown;
+};
+
+export interface ClientRuntime {
+  msg: RuntimeMsg;
+  Err: RuntimeErr;
+  usePage: () => RuntimePage;
+  fetch: RuntimeFetch;
+  sig: Record<PropertyKey, unknown>;
+}
+
+const CLIENT_RUNTIME_KEY = Symbol.for("akanjs.client.runtime");
+
+type RuntimeScope = "app" | "lib";
+
+type RuntimeState = {
+  runtime: ClientRuntime | null;
+  scope: RuntimeScope | null;
+};
+
+const globalWithRuntime = globalThis as typeof globalThis & { [CLIENT_RUNTIME_KEY]?: RuntimeState };
+const state = globalWithRuntime[CLIENT_RUNTIME_KEY] ?? { runtime: null, scope: null };
+globalWithRuntime[CLIENT_RUNTIME_KEY] = state;
+
+const missingRuntimeError = () =>
+  new Error("Akan client runtime is not registered. Import the generated app client first.");
+
+export const registerClientRuntime = <Runtime>(
+  runtime: Runtime,
+  { scope = "app" }: { scope?: RuntimeScope } = {},
+): Runtime => {
+  if (state.scope === "app" && scope === "lib") return runtime;
+  state.runtime = runtime as ClientRuntime;
+  state.scope = scope;
+  return runtime;
+};
+
+export const getClientRuntime = () => {
+  if (!state.runtime) throw missingRuntimeError();
+  return state.runtime;
+};
+
+export const isClientRuntimeRegistered = () => state.runtime !== null;
+
+export const msg = new Proxy({} as ClientRuntime["msg"], {
+  get(_target, prop, receiver) {
+    return Reflect.get(getClientRuntime().msg, prop, receiver);
+  },
+});
+
+const ErrTarget = function AkanClientRuntimeErr(...args: ConstructorParameters<RuntimeErr>) {
+  return Reflect.construct(getClientRuntime().Err, args);
+} as unknown as RuntimeErr;
+
+Object.defineProperty(ErrTarget, Symbol.hasInstance, {
+  value(instance: unknown) {
+    return instance instanceof getClientRuntime().Err;
+  },
+});
+
+export const Err = new Proxy(ErrTarget, {
+  get(_target, prop, receiver) {
+    return Reflect.get(getClientRuntime().Err, prop, receiver);
+  },
+  construct(_target, args) {
+    return Reflect.construct(getClientRuntime().Err, args);
+  },
+  apply(_target, _thisArg, args) {
+    return Reflect.construct(getClientRuntime().Err, args);
+  },
+});
+
+export const usePage: ClientRuntime["usePage"] = (...args) => getClientRuntime().usePage(...args);
+
+export const fetch = new Proxy((...args: Parameters<typeof globalThis.fetch>) => getClientRuntime().fetch(...args), {
+  get(_target, prop, receiver) {
+    return Reflect.get(getClientRuntime().fetch, prop, receiver);
+  },
+  set(_target, prop, value, receiver) {
+    return Reflect.set(getClientRuntime().fetch, prop, value, receiver);
+  },
+  apply(_target, thisArg, args) {
+    return Reflect.apply(getClientRuntime().fetch, thisArg, args);
+  },
+}) as RuntimeFetch;
+
+export const sig = new Proxy({} as ClientRuntime["sig"], {
+  get(_target, prop, receiver) {
+    return Reflect.get(getClientRuntime().sig, prop, receiver);
+  },
+});

package/client/cookie.ts

@@ -0,0 +1,121 @@
+import { getEnv } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type { Account } from "akanjs/fetch";
+import { requestStorage } from "akanjs/fetch";
+import Cookies from "js-cookie";
+import { jwtDecode } from "jwt-decode";
+import { storage } from "./storage";
+import { fetch } from "./useClient";
+
+function parseCookieHeader(cookieHeader: string): Map<string, { name: string; value: string }> {
+  const entries = cookieHeader
+    .split(";")
+    .map((c) => c.trim())
+    .filter(Boolean)
+    .map((c) => {
+      const eqIdx = c.indexOf("=");
+      if (eqIdx === -1) return null;
+      const name = c.slice(0, eqIdx).trim();
+      const raw = c.slice(eqIdx + 1).trim();
+      const value = typeof raw === "string" && raw.startsWith("j:") ? (JSON.parse(raw.slice(2)) as string) : raw;
+      return [name, { name, value }] as const;
+    })
+    .filter((e): e is NonNullable<typeof e> => e !== null);
+  return new Map(entries);
+}
+
+export const cookies = (): Map<string, { name: string; value: string }> => {
+  if (getEnv().side === "server") {
+    const req = requestStorage?.getStore();
+    if (!req) return new Map();
+    return parseCookieHeader(req.headers.get("cookie") ?? "");
+  }
+  const cookie = Cookies.get();
+  return new Map(
+    Object.entries(cookie).map(([key, value]) => [
+      key,
+      {
+        name: key,
+        value: typeof value === "string" && value.startsWith("j:") ? (JSON.parse(value.slice(2)) as string) : value,
+      },
+    ]),
+  );
+};
+
+export const setCookie = (
+  key: string,
+  value: string,
+  options: Cookies.CookieAttributes = { path: "/", sameSite: "none", secure: true },
+) => {
+  if (getEnv().side === "server") return;
+  else
+    void import("@capacitor/core").then(({ CapacitorCookies }) =>
+      CapacitorCookies.setCookie({ key, value, path: options.path }),
+    );
+};
+
+export const getCookie = (key: string): string | undefined => {
+  if (getEnv().side === "server") return cookies().get(key)?.value;
+  else
+    return document.cookie
+      .split(";")
+      .find((c) => c.trim().startsWith(`${key}=`))
+      ?.split("=")[1];
+};
+
+export const removeCookie = (key: string, options: { path: string } = { path: "/" }) => {
+  if (getEnv().side === "server") return cookies().delete(key);
+  else {
+    document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+  }
+};
+export const headers = (): Map<string, string> => {
+  if (getEnv().side !== "server") return new Map();
+  const req = requestStorage?.getStore();
+  if (!req) return new Map();
+  const map = new Map<string, string>();
+  req.headers.forEach((value, key) => {
+    map.set(key, value);
+  });
+  return map;
+};
+
+export const getHeader = (key: string): string | undefined => {
+  return headers().get(key);
+};
+/** Decodes the current JWT into account data when it belongs to this app/environment. */
+export const getAccount = <AddData = unknown>(): Account<AddData> => {
+  const jwt = getCookie("jwt") ?? getHeader("jwt");
+  const defaultAccount = { appName: getEnv().appName, environment: getEnv().environment } as Account<AddData>;
+  if (!jwt) return defaultAccount;
+  const account: Account<AddData> = jwtDecode<Account<AddData>>(jwt);
+  if (account.appName !== getEnv().appName || account.environment !== getEnv().environment) return defaultAccount;
+  return account;
+};
+export interface GetOption {
+  unauthorize: string;
+}
+interface SetAuthOption {
+  jwt: string;
+}
+/** Sets the active auth token on fetch, cookie storage, and client storage. */
+export const setAuth = ({ jwt }: SetAuthOption) => {
+  fetch.setJwt(jwt);
+  setCookie("jwt", jwt);
+  void storage.setItem("jwt", jwt);
+};
+
+interface InitAuthOption {
+  jwt?: string;
+}
+export const initAuth = ({ jwt }: InitAuthOption = {}) => {
+  const token = jwt ?? cookies().get("jwt")?.value;
+  if (token) setAuth({ jwt: token });
+  Logger.verbose(`JWT set from cookie: ${token}`);
+};
+
+export const resetAuth = () => {
+  fetch.setJwt(null);
+  removeCookie("jwt");
+  void storage.removeItem("jwt");
+};

package/client/createFont.ts

@@ -0,0 +1,8 @@
+
+
+export const createFont = (_data: unknown) => null;
+export default createFont;
+export const Nanum_Gothic_Coding = createFont;
+export const Noto_Sans_KR = createFont;
+export const Inter = createFont;
+export const Roboto = createFont;

package/client/csrTypes.ts

@@ -0,0 +1,259 @@
+"use client";
+import type { ReactDOMAttributes } from "@use-gesture/react/dist/declarations/src/types";
+import type { PromiseOrObject } from "akanjs/base";
+import { createContext, type ForwardRefExoticComponent, type ReactNode, type RefObject, useContext } from "react";
+import type { AnimatedComponent, AnimatedProps, Interpolation, SpringValue } from "react-spring";
+import type { RouterInstance } from "./router";
+import type { ReactFont } from "./types";
+
+export type TransitionType = "none" | "fade" | "bottomUp" | "stack" | "scaleOut";
+/** Per-page CSR configuration for transition, safe-area, gesture, and cache behavior. */
+export interface PageConfig {
+  transition?: TransitionType;
+  safeArea?: boolean | "top" | "bottom";
+  topInset?: boolean | number;
+  /**
+   * @default 48px
+   */
+  bottomInset?: boolean | number;
+  gesture?: boolean;
+  cache?: boolean;
+  rscCache?: "public" | false;
+  rscCacheTtl?: number;
+  topSafeAreaColor?: string;
+  bottomSafeAreaColor?: string;
+}
+
+export interface CsrState {
+  transition: TransitionType;
+  topSafeArea: number;
+  bottomSafeArea: number;
+  topInset: number;
+  bottomInset: number;
+  gesture: boolean;
+  cache: boolean;
+  topSafeAreaColor?: string;
+  bottomSafeAreaColor?: string;
+}
+export const DEFAULT_TOP_INSET = 48;
+export const DEFAULT_BOTTOM_INSET = 60;
+export interface PageProps {
+  params: { [key: string]: string };
+  searchParams: { [key: string]: string | string[] };
+}
+/** Props passed to Akan layout route modules. */
+export interface LayoutProps extends PageProps {
+  children: ReactNode;
+}
+export interface PageLoadingProps {
+  params: { [key: string]: string };
+}
+export interface LayoutLoadingProps extends PageLoadingProps {
+  children: ReactNode;
+}
+export type Head = ReactNode;
+export type GenerateHead = (props: PageProps) => PromiseOrObject<Head | null | undefined>;
+export type ResolveHead = (props: PageProps) => PromiseOrObject<Head | null | undefined>;
+export type HeadProps = PageProps;
+export type PageRender = (props: PageProps) => PromiseOrObject<ReactNode>;
+export type LayoutRender = (props: LayoutProps) => PromiseOrObject<ReactNode>;
+export type PageLoadingRender = (props: PageLoadingProps) => PromiseOrObject<ReactNode>;
+export type LayoutLoadingRender = (props: LayoutLoadingProps) => PromiseOrObject<ReactNode>;
+export interface RouteRender {
+  render: LayoutRender | PageRender;
+  Loading?: LayoutLoadingRender | PageLoadingRender;
+  resolveHead?: ResolveHead;
+  getPageConfig?: () => PromiseOrObject<PageConfig | undefined>;
+}
+export interface WebAppManifestIcon {
+  src: string;
+  sizes?: string;
+  type?: string;
+  purpose?: string;
+  [key: string]: unknown;
+}
+export interface WebAppManifest {
+  name?: string;
+  shortName?: string;
+  startUrl?: string;
+  scope?: string;
+  display?: "fullscreen" | "standalone" | "minimal-ui" | "browser" | (string & {});
+  displayOverride?: string[];
+  orientation?: string;
+  themeColor?: string;
+  backgroundColor?: string;
+  description?: string;
+  lang?: string;
+  dir?: "ltr" | "rtl" | "auto";
+  icons?: WebAppManifestIcon[];
+  categories?: string[];
+  screenshots?: WebAppManifestIcon[];
+  [key: string]: unknown;
+}
+export interface PageModule {
+  default?: PageRender;
+  pageConfig?: PageConfig;
+  head?: Head;
+  generateHead?: GenerateHead;
+  Loading?: PageLoadingRender;
+}
+export interface LayoutModule {
+  default?: LayoutRender;
+  head?: Head;
+  generateHead?: GenerateHead;
+  fonts?: ReactFont[];
+  manifest?: WebAppManifest;
+  theme?: string;
+  reconnect?: boolean;
+  layoutStyle?: "mobile" | "web";
+  gaTrackingId?: string;
+  Loading?: LayoutLoadingRender;
+}
+export type RouteModule = PageModule | LayoutModule;
+export interface Route {
+  csrConfig?: PageConfig;
+  path: string;
+  renderPage?: RouteRender;
+  renderLayout?: RouteRender;
+  pageIncludesOwnLayout?: boolean;
+  isSpecialRoute?: boolean;
+
+  loader?: () => any;
+  pageState?: PageState;
+
+  children: Map<string, Route>;
+}
+
+export type AnimatedDivProps =
+  AnimatedComponent<"div"> extends ForwardRefExoticComponent<AnimatedProps<infer P>> ? P : never;
+export type TransitionStyle = AnimatedDivProps["style"];
+
+export interface SafeAreaTransition {
+  containerStyle: TransitionStyle;
+}
+export interface ContainerTransition {
+  containerStyle: TransitionStyle;
+  contentStyle: TransitionStyle;
+  prevContentStyle: TransitionStyle;
+}
+export interface PageTransition {
+  containerStyle: TransitionStyle;
+  contentStyle: TransitionStyle;
+}
+export interface CsrTransitionStyles {
+  topSafeArea: SafeAreaTransition | null;
+  page: PageTransition | null;
+  prevPage: PageTransition | null;
+  topInset: ContainerTransition | null;
+  bottomInset: ContainerTransition | null;
+  topLeftAction: ContainerTransition | null;
+  bottomSafeArea: SafeAreaTransition | null;
+}
+
+export type PageState = CsrState & {
+  topInset: number;
+  bottomInset: number;
+};
+export const defaultPageState: PageState = {
+  transition: "none",
+  topSafeArea: 0,
+  bottomSafeArea: 0,
+  topInset: 0,
+  bottomInset: 0,
+  gesture: true,
+  cache: false,
+  topSafeAreaColor: "transparent",
+  bottomSafeAreaColor: "transparent",
+};
+
+export interface Location {
+  href: string;
+  pathname: string;
+  search: string;
+  params: { [key: string]: string };
+  searchParams: { [key: string]: string | string[] };
+  pathRoute: PathRoute;
+  hash: string;
+}
+export interface LocationState {
+  location: Location;
+  prevLocation: Location | null;
+}
+export interface History {
+  type: "initial" | "forward" | "back";
+  locations: Location[];
+  scrollMap: Map<string, number>;
+  idxMap: Map<string, number>;
+  cachedLocationMap: Map<string, Location>;
+  idx: number;
+}
+
+export interface RouterProps {
+  push: (path: string) => void;
+  replace: (path: string) => void;
+  refresh: () => void;
+  back: () => void | Promise<void>;
+}
+
+export interface RouteState {
+  clientWidth: number;
+  clientHeight: number;
+  location: Location;
+  prevLocation: Location | null;
+  history: RefObject<History>;
+  topSafeAreaRef: RefObject<HTMLDivElement | null>;
+  bottomSafeAreaRef: RefObject<HTMLDivElement | null>;
+  prevPageContentRef: RefObject<HTMLDivElement | null>;
+  pageContentRef: RefObject<HTMLDivElement | null>;
+  frameRootRef: RefObject<HTMLDivElement | null>;
+  onBack: RefObject<{ [K in TransitionType]?: () => Promise<void> }>;
+  router: RouterInstance;
+  pathRoutes: PathRoute[];
+}
+
+export type UseCsrTransition = CsrTransitionStyles & {
+  pageBind: (...args: any[]) => ReactDOMAttributes;
+  pageClassName: string;
+  transDirection: "vertical" | "horizontal" | "none";
+  transUnitRange: number[];
+  transUnit: SpringValue<number>;
+  transPercent: Interpolation<number>;
+  transProgress: Interpolation<number>;
+};
+
+export type CsrContextType = RouteState & UseCsrTransition;
+export const csrContext = createContext<CsrContextType>({} as unknown as CsrContextType);
+export const useCsr = () => {
+  const contextValues = useContext(csrContext);
+  return contextValues;
+};
+
+export interface PathContextType {
+  pageType: "current" | "prev" | "cached";
+  location: Location;
+  prefix?: string;
+  gestureEnabled: boolean;
+  setGestureEnabled: (enabled: boolean) => void;
+}
+export const pathContext = createContext<PathContextType>({} as unknown as PathContextType);
+export const usePathCtx = () => {
+  const contextValues = useContext(pathContext);
+  return contextValues;
+};
+
+export interface PathRoute {
+  path: string;
+  pathSegments: string[];
+  renderPage: RouteRender;
+  pageState: PageState;
+  renderRootLayouts: RouteRender[];
+  renderLayouts: RouteRender[];
+  resolveHead?: ResolveHead;
+  isSpecialRoute?: boolean;
+}
+
+export interface RouteGuide {
+  pathSegment: string;
+  pathRoute?: PathRoute;
+  children: { [key: string]: RouteGuide };
+}

package/client/decorators.ts

@@ -0,0 +1,25 @@
+import { Logger } from "akanjs/common";
+import { msg } from "./useClient";
+
+interface ToastProps {
+  root?: string;
+  duration?: number;
+}
+/** Decorates async actions with loading/success/error toast messages from `msg`. */
+export const Toast = ({ root, duration = 3 }: ToastProps = {}) => {
+  return (target: any, key: string, descriptor: PropertyDescriptor) => {
+    const originMethod = descriptor.value as (...args: any[]) => Promise<void>;
+    descriptor.value = async function (...args: any[]) {
+      try {
+        msg.loading(`${root ? `${root}.` : ""}${key}-loading` as any, { key, duration });
+        const result = (await originMethod.apply(this, args)) as unknown;
+        msg.success(`${root ? `${root}.` : ""}${key}-success` as any, { key, duration });
+        return result;
+      } catch (err) {
+        const errKey = typeof err === "string" ? err : (err as Error).message;
+        msg.error(errKey as any, { key, duration });
+        Logger.error(`${key} action error return: ${err}`);
+      }
+    };
+  };
+};