akanjs 0.0.1 → 2.0.0-beta.1

package/store/storeInstance.ts

@@ -0,0 +1,382 @@
+import { ACTION_META, STATE_DERIVED_META, STATE_INIT_META } from "akanjs/base";
+import { capitalize, Logger } from "akanjs/common";
+import { produce } from "immer";
+import type { RefObject } from "react";
+import { useEffect, useRef, useSyncExternalStore } from "./hooks";
+import type { RootStoreCls } from "./rootStore";
+import type { SliceStateKey } from "./state";
+import { evaluateInitializers, type SearchParamsState, type StateDerivedMeta } from "./stateBuilder";
+
+type StoreStateRecord = Record<string, unknown>;
+type StoreAction = (...args: unknown[]) => unknown;
+
+type SliceActionKey =
+  | "initModel"
+  | "refreshModel"
+  | "selectModel"
+  | "setPageOfModel"
+  | "addPageOfModel"
+  | "setLimitOfModel"
+  | "setQueryArgsOfModel"
+  | "setSortOfModel";
+
+export type ReactAPI = {
+  useSyncExternalStore: <T>(
+    subscribe: (onStoreChange: () => void) => () => void,
+    getSnapshot: () => T,
+    getServerSnapshot?: () => T,
+  ) => T;
+  useRef: <T>(initialValue: T) => { current: T };
+  useEffect: (effect: () => (() => void) | void, deps?: any[]) => void;
+};
+
+export class StoreInstance {
+  #state: StoreStateRecord = {};
+  #listeners = new Set<() => void>();
+  #derivedMeta: StateDerivedMeta = { persistSession: {}, search: {}, computed: {}, derivedKeys: new Set() };
+
+  get = (): StoreStateRecord => this.#state;
+
+  set = (stateOrUpdater: StoreStateRecord | ((state: StoreStateRecord) => void)) => {
+    const prev = this.#state;
+    if (typeof stateOrUpdater === "function") {
+      this.#state = produce(this.#state, stateOrUpdater);
+    } else {
+      this.#state = { ...this.#state, ...stateOrUpdater };
+    }
+    this.#assertNoDerivedMutation(stateOrUpdater);
+    this.#state = this.#materializeDerived(this.#state, prev);
+    this.#syncPersistSession(prev, this.#state);
+    this.#notify();
+  };
+
+  #pick = (...fields: string[]) => {
+    const ret = {} as StoreStateRecord;
+    for (const field of fields) {
+      const val = this.#state[field];
+      if (val === null || val === undefined || val === "") throw new Error(`Field ${field} is not ready`);
+      ret[field] = val;
+    }
+    return ret;
+  };
+
+  #ctx: Record<string, unknown> = { set: this.set, get: this.get, pick: this.#pick };
+
+  subscribe = (listener: () => void) => {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  };
+
+  sub: {
+    (listener: (state: StoreStateRecord, prev: StoreStateRecord) => void): () => void;
+    <U>(
+      selector: (state: StoreStateRecord) => U,
+      listener: (state: U, prev: U) => void,
+      options?: { equalityFn?: (a: U, b: U) => boolean; fireImmediately?: boolean },
+    ): () => void;
+  } = ((...args: any[]) => {
+    if (args.length === 1 && typeof args[0] === "function") {
+      const listener = args[0] as (state: StoreStateRecord, prev: StoreStateRecord) => void;
+      let prev = this.#state;
+      const wrapped = () => {
+        const next = this.#state;
+        listener(next, prev);
+        prev = next;
+      };
+      this.#listeners.add(wrapped);
+      return () => {
+        this.#listeners.delete(wrapped);
+      };
+    }
+    const [selector, listener, options] = args as [
+      (state: StoreStateRecord) => unknown,
+      (state: unknown, prev: unknown) => void,
+      { equalityFn?: (a: any, b: any) => boolean; fireImmediately?: boolean } | undefined,
+    ];
+    const equalityFn = options?.equalityFn ?? Object.is;
+    let prev = selector(this.#state);
+    const wrapped = () => {
+      const next = selector(this.#state);
+      if (!equalityFn(next, prev)) {
+        const p = prev;
+        prev = next;
+        listener(next, p);
+      }
+    };
+    this.#listeners.add(wrapped);
+    if (options?.fireImmediately) listener(prev, prev);
+    return () => {
+      this.#listeners.delete(wrapped);
+    };
+  }) as any;
+
+  sel = <U>(selector: (state: StoreStateRecord) => U, equals?: (a: U, b: U) => boolean) => {
+    const eq = equals ?? Object.is;
+    return useSyncExternalStore(
+      (onStoreChange: () => void) => {
+        let prev = selector(this.#state);
+        const listener = () => {
+          const next = selector(this.#state);
+          if (!eq(next, prev)) {
+            prev = next;
+            onStoreChange();
+          }
+        };
+        return this.subscribe(listener);
+      },
+      () => selector(this.#state),
+      () => selector(this.#state),
+    );
+  };
+
+  ref = <U>(selector: (state: StoreStateRecord) => U): RefObject<U> => {
+    const ref = useRef(selector(this.get()));
+    useEffect(
+      () =>
+        this.sub(selector, (val: U) => {
+          ref.current = val;
+        }),
+      [],
+    );
+    return ref as RefObject<U>;
+  };
+
+  use: { [key: string]: () => unknown } = {};
+  do: { [key: string]: StoreAction } = {};
+  slice: { [key: string]: unknown } = {};
+
+  constructor(store?: RootStoreCls) {
+    if (store) this.addStore(store);
+  }
+
+  addStore(store: RootStoreCls) {
+    this.#mergeDerivedMeta(store[STATE_DERIVED_META]);
+    const newState = evaluateInitializers(store[STATE_INIT_META] ?? {});
+    const hydratedState = this.#hydratePersistSession(newState);
+    const derivedState = this.#materializeDerived({ ...this.#state, ...hydratedState }, this.#state);
+    let hasNewStateKey = false;
+    const nextState = { ...this.#state };
+    for (const [key, value] of Object.entries(derivedState)) {
+      if (key in nextState) continue;
+      nextState[key] = value;
+      hasNewStateKey = true;
+    }
+    if (hasNewStateKey) this.#state = nextState;
+    this.#mergeActions(store[ACTION_META]);
+    this.#extendAccessors(derivedState, store[ACTION_META]);
+    this.#buildSlices(store);
+    if (hasNewStateKey) this.#notify();
+    return this;
+  }
+
+  #mergeActions(actions: { [key: string]: StoreAction }) {
+    for (const [k, method] of Object.entries(actions)) {
+      this.#ctx[k] = (...args: unknown[]) => method.call(this.#ctx, ...args);
+    }
+  }
+
+  #extendAccessors(state: StoreStateRecord, actions: { [key: string]: StoreAction }) {
+    for (const k of Object.keys(state)) {
+      if (typeof state[k] !== "function") {
+        this.use[k] = () => this.sel((s) => s[k]);
+        if (this.#derivedMeta.derivedKeys.has(k)) continue;
+        const setKey = `set${capitalize(k)}`;
+        this.do[setKey] = (value: unknown) => this.set({ [k]: value });
+      }
+    }
+    for (const k of Object.keys(actions)) {
+      this.do[k] = async (...args: unknown[]) => {
+        Logger.verbose(`${k} action loading...`);
+        const start = Date.now();
+        await (this.#ctx[k] as StoreAction)(...args);
+        Logger.verbose(`=> ${k} action dispatched (${Date.now() - start}ms)`);
+      };
+    }
+  }
+
+  #buildSlices(store: RootStoreCls) {
+    Object.entries(store.slice).forEach(([refName, sliceObj]) => {
+      Object.entries(sliceObj).forEach(([suffix, serializedSlice]) => {
+        const sliceName = `${refName}${capitalize(suffix)}`;
+        this.#buildSlice(refName, sliceName, serializedSlice);
+      });
+    });
+  }
+
+  #buildSlice(refName: string, sliceName: string, serializedSlice: { args?: any[] }) {
+    const [fieldName, className] = [refName, capitalize(refName)];
+    const names: { [key in SliceStateKey | SliceActionKey | "model" | "Model"]: string } = {
+      model: fieldName,
+      Model: className,
+      defaultModel: `default${className}`,
+      modelInsight: `${fieldName}Insight`,
+      modelList: `${fieldName}List`,
+      modelListLoading: `${fieldName}ListLoading`,
+      modelInitList: `${fieldName}InitList`,
+      modelInitAt: `${fieldName}InitAt`,
+      pageOfModel: `pageOf${className}`,
+      limitOfModel: `limitOf${className}`,
+      queryArgsOfModel: `queryArgsOf${className}`,
+      sortOfModel: `sortOf${className}`,
+      modelSelection: `${fieldName}Selection`,
+      initModel: `init${className}`,
+      refreshModel: `refresh${className}`,
+      selectModel: `select${className}`,
+      setPageOfModel: `setPageOf${className}`,
+      addPageOfModel: `addPageOf${className}`,
+      setLimitOfModel: `setLimitOf${className}`,
+      setQueryArgsOfModel: `setQueryArgsOf${className}`,
+      setSortOfModel: `setSortOf${className}`,
+      lastPageOfModel: `lastPageOf${className}`,
+    };
+    const SliceName = capitalize(sliceName);
+    const namesOfSliceState: { [key in SliceStateKey]: string } = {
+      defaultModel: SliceName.replace(names.Model, names.defaultModel),
+      modelInitList: SliceName.replace(names.Model, names.modelInitList),
+      modelInsight: sliceName.replace(names.model, names.modelInsight),
+      modelList: sliceName.replace(names.model, names.modelList),
+      modelListLoading: sliceName.replace(names.model, names.modelListLoading),
+      modelInitAt: SliceName.replace(names.Model, names.modelInitAt),
+      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),
+      modelSelection: SliceName.replace(names.Model, names.modelSelection),
+    };
+    const namesOfSliceAction: { [key in SliceActionKey]: string } = {
+      initModel: SliceName.replace(names.Model, names.initModel),
+      refreshModel: SliceName.replace(names.Model, names.refreshModel),
+      selectModel: SliceName.replace(names.Model, names.selectModel),
+      setPageOfModel: SliceName.replace(names.Model, names.setPageOfModel),
+      addPageOfModel: SliceName.replace(names.Model, names.addPageOfModel),
+      setLimitOfModel: SliceName.replace(names.Model, names.setLimitOfModel),
+      setQueryArgsOfModel: SliceName.replace(names.Model, names.setQueryArgsOfModel),
+      setSortOfModel: SliceName.replace(names.Model, names.setSortOfModel),
+    };
+
+    const targetSlice: {
+      do: { [key: string]: (...args: any[]) => void };
+      use: { [key: string]: () => any };
+      get: () => any;
+      sliceName: string;
+      refName: string;
+      argLength: number;
+    } = {
+      do: {},
+      use: {},
+      get: () => ({}),
+      sliceName,
+      refName,
+      argLength: serializedSlice.args?.length ?? 0,
+    };
+
+    for (const key of Object.keys(namesOfSliceAction) as SliceActionKey[]) {
+      const rootActionKey = namesOfSliceAction[key];
+      if (this.do[rootActionKey]) targetSlice.do[names[key]] = this.do[rootActionKey];
+    }
+
+    for (const key of Object.keys(namesOfSliceState) as SliceStateKey[]) {
+      const rootStateKey = namesOfSliceState[key];
+      if (this.use[rootStateKey]) targetSlice.use[names[key]] = this.use[rootStateKey];
+      const setRootKey = `set${capitalize(rootStateKey)}`;
+      const setLocalKey = `set${capitalize(names[key])}`;
+      if (this.do[setRootKey]) targetSlice.do[setLocalKey] = this.do[setRootKey];
+    }
+
+    targetSlice.get = () => {
+      const state = this.get();
+      return Object.fromEntries(
+        (Object.entries(namesOfSliceState) as [SliceStateKey, string][]).map(([key, value]) => [
+          names[key],
+          state[value],
+        ]),
+      );
+    };
+
+    (this.slice as any)[sliceName] = targetSlice;
+  }
+
+  #notify() {
+    for (const listener of this.#listeners) listener();
+  }
+
+  #mergeDerivedMeta(meta?: StateDerivedMeta) {
+    if (!meta) return;
+    Object.assign(this.#derivedMeta.persistSession, meta.persistSession);
+    Object.assign(this.#derivedMeta.search, meta.search);
+    Object.assign(this.#derivedMeta.computed, meta.computed);
+    for (const key of meta.derivedKeys) this.#derivedMeta.derivedKeys.add(key);
+  }
+
+  #hydratePersistSession(state: StoreStateRecord) {
+    const next = { ...state };
+    for (const [key, meta] of Object.entries(this.#derivedMeta.persistSession)) {
+      if (!(key in next)) continue;
+      const storage = this.#getStorage(meta.kind);
+      if (!storage) continue;
+      try {
+        const raw = storage.getItem(meta.storageKey);
+        if (raw === null) continue;
+        next[key] = meta.parse(JSON.parse(raw));
+      } catch (error) {
+        Logger.warn(`Failed to hydrate ${meta.kind} state ${key}: ${String(error)}`);
+        next[key] = meta.getDefault();
+      }
+    }
+    return next;
+  }
+
+  #syncPersistSession(prev: StoreStateRecord, next: StoreStateRecord) {
+    for (const [key, meta] of Object.entries(this.#derivedMeta.persistSession)) {
+      if (Object.is(prev[key], next[key])) continue;
+      const storage = this.#getStorage(meta.kind);
+      if (!storage) continue;
+      try {
+        storage.setItem(meta.storageKey, JSON.stringify(meta.serialize(next[key])));
+      } catch (error) {
+        Logger.warn(`Failed to persist ${meta.kind} state ${key}: ${String(error)}`);
+      }
+    }
+  }
+
+  #materializeDerived(next: StoreStateRecord, prev: StoreStateRecord) {
+    const materialized = { ...next };
+    const changedKeys = new Set(Object.keys(materialized).filter((key) => !Object.is(materialized[key], prev[key])));
+    const searchParams = (materialized.searchParams ?? {}) as SearchParamsState;
+    for (const [key, meta] of Object.entries(this.#derivedMeta.search)) {
+      const value = typeof window === "undefined" ? meta.getDefault() : meta.parseSearch(searchParams);
+      if (!Object.is(materialized[key], value)) {
+        materialized[key] = value;
+        changedKeys.add(key);
+      }
+    }
+    for (const [key, meta] of Object.entries(this.#derivedMeta.computed)) {
+      if (key in materialized && !meta.deps.some((dep) => changedKeys.has(dep))) continue;
+      const value = meta.selector(...meta.deps.map((dep) => materialized[dep]));
+      if (!(key in materialized) || !meta.equals(materialized[key], value)) {
+        materialized[key] = value;
+        changedKeys.add(key);
+      }
+    }
+    return materialized;
+  }
+
+  #assertNoDerivedMutation(stateOrUpdater: unknown) {
+    if (!stateOrUpdater || typeof stateOrUpdater === "function") return;
+    for (const key of Object.keys(stateOrUpdater)) {
+      if (this.#derivedMeta.derivedKeys.has(key)) throw new Error(`Cannot set derived state directly: ${key}`);
+    }
+  }
+
+  #getStorage(kind: "persist" | "session") {
+    if (typeof window === "undefined") return null;
+    try {
+      return kind === "persist" ? window.localStorage : window.sessionStorage;
+    } catch {
+      return null;
+    }
+  }
+}

package/store/storeRegistry.ts

@@ -0,0 +1,84 @@
+import {
+  ACTION_META,
+  type MergeAllKeyOfObjects,
+  type MergeAllKeyOfTypes,
+  type MergeAllTypes,
+  STATE_DERIVED_META,
+  STATE_INIT_META,
+  STATE_META,
+} from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import type { RootStoreCls } from "./rootStore";
+import type { StoreCls } from "./store";
+import { StoreInstance } from "./storeInstance";
+
+export type { ReactAPI } from "./storeInstance";
+
+import type { SerializedSlice } from "akanjs/signal";
+import { mergeDerivedMeta } from "./stateBuilder";
+import type { SetGet } from "./types";
+import type { WithSelectors } from "./withSelector";
+
+const STORE_REGISTRY_KEY = Symbol.for("akanjs.store.registry");
+
+interface StoreRegistryState {
+  instance: StoreInstance;
+  store: Map<string, StoreCls>;
+}
+
+function getStoreRegistryState(): StoreRegistryState {
+  const globalStore = globalThis as typeof globalThis & { [STORE_REGISTRY_KEY]?: StoreRegistryState };
+  globalStore[STORE_REGISTRY_KEY] ??= {
+    instance: new StoreInstance(),
+    store: new Map<string, StoreCls>(),
+  };
+  return globalStore[STORE_REGISTRY_KEY];
+}
+
+export class StoreRegistry {
+  static #state = getStoreRegistryState();
+  static register<StrCls extends StoreCls>(store: StrCls): StrCls {
+    const parentStore = Object.getPrototypeOf(store) as StoreCls | null;
+    const actions = { ...(parentStore?.[ACTION_META] ?? {}) };
+    Object.entries(Object.getOwnPropertyDescriptors(store.prototype)).forEach(([key, descriptor]) => {
+      if (key === "constructor") return;
+      if (!descriptor.value || typeof descriptor.value !== "function") return;
+      actions[key] = descriptor.value;
+    });
+    store[ACTION_META] = actions;
+    StoreRegistry.#state.store.set(store.refName, store);
+    return store;
+  }
+  static get(refName: string) {
+    return StoreRegistry.#state.store.get(refName);
+  }
+  static merge<RefName extends string, StoreClses extends (StoreCls | RootStoreCls)[]>(
+    refName: RefName,
+    ...stores: StoreClses
+  ): RootStoreCls<
+    RefName,
+    MergeAllKeyOfObjects<StoreClses, typeof STATE_META>,
+    MergeAllTypes<StoreClses, keyof SetGet | "slice">,
+    MergeAllKeyOfTypes<StoreClses, "slice">,
+    MergeAllKeyOfObjects<StoreClses, "_slice">
+  > {
+    class RootStore {
+      static type = "root";
+      static refName = refName;
+      static [STATE_META] = Object.assign({}, ...stores.map((store) => store[STATE_META]));
+      static [STATE_INIT_META] = Object.assign({}, ...stores.map((store) => store[STATE_INIT_META]));
+      static [STATE_DERIVED_META] = mergeDerivedMeta(...stores.map((store) => store[STATE_DERIVED_META]));
+      static [ACTION_META] = Object.assign({}, ...stores.map((store) => store[ACTION_META]));
+      static slice: { [key: string]: { [key: string]: SerializedSlice } } = {};
+    }
+    stores.forEach((store) => {
+      if (store.type === "root") Object.assign(RootStore.slice, store.slice);
+      else RootStore.slice[store.refName] = store.slice;
+    });
+    applyMixins(RootStore, stores);
+    return RootStore as any;
+  }
+  static build<RtStoreCls extends RootStoreCls>(store: RtStoreCls): WithSelectors<RtStoreCls> {
+    return StoreRegistry.#state.instance.addStore(store) as unknown as WithSelectors<RtStoreCls>;
+  }
+}

package/store/types.ts

@@ -0,0 +1,69 @@
+import type { DefaultOf } from "akanjs/constant";
+import type { ExtractSort, FilterInstance } from "akanjs/document";
+import type { SliceInfo } from "akanjs/signal";
+import type { SliceAction } from "./action";
+import type { SliceState } from "./state";
+
+export interface Submit {
+  disabled: boolean;
+  loading: boolean;
+  times: number;
+}
+
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type PickFunc<
+  State,
+  F extends keyof State = IsAny<State> extends true ? any : keyof State extends never ? any : keyof State,
+> = (...fields: F[]) => {
+  [K in (typeof fields)[number]]: Exclude<State[K], null | undefined | "loading">;
+}; 
+export interface SetGet<State = any> {
+  set: (setState: Partial<State> | ((state: State) => void)) => void;
+  get: () => State;
+  pick: PickFunc<State>;
+}
+export interface SetGetWritable<WritableState = any, State = WritableState> {
+  set: (setState: Partial<WritableState> | ((state: WritableState) => void)) => void;
+  get: () => State;
+  pick: PickFunc<State>;
+}
+export interface SetPick<State = any> {
+  set: (setState: Partial<State> | ((state: State) => void)) => void;
+  pick: PickFunc<State>;
+}
+export type Get<State, Actions> = {
+  get: () => State & Actions;
+};
+
+export type SliceStateAction<
+  RefName extends string = string,
+  Suffix extends string = "",
+  SliceName extends string = `${RefName}${Capitalize<Suffix>}`,
+  State = any,
+  Action = any,
+> = Action & {
+  refName: RefName;
+  suffix: Suffix;
+  sliceName: SliceName;
+  get: () => State;
+  set: (setState: Partial<State> | ((state: State) => void)) => void;
+};
+
+export type InternalSlice<
+  SlceInfo extends SliceInfo = any,
+  RefName extends string = any,
+  Suffix extends string = any,
+  Input = any,
+  Full = any,
+  Light extends { id: string } = any,
+  Insight = any,
+  Filter extends FilterInstance = any,
+  _CapitalizedRefName extends string = Capitalize<RefName>,
+  _Default = DefaultOf<Full>,
+  _Sort = ExtractSort<Filter>,
+  _Args extends any[] = SlceInfo extends SliceInfo<any, any, any, any, any, any, any, any, infer Args, any, any>
+    ? Args
+    : never,
+  _SliceState = SliceState<RefName, "", Full, Light, _Args, Insight, Filter, _CapitalizedRefName, "", _Default, _Sort>,
+  _SliceAction = SliceAction<RefName, "", Input, Light, _Args, Filter, _CapitalizedRefName, "", _Sort>,
+> = SliceStateAction<RefName, Suffix, `${RefName}${Capitalize<Suffix>}`, _SliceState, _SliceAction>;

package/store/withSelector.ts

@@ -0,0 +1,62 @@
+import type { Prettify } from "akanjs/base";
+import type { FieldState } from "akanjs/constant";
+import type { RefObject } from "react";
+import type { RootStoreCls } from "./rootStore";
+import type { SliceStateAction } from "./types";
+
+type SetKey<Key extends string> = `set${Capitalize<Key>}`;
+
+export type WithSelectors<RtStoreCls extends RootStoreCls> =
+  RtStoreCls extends RootStoreCls<any, infer WritableState, infer Action, infer InternalSliceObj, any, any, infer State>
+    ? WithSelectorsOf<State, WritableState, Action, InternalSliceObj>
+    : never;
+
+type WithSelectorsOf<State, WritableState, Action, InternalSliceObj> = {
+  sub: {
+    (listener: (state: State, prev: State) => void): () => void;
+    <U>(
+      selector: (state: State) => U,
+      listener: (state: U, prev: U) => void,
+      options?: {
+        equalityFn?: (a: U, b: U) => boolean;
+        fireImmediately?: boolean;
+      },
+    ): () => void;
+  };
+  ref: <U>(selector: (state: State) => U) => RefObject<U>;
+  sel: <U>(selector: (state: State) => U, equals?: (a: U, b: U) => boolean) => U;
+  use: {
+    [K in keyof State]: () => State[K];
+  };
+  do: Action & {
+    [K in keyof WritableState as K extends string ? SetKey<K> : never]: (value: FieldState<WritableState[K]>) => void;
+  };
+  get: () => State;
+  set: (state: Partial<WritableState> | ((state: WritableState) => any)) => void;
+  slice: {
+    [K in keyof InternalSliceObj]: InternalSliceObj[K] extends SliceStateAction<
+      infer RefName,
+      infer Suffix,
+      infer SliceName,
+      infer State,
+      infer Action
+    >
+      ? SliceSelectors<RefName, State, Action>
+      : never;
+  };
+};
+
+export interface SliceSelectors<RefName extends string, State, Action> {
+  refName: RefName;
+  use: {
+    [K in keyof State]: () => State[K];
+  };
+  do: Prettify<
+    {
+      [K in keyof Action]: Action[K];
+    } & {
+      [K in keyof State as K extends string ? SetKey<K> : never]: (value: FieldState<State[K]>) => void;
+    }
+  >;
+  get: () => State;
+}

package/test/index.ts

@@ -0,0 +1,16 @@
+export { sample } from "./sample";
+export { sampleOf } from "./sampleOf";
+export {
+  configureSignalTest,
+  getOrSetupSignalTestContext,
+  getOrSetupSignalTestFetch,
+  getSignalTestContext,
+  getSignalTestFetch,
+  hasSignalTestContext,
+  type SignalTestContext,
+  type SignalTestOptions,
+  type SignalTestTarget,
+  setupSignalTestTarget,
+  terminateSignalTestContext,
+} from "./signalTestRuntime";
+export { TestServer, type TestServerOptions } from "./testServer";

package/test/playwright.config.base.ts

@@ -0,0 +1,48 @@
+
+
+import { defineConfig, devices, type PlaywrightTestConfig } from "@playwright/test";
+
+const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
+const projectName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export const withBase = (filename: string, config: PlaywrightTestConfig = {}) =>
+  defineConfig({
+
+    use: {
+      baseURL,
+      
+      trace: "on-first-retry",
+    },
+    
+    webServer: {
+      command: `akan serve ${projectName}`,
+      url: "http://127.0.0.1:4200",
+      reuseExistingServer: !process.env.CI,
+    },
+    projects: [
+      {
+        name: "chromium",
+        use: { ...devices["Desktop Chrome"] },
+      },
+
+      {
+        name: "firefox",
+        use: { ...devices["Desktop Firefox"] },
+      },
+
+      {
+        name: "webkit",
+        use: { ...devices["Desktop Safari"] },
+      },
+
+    ],
+    ...config,
+  });