akanjs 2.2.4 → 2.2.5

package/ui/Constant/schemaDoc.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { enumOf, FIELD_META, Int } from "akanjs/base";
-import { type ConstantCls, type ConstantField, ConstantRegistry, type FieldInfoObject, field } from "akanjs/constant";
-
-import { databaseModelVariants, getConstantSchemaDoc } from "./schemaDoc";
-
-const ConstantDocRole = enumOf("constantDocRole", ["admin", "user"] as const);
-ConstantRegistry.enum.set("constantDocRole", ConstantDocRole);
-
-const makeRef = (fields: FieldInfoObject | Record<string, ConstantField>): ConstantCls => {
-  class TestConstant {}
-  Object.assign(TestConstant, {
-    [FIELD_META]: Object.fromEntries(
-      Object.entries(fields).map(([key, fieldInfo]) => [key, "toField" in fieldInfo ? fieldInfo.toField() : fieldInfo]),
-    ),
-    children: new Set(),
-    relations: new Set(),
-    enums: new Set(),
-    text: { search: new Set(), filter: new Set(), children: { search: new Set(), filter: new Set() } },
-  });
-  return TestConstant as ConstantCls;
-};
-
-const ConstantDocAddress = makeRef({
-  city: field(String),
-  zip: field(Int, { default: 10000, min: 10000 }),
-});
-ConstantRegistry.buildScalar("constantDocAddress", ConstantDocAddress, { ConstantDocAddress });
-
-const ConstantDocUserInput = makeRef({
-  name: field(String, { minlength: 2 }),
-  role: field(String, { enum: ConstantDocRole } as never),
-  metadata: field(Map, { of: String }),
-  password: field.secret(String),
-});
-const ConstantDocUserObject = makeRef({
-  ...ConstantDocUserInput[FIELD_META],
-  organizationId: field(String, { ref: "organization", refType: "relation" }).toField(),
-});
-const LightConstantDocUser = makeRef({
-  name: field(String, { minlength: 2 }),
-  role: field(String, { enum: ConstantDocRole } as never),
-});
-const ConstantDocUser = makeRef({
-  ...ConstantDocUserObject[FIELD_META],
-  displayName: field(String, { text: "search" }).toField(),
-});
-const ConstantDocUserInsight = makeRef({
-  ...ConstantDocUser[FIELD_META],
-  total: field(Int, { default: 0, accumulate: {} }).toField(),
-});
-
-ConstantRegistry.buildModel(
-  "constantDocUser",
-  ConstantDocUserInput,
-  ConstantDocUserObject,
-  ConstantDocUser,
-  LightConstantDocUser,
-  ConstantDocUserInsight,
-  {
-    ConstantDocUserInput,
-    ConstantDocUserObject,
-    ConstantDocUser,
-    LightConstantDocUser,
-    ConstantDocUserInsight,
-    ConstantDocRole,
-  },
-);
-
-describe("constant schema docs", () => {
-  test("builds selected database, scalar, and enum schemas", () => {
-    const doc = getConstantSchemaDoc({
-      models: ["constantDocUser"],
-      scalars: ["constantDocAddress"],
-      enums: ["constantDocRole"],
-    });
-
-    expect(doc.databases.map((database) => database.refName)).toEqual(["constantDocUser"]);
-    expect(doc.scalars.map((scalar) => scalar.refName)).toEqual(["constantDocAddress"]);
-    expect(doc.enums.map((enumSchema) => enumSchema.refName)).toEqual(["constantDocRole"]);
-    expect(Object.keys(doc.databases[0].variants)).toEqual([...databaseModelVariants]);
-  });
-
-  test("normalizes field metadata for tables", () => {
-    const doc = getConstantSchemaDoc({ models: ["constantDocUser"], scalars: ["constantDocAddress"] });
-    const fullFields = doc.databases[0].variants.full.fields;
-    const role = fullFields.find((field) => field.key === "role");
-    const password = fullFields.find((field) => field.key === "password");
-    const metadata = fullFields.find((field) => field.key === "metadata");
-    const displayName = fullFields.find((field) => field.key === "displayName");
-
-    expect(role?.enumValues).toEqual(["admin", "user"]);
-    expect(password?.fieldType).toBe("hidden");
-    expect(password?.select).toBe(false);
-    expect(metadata?.typeLabel).toBe("Map<String, String>");
-    expect(displayName?.constraints).toContain("text:search");
-  });
-
-  test("collects enum usages and scalar fields", () => {
-    const doc = getConstantSchemaDoc({
-      models: ["constantDocUser"],
-      scalars: ["constantDocAddress"],
-      enums: ["constantDocRole"],
-    });
-    const roleEnum = doc.enums[0];
-    const zipField = doc.scalars[0].fields.find((field) => field.key === "zip");
-
-    expect(roleEnum.usedBy.some((usage) => usage.refName === "constantDocUser" && usage.fieldKey === "role")).toBe(
-      true,
-    );
-    expect(zipField?.constraints).toContain("min 10000");
-  });
-});

package/ui/InfiniteScroll.test.tsx

@@ -1,155 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-import type { InfiniteScrollProps } from "./InfiniteScroll";
-
-type Effect = () => (() => void) | undefined;
-
-const effectQueue: Effect[] = [];
-const effectCleanups: Array<() => void> = [];
-let hookIndex = 0;
-const hookStates: unknown[] = [];
-let latestObserver: FakeIntersectionObserver | undefined;
-const originalIntersectionObserver = globalThis.IntersectionObserver;
-
-const fakeElement = { nodeType: 1, nodeName: "DIV" } as Element;
-
-const resetHooks = () => {
-  hookIndex = 0;
-  hookStates.length = 0;
-  effectQueue.length = 0;
-};
-
-const flushEffects = () => {
-  for (const effect of effectQueue.splice(0)) {
-    const cleanup = effect();
-    if (cleanup) effectCleanups.push(cleanup);
-  }
-};
-
-const tick = async () => {
-  await Promise.resolve();
-  await Promise.resolve();
-};
-
-class FakeIntersectionObserver {
-  observed: Element[] = [];
-
-  constructor(private readonly callback: IntersectionObserverCallback) {
-    latestObserver = this;
-  }
-
-  observe = (element: Element) => {
-    this.observed.push(element);
-  };
-
-  disconnect = () => {
-    this.observed = [];
-  };
-
-  emit = (isIntersecting = true) => {
-    this.callback(
-      [{ isIntersecting, target: this.observed[0] ?? fakeElement } as IntersectionObserverEntry],
-      this as unknown as IntersectionObserver,
-    );
-  };
-}
-
-const assignRef = (ref: unknown) => {
-  if (typeof ref === "function") {
-    ref(fakeElement);
-    return;
-  }
-  if (ref && typeof ref === "object" && "current" in ref) {
-    (ref as { current: Element | null }).current = fakeElement;
-  }
-};
-
-const createElement = (type: unknown, props: Record<string, unknown> = {}) => {
-  assignRef(props.ref);
-  return { type, props };
-};
-
-beforeAll(() => {
-  mock.module("react", () => ({
-    Fragment: ({ children }: { children: unknown }) => children,
-    useEffect: (effect: Effect) => {
-      effectQueue.push(effect);
-    },
-    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 prev = hookStates[index] as T;
-        hookStates[index] = typeof next === "function" ? (next as (value: T) => T)(prev) : next;
-      };
-      return [hookStates[index] as T, setState] as const;
-    },
-  }));
-  mock.module("react/jsx-dev-runtime", () => ({
-    Fragment: ({ children }: { children: unknown }) => children,
-    jsxDEV: createElement,
-  }));
-  mock.module("react/jsx-runtime", () => ({
-    Fragment: ({ children }: { children: unknown }) => children,
-    jsx: createElement,
-    jsxs: createElement,
-  }));
-  mock.module("react-icons/bi", () => ({
-    BiLoaderAlt: (props: Record<string, unknown>) => createElement("BiLoaderAlt", props),
-  }));
-});
-
-afterEach(() => {
-  for (const cleanup of effectCleanups.splice(0)) cleanup();
-  latestObserver = undefined;
-  resetHooks();
-  Object.defineProperty(globalThis, "IntersectionObserver", {
-    value: originalIntersectionObserver,
-    configurable: true,
-  });
-});
-
-const renderInfiniteScroll = async (props: InfiniteScrollProps) => {
-  Object.defineProperty(globalThis, "IntersectionObserver", {
-    value: FakeIntersectionObserver,
-    configurable: true,
-  });
-  const { InfiniteScroll } = await import("./InfiniteScroll");
-  hookIndex = 0;
-  const result = InfiniteScroll(props);
-  flushEffects();
-  return result;
-};
-
-describe("InfiniteScroll", () => {
-  test("loads the next page once when the sentinel intersects", async () => {
-    const addPageCalls: number[] = [];
-    const pageSelections: number[] = [];
-
-    await renderInfiniteScroll({
-      total: 30,
-      currentPage: 1,
-      itemsPerPage: 10,
-      onAddPage: async (page) => {
-        addPageCalls.push(page);
-      },
-      onPageSelect: (page) => {
-        pageSelections.push(page);
-      },
-      children: "items",
-    });
-
-    expect(latestObserver?.observed).toHaveLength(1);
-
-    latestObserver?.emit();
-    await tick();
-
-    expect(addPageCalls).toEqual([2]);
-    expect(pageSelections).toEqual([2]);
-  });
-});

package/ui/System/Common.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createManifestDataUrl, toManifestJson } from "./Common";
-
-describe("manifest helpers", () => {
-  test("converts author-facing camelCase keys to manifest snake_case", () => {
-    expect(
-      toManifestJson({
-        name: "Akan App",
-        shortName: "Akan",
-        startUrl: "/",
-        themeColor: "#ffffff",
-        backgroundColor: "#000000",
-        displayOverride: ["standalone"],
-        icons: [{ src: "/icon.png", sizes: "192x192", type: "image/png" }],
-      }),
-    ).toEqual({
-      name: "Akan App",
-      short_name: "Akan",
-      start_url: "/",
-      theme_color: "#ffffff",
-      background_color: "#000000",
-      display_override: ["standalone"],
-      icons: [{ src: "/icon.png", sizes: "192x192", type: "image/png" }],
-    });
-  });
-
-  test("encodes manifest JSON as a base64 data URL", () => {
-    const href = createManifestDataUrl({ name: "Akan App", shortName: "Akan" });
-    expect(href.startsWith("data:application/manifest+json;base64,")).toBe(true);
-
-    const encoded = href.slice("data:application/manifest+json;base64,".length);
-    expect(JSON.parse(Buffer.from(encoded, "base64").toString("utf8"))).toEqual({
-      name: "Akan App",
-      short_name: "Akan",
-    });
-  });
-});

package/webkit/bootCsr.test.tsx

@@ -1,153 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-
-const originalWindow = globalThis.window;
-const originalDocument = globalThis.document;
-const originalEnv = { ...process.env };
-
-const deviceState = {
-  lang: "en",
-  platform: "web",
-};
-const storageState = {
-  jwt: null as string | null,
-};
-
-beforeAll(() => {
-  mock.module("akanjs/client", () => ({
-    DEFAULT_BOTTOM_INSET: 34,
-    DEFAULT_TOP_INSET: 44,
-    csrContext: { Provider: ({ children }: { children: unknown }) => children },
-    defaultPageState: {
-      transition: "none",
-      topSafeArea: 0,
-      bottomSafeArea: 0,
-      topInset: 0,
-      bottomInset: 0,
-      gesture: true,
-      cache: false,
-    },
-    router: {
-      state: {},
-      set: () => undefined,
-      emit: () => undefined,
-      on: () => undefined,
-      off: () => undefined,
-    },
-    Device: {
-      load: async () => ({
-        lang: deviceState.lang,
-        info: { platform: deviceState.platform },
-        topSafeArea: 11,
-        bottomSafeArea: 22,
-      }),
-      getDevice: () => ({
-        info: { platform: deviceState.platform },
-      }),
-    },
-    initAuth: () => undefined,
-    storage: {
-      getItem: async (key: string) => (key === "jwt" ? storageState.jwt : null),
-    },
-  }));
-  mock.module("react-dom/client", () => ({
-    createRoot: () => ({ render: () => undefined }),
-  }));
-  mock.module("@capacitor/app", () => ({
-    App: {
-      addListener: () => ({ remove: () => undefined }),
-    },
-  }));
-  mock.module("@react-spring/web", () => ({
-    useSpringValue: () => ({ to: () => 0, start: async () => undefined }),
-  }));
-  mock.module("@use-gesture/react", () => ({
-    useDrag: () => () => ({}),
-  }));
-});
-
-const installWindow = ({
-  href,
-  replace,
-  root = true,
-}: {
-  href: string;
-  replace?: (href: string) => void;
-  root?: boolean;
-}) => {
-  const url = new URL(href);
-  const body = { style: {} } as HTMLBodyElement;
-  const document = {
-    body,
-    getElementById: (id: string) => (root && id === "root" ? ({ nodeType: 1 } as HTMLElement) : null),
-  } as unknown as Document;
-  const window = {
-    document,
-    location: {
-      href,
-      origin: url.origin,
-      pathname: url.pathname,
-      search: url.search,
-      hash: url.hash,
-      replace: replace ?? (() => undefined),
-    },
-  } as unknown as Window & typeof globalThis;
-  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 });
-};
-
-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 });
-  process.env = { ...originalEnv };
-  deviceState.lang = "en";
-  deviceState.platform = "web";
-  storageState.jwt = null;
-});
-
-describe("bootCsr", () => {
-  test("exits early on 404 before route loading", async () => {
-    installWindow({ href: "https://example.test/404" });
-    let loaded = false;
-    const { bootCsr } = await import("./bootCsr");
-
-    await bootCsr({
-      "./_index.tsx": async () => {
-        loaded = true;
-        return { default: () => null };
-      },
-    });
-
-    expect(loaded).toBe(false);
-    expect(document.body.style.overflow).toBe("hidden");
-  });
-
-  test("redirects to language-prefixed path when missing language prefix", async () => {
-    const replacements: string[] = [];
-    installWindow({ href: "https://example.test/home?a=1#top", replace: (href) => replacements.push(href) });
-    const { bootCsr } = await import("./bootCsr");
-
-    await bootCsr({
-      "./_index.tsx": async () => ({ default: () => null }),
-    });
-
-    expect(replacements).toEqual(["/en/home?a=1#top"]);
-  });
-
-  test("initializes mobile target from local Capacitor CSR URL", async () => {
-    const replacements: string[] = [];
-    installWindow({
-      href: "https://example.test/en/?csr=true&akanMobileTarget=default&akanMobileBasePath=minimal",
-      replace: (href) => replacements.push(href),
-    });
-    const { bootCsr } = await import("./bootCsr");
-
-    await bootCsr({
-      "./_index.tsx": async () => ({ default: () => null }),
-    });
-
-    expect(window.__AKAN_MOBILE_TARGET__).toEqual({ name: "default", basePath: "minimal" });
-    expect(replacements).toEqual([]);
-  });
-});