akanjs 2.2.4-rc.4 → 2.2.4

package/webkit/webkit.test.tsx

@@ -0,0 +1,531 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import type { Location, PathRoute, RouteGuide } from "akanjs/client";
+import { createRobotPage } from "./createRobotPage";
+import { createSitemapPage } from "./createSitemapPage";
+
+type RenderHookResult<T> = {
+  get current(): T;
+  rerender: (props?: unknown) => void;
+  unmount: () => void;
+};
+
+const originalWindow = globalThis.window;
+const originalDocument = globalThis.document;
+const originalSetTimeout = globalThis.setTimeout;
+const originalClearTimeout = globalThis.clearTimeout;
+const originalSetInterval = globalThis.setInterval;
+const originalClearInterval = globalThis.clearInterval;
+const effectCleanups: Array<() => void> = [];
+let hookIndex = 0;
+const hookStates: unknown[] = [];
+let hookMemoStates: Array<{ deps: unknown[]; value: unknown }> = [];
+let hookEffectStates: Array<{ deps: unknown[] | undefined; cleanup?: () => undefined }> = [];
+
+const sameDeps = (a: unknown[] | undefined, b: unknown[] | undefined) =>
+  !!a && !!b && a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
+
+mock.module("react", () => ({
+  Fragment: ({ children }: { children: unknown }) => children,
+  useCallback: <T,>(fn: T, deps?: unknown[]) => {
+    const index = hookIndex++;
+    const memo = hookMemoStates[index];
+    if (memo && sameDeps(memo.deps, deps)) return memo.value as T;
+    hookMemoStates[index] = { deps: deps ?? [], value: fn };
+    return fn;
+  },
+  useMemo: <T,>(factory: () => T, deps?: unknown[]) => {
+    const index = hookIndex++;
+    const memo = hookMemoStates[index];
+    if (memo && sameDeps(memo.deps, deps)) return memo.value as T;
+    const value = factory();
+    hookMemoStates[index] = { deps: deps ?? [], value };
+    return value;
+  },
+  useRef: <T,>(initial: T) => {
+    const index = hookIndex++;
+    if (!hookStates[index]) hookStates[index] = { current: initial };
+    return hookStates[index] as { current: T };
+  },
+  useState: <T,>(initial: T) => {
+    const index = hookIndex++;
+    if (hookStates[index] === undefined)
+      hookStates[index] = typeof initial === "function" ? (initial as () => T)() : initial;
+    const setState = (next: T | ((prev: T) => T)) => {
+      const state = hookStates[index] as T;
+      const nextState = typeof next === "function" ? (next as (prev: T) => T)(state) : next;
+      if (typeof state === "object" && state && typeof nextState === "object" && nextState) {
+        Object.assign(state, nextState);
+      } else {
+        hookStates[index] = nextState;
+      }
+    };
+    return [hookStates[index] as T, setState] as const;
+  },
+  useEffect: (fn: () => (() => undefined) | undefined, deps?: unknown[]) => {
+    const index = hookIndex++;
+    const prev = hookEffectStates[index];
+    if (prev && sameDeps(prev.deps, deps)) return;
+    prev?.cleanup?.();
+    const cleanup = fn();
+    hookEffectStates[index] = { deps, cleanup: cleanup || undefined };
+    if (cleanup) effectCleanups.push(cleanup);
+  },
+  forwardRef: (fn: unknown) => fn,
+  lazy: (loader: unknown) => ({ loader }),
+  memo: <T,>(component: T) => component,
+  act: async (fn: () => void | Promise<void>) => await fn(),
+}));
+mock.module("react/jsx-dev-runtime", () => ({
+  Fragment: ({ children }: { children: unknown }) => children,
+  jsxDEV: (_type: unknown, props: { children?: unknown }) => props.children ?? null,
+}));
+mock.module("react/jsx-runtime", () => ({
+  Fragment: ({ children }: { children: unknown }) => children,
+  jsx: (_type: unknown, props: { children?: unknown }) => props.children ?? null,
+  jsxs: (_type: unknown, props: { children?: unknown }) => props.children ?? null,
+}));
+
+const installWindow = ({
+  href = "https://example.test/en/home?tab=a#hash",
+  assign,
+  replace,
+  getElementById,
+}: {
+  href?: string;
+  assign?: (href: string) => void;
+  replace?: (href: string) => void;
+  getElementById?: (id: string) => { offsetTop: number } | null;
+} = {}) => {
+  const url = new URL(href);
+  const createElement = (tagName = "div") =>
+    ({
+      nodeType: 1,
+      nodeName: tagName.toUpperCase(),
+      tagName: tagName.toUpperCase(),
+      namespaceURI: "http://www.w3.org/1999/xhtml",
+      ownerDocument: null,
+      style: {},
+      childNodes: [],
+      addEventListener: () => undefined,
+      removeEventListener: () => undefined,
+      appendChild: () => undefined,
+      removeChild: () => undefined,
+      insertBefore: () => undefined,
+      setAttribute: () => undefined,
+      removeAttribute: () => undefined,
+    }) as unknown as HTMLDivElement;
+  const body = { style: {} } as HTMLBodyElement;
+  const document = {
+    nodeType: 9,
+    body,
+    documentElement: createElement("html"),
+    defaultView: null,
+    createElement,
+    getElementById: getElementById ?? (() => null),
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+  } as unknown as Document;
+  (document.documentElement as unknown as { ownerDocument: Document }).ownerDocument = document;
+  const window = {
+    location: {
+      href,
+      origin: url.origin,
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      assign: assign ?? (() => undefined),
+      replace: replace ?? (() => undefined),
+    },
+    document,
+    HTMLIFrameElement: class HTMLIFrameElement {},
+    Node: class Node {},
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+  } as unknown as Window & typeof globalThis;
+  (document as unknown as { defaultView: Window }).defaultView = window;
+
+  Object.defineProperty(globalThis, "window", { value: window, configurable: true });
+  Object.defineProperty(globalThis, "document", { value: document, configurable: true });
+  Object.defineProperty(globalThis, "location", { value: window.location, configurable: true });
+  return { window, document };
+};
+
+const renderHook = <T,>(hook: (props?: unknown) => T, initialProps?: unknown): RenderHookResult<T> => {
+  let current: T;
+  const render = (props?: unknown) => {
+    hookIndex = 0;
+    current = hook(props);
+  };
+  render(initialProps);
+  return {
+    get current() {
+      return current;
+    },
+    rerender: render,
+    unmount: () => {
+      effectCleanups.splice(0).forEach((cleanup) => {
+        cleanup();
+      });
+      hookIndex = 0;
+      hookStates.length = 0;
+      hookMemoStates = [];
+      hookEffectStates = [];
+    },
+  };
+};
+
+const tick = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+class TimerController {
+  private nextId = 1;
+  private timeouts = new Map<number, { handler: () => void; delay: number }>();
+  private intervals = new Map<number, { handler: () => void; delay: number }>();
+
+  install() {
+    globalThis.setTimeout = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+      const id = this.nextId++;
+      this.timeouts.set(id, {
+        handler: () => {
+          if (typeof handler === "function") handler(...args);
+        },
+        delay: delay ?? 0,
+      });
+      return id as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout;
+    globalThis.clearTimeout = ((id?: ReturnType<typeof setTimeout>) => {
+      this.timeouts.delete(Number(id));
+    }) as typeof clearTimeout;
+    globalThis.setInterval = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+      const id = this.nextId++;
+      this.intervals.set(id, {
+        handler: () => {
+          if (typeof handler === "function") handler(...args);
+        },
+        delay: delay ?? 0,
+      });
+      return id as unknown as ReturnType<typeof setInterval>;
+    }) as typeof setInterval;
+    globalThis.clearInterval = ((id?: ReturnType<typeof setInterval>) => {
+      this.intervals.delete(Number(id));
+    }) as typeof clearInterval;
+  }
+
+  flushTimeouts() {
+    const pending = [...this.timeouts.entries()];
+    this.timeouts.clear();
+    pending.forEach(([, timer]) => {
+      timer.handler();
+    });
+  }
+
+  tickIntervals() {
+    [...this.intervals.values()].forEach((timer) => {
+      timer.handler();
+    });
+  }
+
+  get timeoutCount() {
+    return this.timeouts.size;
+  }
+
+  get intervalCount() {
+    return this.intervals.size;
+  }
+}
+
+const makePathRoute = (path: string, pathSegments: string[], cache = false): PathRoute =>
+  ({
+    path,
+    pathSegments,
+    renderPage: { render: () => null },
+    renderRootLayouts: [],
+    renderLayouts: [],
+    pageState: {
+      transition: "none",
+      topSafeArea: 0,
+      bottomSafeArea: 0,
+      topInset: 0,
+      bottomInset: 0,
+      gesture: true,
+      cache,
+    },
+  }) as unknown as PathRoute;
+
+const homeRoute = makePathRoute("/en/home", ["/", "/en", "/home"], true);
+const detailRoute = makePathRoute("/en/items/:id", ["/", "/en", "/items", "/:id"], true);
+const rootRouteGuide: RouteGuide = {
+  pathSegment: "/",
+  children: {
+    "/en": {
+      pathSegment: "/en",
+      children: {
+        "/home": { pathSegment: "/home", children: {}, pathRoute: homeRoute },
+        "/items": {
+          pathSegment: "/items",
+          children: {
+            "/:id": { pathSegment: "/:id", children: {}, pathRoute: detailRoute },
+          },
+        },
+      },
+    },
+  },
+};
+
+afterEach(() => {
+  Object.defineProperty(globalThis, "window", { value: originalWindow, configurable: true });
+  Object.defineProperty(globalThis, "document", { value: originalDocument, configurable: true });
+  Object.defineProperty(globalThis, "location", { value: originalWindow?.location, configurable: true });
+  globalThis.setTimeout = originalSetTimeout;
+  globalThis.clearTimeout = originalClearTimeout;
+  globalThis.setInterval = originalSetInterval;
+  globalThis.clearInterval = originalClearInterval;
+  effectCleanups.splice(0);
+  hookIndex = 0;
+  hookStates.length = 0;
+  hookMemoStates = [];
+  hookEffectStates = [];
+});
+
+describe("page helpers", () => {
+  test("creates robots config with defaults and overrides", () => {
+    expect(createRobotPage("https://example.test")).toEqual({
+      rules: { userAgent: "*", allow: "/", disallow: "/admin/" },
+      sitemap: "https://example.test/sitemap.xml",
+    });
+    expect(
+      createRobotPage("https://example.test", {
+        rules: { userAgent: "Googlebot", allow: "/public", disallow: "/private" },
+        sitemap: "https://ignored.test/custom.xml",
+      }),
+    ).toEqual({
+      rules: { userAgent: "Googlebot", allow: "/public", disallow: "/private" },
+      sitemap: "https://example.test/sitemap.xml",
+    });
+  });
+
+  test("creates sitemap pages with shared lastModified", () => {
+    const sitemap = createSitemapPage("https://example.test", ["/", "/about"]);
+
+    expect(sitemap.map((entry) => entry.url)).toEqual(["https://example.test/", "https://example.test/about"]);
+    expect(sitemap[0]?.lastModified).toBeInstanceOf(Date);
+    expect(sitemap[0]?.lastModified).toBe(sitemap[1]?.lastModified);
+  });
+});
+
+describe("routing and history hooks", () => {
+  test("useLocation parses static, dynamic, query array, hash, and absolute hrefs", async () => {
+    const { useLocation } = await import("./useLocation");
+    installWindow({ href: "https://example.test/en/home" });
+    const hook = renderHook(() => useLocation({ rootRouteGuide }));
+
+    const home = hook.current.getLocation("https://example.test/en/home?tab=a&tab=b#section");
+    const detail = hook.current.getLocation("/en/items/123?mode=edit");
+
+    expect(home).toMatchObject({
+      pathname: "/en/home",
+      search: "tab=a&tab=b",
+      searchParams: { tab: ["a", "b"] },
+      hash: "section",
+      pathRoute: homeRoute,
+    });
+    expect(detail).toMatchObject({
+      pathname: "/en/items/123",
+      params: { id: "123" },
+      searchParams: { mode: "edit" },
+      pathRoute: detailRoute,
+    });
+    hook.unmount();
+  });
+
+  test("useLocation redirects missing route to 404", async () => {
+    const { useLocation } = await import("./useLocation");
+    const assigned: string[] = [];
+    installWindow({ assign: (href) => assigned.push(href) });
+    const hook = renderHook(() => useLocation({ rootRouteGuide }));
+
+    expect(() => hook.current.getLocation("/en/missing")).toThrow("Not found: /en/missing");
+    expect(assigned).toEqual([]);
+    hook.unmount();
+  });
+
+  test("useHistory tracks forward/back state, caches route locations, and reads hash scroll", async () => {
+    const { useHistory } = await import("./useHistory");
+    installWindow({
+      href: "https://example.test/en/home",
+      getElementById: (id) => (id === "target" ? { offsetTop: 77 } : null),
+    });
+    const firstLocation = {
+      href: "/en/home",
+      pathname: "/en/home",
+      hash: "",
+      pathRoute: homeRoute,
+    } as Location;
+    const secondLocation = {
+      href: "/en/items/1",
+      pathname: "/en/items/1",
+      hash: "",
+      pathRoute: detailRoute,
+    } as Location;
+    const hashLocation = {
+      href: "/en/items/1#target",
+      pathname: "/en/items/1",
+      hash: "target",
+      pathRoute: detailRoute,
+    } as Location;
+    const hook = renderHook(() => useHistory([firstLocation]));
+
+    expect(hook.current.getCurrentLocation()).toBe(firstLocation);
+    hook.current.setHistoryForward({ type: "push", location: secondLocation, scrollTop: 30 });
+    expect(hook.current.history.current.type).toBe("forward");
+    expect(hook.current.history.current.idx).toBe(1);
+    expect(hook.current.getPrevLocation()).toBe(firstLocation);
+    expect(hook.current.history.current.cachedLocationMap.get(detailRoute.path)).toBe(secondLocation);
+    expect(hook.current.getScrollTop(firstLocation)).toBe(30);
+
+    const replacement = { ...secondLocation, href: "/en/items/2" } as Location;
+    hook.current.setHistoryForward({ type: "replace", location: replacement, scrollToTop: true });
+    expect(hook.current.history.current.locations.at(-1)).toBe(replacement);
+    expect(hook.current.history.current.idx).toBe(1);
+
+    hook.current.setHistoryBack({ type: "back", location: replacement, scrollTop: 55 });
+    expect(hook.current.history.current.type).toBe("back");
+    expect(hook.current.history.current.idx).toBe(0);
+    expect(hook.current.getNextLocation()).toBe(replacement);
+    expect(hook.current.getScrollTop(hashLocation)).toBe(77);
+    hook.unmount();
+  });
+});
+
+describe("promise and timer hooks", () => {
+  test("useFetch handles immediate values and resolved promises", async () => {
+    const { useFetch } = await import("./useFetch");
+    installWindow();
+    const immediate = renderHook(() => useFetch("ready"));
+    expect(immediate.current).toEqual({ fulfilled: true, value: "ready" });
+    immediate.unmount();
+
+    const promise = Promise.resolve("done");
+    const hook = renderHook(() => useFetch(promise));
+    expect(hook.current).toEqual({ fulfilled: false, value: null });
+    await tick();
+    expect(hook.current).toEqual({ fulfilled: true, value: "done" });
+    hook.unmount();
+  });
+
+  test("useFetch cancels updates on unmount and formats errors", async () => {
+    const { useFetch } = await import("./useFetch");
+    installWindow();
+    let resolvePromise: (value: string) => void = () => undefined;
+    const promise = new Promise<string>((resolve) => {
+      resolvePromise = resolve;
+    });
+    const cancelled = renderHook(() => useFetch(promise));
+    cancelled.unmount();
+    resolvePromise("late");
+    await tick();
+    expect(cancelled.current).toEqual({ fulfilled: false, value: null });
+
+    const errors: string[] = [];
+    const rejection = Promise.reject(new Error("boom"));
+    rejection.catch(() => undefined);
+    expect(() => renderHook(() => useFetch(rejection, { onError: (error) => errors.push(error) }))).not.toThrow();
+    await tick();
+    expect(errors).toEqual(["Error: boom"]);
+  });
+
+  test("useFetchFn memoizes factory by dependencies", async () => {
+    const { useFetchFn } = await import("./useFetch");
+    installWindow();
+    let calls = 0;
+    const hook = renderHook(
+      (dep) =>
+        useFetchFn(() => {
+          calls += 1;
+          return `value:${dep}`;
+        }, [dep]),
+      "a",
+    );
+
+    expect(hook.current).toEqual({ fulfilled: true, value: "value:a" });
+    hook.rerender("a");
+    expect(calls).toBe(1);
+    hook.rerender("b");
+    expect(hook.current).toEqual({ fulfilled: true, value: "value:b" });
+    expect(calls).toBe(2);
+    hook.unmount();
+  });
+
+  test("debounce, throttle, and interval hooks use timers correctly", async () => {
+    const { useDebounce } = await import("./useDebounce");
+    const { useInterval } = await import("./useInterval");
+    const { useThrottle } = await import("./useThrottle");
+    installWindow();
+    const timers = new TimerController();
+    timers.install();
+    const debouncedValues: string[] = [];
+    const throttledValues: string[] = [];
+    const intervalValues: string[] = [];
+
+    const debounceHook = renderHook(() => useDebounce((value: string) => debouncedValues.push(value), [], 100));
+    debounceHook.current("a");
+    debounceHook.current("b");
+    expect(timers.timeoutCount).toBe(1);
+    timers.flushTimeouts();
+    expect(debouncedValues).toEqual(["b"]);
+    debounceHook.unmount();
+
+    const throttleHook = renderHook(() => useThrottle((value: string) => throttledValues.push(value), 100, []));
+    throttleHook.current("a");
+    throttleHook.current("b");
+    expect(throttledValues).toEqual(["a"]);
+    timers.flushTimeouts();
+    throttleHook.current("c");
+    expect(throttledValues).toEqual(["a", "c"]);
+    throttleHook.unmount();
+
+    let intervalLabel = "first";
+    const intervalHook = renderHook(() => useInterval(() => intervalValues.push(intervalLabel), 100));
+    timers.tickIntervals();
+    intervalLabel = "second";
+    intervalHook.rerender();
+    timers.tickIntervals();
+    expect(intervalValues).toEqual(["first", "second"]);
+    intervalHook.unmount();
+    expect(timers.intervalCount).toBe(0);
+  });
+});
+
+describe("lazy loading", () => {
+  test("returns server fallback stub for ssr false without invoking loader", async () => {
+    const { lazy } = await import("./lazy");
+    installWindow();
+    Object.defineProperty(globalThis, "window", { value: undefined, configurable: true });
+    let loaded = false;
+    const LazyComponent = lazy(
+      async () => {
+        loaded = true;
+        return { default: () => "Loaded" };
+      },
+      { ssr: false, loading: () => "Loading" },
+    ) as (props: Record<string, unknown>) => unknown;
+
+    expect(loaded).toBe(false);
+    expect(LazyComponent({})).toBeDefined();
+  });
+
+  test("returns wrappers for default and client ssr false paths", async () => {
+    const { lazy } = await import("./lazy");
+    installWindow();
+    const DefaultLazy = lazy(async () => ({ default: () => "Loaded" })) as { displayName?: string };
+    const ClientGate = lazy(async () => ({ default: () => "Loaded" }), {
+      ssr: false,
+      loading: () => "Loading",
+    }) as { displayName?: string };
+
+    expect(DefaultLazy.displayName).toBe("LazyWrapper");
+    expect(ClientGate.displayName).toBe("LazySsrFalseStub");
+  });
+});

package/types/base/base.d.ts

@@ -1,53 +0,0 @@
-import type { Cls } from ".";
-import { Float, Int } from "./primitiveRegistry.d.ts";
-export type EnumInstance<RefName extends string = string, T = string | number> = Cls<{
-    refName: RefName;
-    value: T;
-}, {
-    refName: RefName;
-    type: StringConstructor | typeof Int | typeof Float;
-    values: readonly T[];
-    valueMap: Map<T, number>;
-    has: (value: T) => boolean;
-    indexOf: (value: T) => number;
-    find: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T;
-    findIndex: (callback: (value: T, index: number, array: readonly T[]) => boolean) => number;
-    filter: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T[];
-    map: <R>(callback: (value: T, index: number, array: readonly T[]) => R) => R[];
-    forEach: (callback: (value: T, index: number, array: readonly T[]) => void) => void;
-}>;
-/** Returns true when a class was created by `enumOf`. */
-export declare const isEnum: (enumRef: Cls) => boolean;
-/** Creates a typed scalar enum class from a readonly list of string or number values. */
-export declare const enumOf: <RefName extends string, T = string | number>(refName: RefName, values: readonly T[]) => EnumInstance<RefName, T>;
-/** Id-keyed list helper used for light model collections and immutable-style list updates. */
-export declare class DataList<Light extends {
-    id: string;
-}> {
-    #private;
-    length: number;
-    values: Light[];
-    constructor(data?: Light[] | DataList<Light>);
-    indexOf(id: string): number;
-    set(value: Light): this;
-    delete(id: string): this;
-    get(id: string): Light | undefined;
-    at(idx: number): Light | undefined;
-    pickAt(idx: number): Light;
-    pick(id: string): Light;
-    has(id: string): boolean;
-    find(fn: (value: Light, idx: number) => boolean): Light | undefined;
-    findIndex(fn: (value: Light, idx: number) => boolean): number;
-    some(fn: (value: Light, idx: number) => boolean): boolean;
-    every(fn: (value: Light, idx: number) => boolean): boolean;
-    forEach(fn: (value: Light, idx: number) => void): void;
-    map<T>(fn: (value: Light, idx: number) => T): T[];
-    flatMap<T>(fn: (value: Light, idx: number, array: Light[]) => T | readonly T[]): T[];
-    sort(fn: (a: Light, b: Light) => number): DataList<Light>;
-    filter(fn: (value: Light, idx: number) => boolean): DataList<Light>;
-    reduce<T>(fn: (acc: T, value: Light, idx: number) => T, initialValue: T): T;
-    slice(start: number, end?: number): DataList<Light>;
-    save(): DataList<Light>;
-    [Symbol.iterator](): ArrayIterator<Light>;
-}
-export declare const logo = "\n     _    _                  _     \n    / \\  | | ____ _ _ __    (_)___ \n   / _ \\ | |/ / _' | '_ \\   | / __|\n  / ___ \\|   < (_| | | | |_ | \\__ \\\n /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/\n                          |__/      \n? See more details on docs  https://www.akanjs.com/docs\n\u2605 Star Akanjs on GitHub     https://github.com/akan-team/akanjs\n\n";

package/types/base/baseEnv.d.ts

@@ -1,68 +0,0 @@
-export type Environment = "testing" | "debug" | "develop" | "main" | "local";
-export type DatabaseMode = "single" | "multiple" | "cluster";
-export interface BaseEnv {
-    repoName: string;
-    serveDomain: string;
-    appName: string;
-    environment: Environment;
-    operationMode: "local" | "edge" | "cloud" | "module";
-    tunnelUsername: string;
-    tunnelPassword: string;
-    databaseMode?: DatabaseMode;
-}
-export type BackendEnv = BaseEnv & {
-    hostname?: string | null;
-    port?: number;
-    database?: {
-        mode?: DatabaseMode;
-        driver?: "sqlite" | "libsql" | "postgres";
-        sqlite?: {
-            filePath?: string;
-            journalMode?: string;
-            busyTimeoutMs?: number;
-            synchronous?: string;
-            foreignKeys?: boolean;
-            cacheSize?: number;
-            tempStore?: string;
-        };
-        libsql?: {
-            url?: string;
-            authToken?: string;
-        };
-        postgres?: {
-            url?: string;
-            host?: string;
-            port?: number;
-            database?: string;
-            user?: string;
-            password?: string;
-        };
-    };
-    solid?: {
-        filePath?: string;
-        journalMode?: string;
-        busyTimeoutMs?: number;
-        synchronous?: string;
-        cleanupIntervalMs?: number;
-        queuePollIntervalMs?: number;
-        queueLeaseMs?: number;
-    };
-    onCleanup?: () => Promise<void>;
-};
-export type ClientEnv = BaseEnv & {
-    side: "server" | "client";
-    renderMode: "ssr" | "csr";
-    websocket: boolean;
-    clientHost: string;
-    clientPort: number;
-    clientHttpProtocol: "http:" | "https:";
-    clientHttpUri: string;
-    serverHost: string;
-    serverPort: number;
-    serverHttpProtocol: "http:" | "https:";
-    serverHttpUri: string;
-    serverWsProtocol: "ws:" | "wss:";
-    serverWsUri: string;
-};
-/** Reads and caches Akan runtime environment values from process/browser environment settings. */
-export declare const getEnv: () => ClientEnv;

package/types/base/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./base.d.ts";
-export * from "./baseEnv.d.ts";
-export * from "./primitiveRegistry.d.ts";
-export * from "./symbols.d.ts";
-export * from "./types.d.ts";
-export * from "./utils.d.ts";