@panyam/tsappkit 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@panyam/tsappkit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "TypeScript application toolkit with component lifecycle management, event system, UI utilities, and documentation site components",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -22,6 +22,7 @@
   "files": [
     "dist",
     "src",
+    "!src/**/*.test.ts",
     "styles"
   ],
   "scripts": {

package/src/page/IslandPage.test.ts

@@ -1,83 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { LCMComponent } from "../LCMComponent";
-import { IslandPage } from "./IslandPage";
-import type { PageSpec } from "./spec";
-
-type Ctx = { built: number };
-type Ext = { things: string[] };
-
-const mounted: { name: string; el: HTMLElement; config: unknown; ctx: Ctx }[] = [];
-const contexts: (PageSpec & Ext)[] = [];
-
-const island = (name: string) => (el: HTMLElement, spec: { config: unknown }, ctx: Ctx) => {
-  mounted.push({ name, el, config: spec.config, ctx });
-  return { name } as unknown as LCMComponent;
-};
-
-class TestPage extends IslandPage<Ctx, Ext> {
-  protected registry() {
-    return { player: island("player"), chat: island("chat") };
-  }
-  protected readExtension(raw: Record<string, unknown>): Ext {
-    return { things: Array.isArray(raw.things) ? raw.things.map(String) : [] };
-  }
-  protected makeContext(spec: PageSpec & Ext): Ctx {
-    contexts.push(spec);
-    return { built: contexts.length };
-  }
-  mount() {
-    return this.initializeSpecificComponents();
-  }
-}
-
-function page(spec: string | null, slots: string[]) {
-  document.body.innerHTML =
-    (spec === null ? "" : `<script type="application/json" id="page-spec">${spec}</script>`) +
-    slots.map((s) => `<section data-slot="${s}"></section>`).join("");
-  return new TestPage("test");
-}
-
-describe("IslandPage", () => {
-  let warn: ReturnType<typeof vi.spyOn>;
-  beforeEach(() => {
-    // jsdom has no matchMedia, and BasePage's ThemeManager asks it for the colour scheme.
-    window.matchMedia ??= ((query: string) => ({ matches: false, media: query, addEventListener() {}, removeEventListener() {} })) as unknown as typeof window.matchMedia;
-    mounted.length = 0;
-    contexts.length = 0;
-    warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-  });
-  afterEach(() => warn.mockRestore());
-
-  it("mounts each island from the spec into its data-slot, sharing one context", () => {
-    const spec = JSON.stringify({
-      layout: "drawer",
-      islands: [
-        { name: "player", slot: "main", config: { a: 1 } },
-        { name: "nobody", slot: "side" },
-        { name: "chat", slot: "drawer" },
-      ],
-      things: ["x"],
-    });
-    const out = page(spec, ["main", "side", "drawer"]).mount();
-    expect(out).toHaveLength(2);
-    expect(mounted.map((m) => [m.name, m.el.dataset.slot, m.config])).toEqual([
-      ["player", "main", { a: 1 }],
-      ["chat", "drawer", {}],
-    ]);
-    expect(mounted[0].ctx).toBe(mounted[1].ctx);
-    expect(contexts).toHaveLength(1);
-    expect(contexts[0].things).toEqual(["x"]);
-    expect(warn.mock.calls.flat().join("\n")).toMatch(/nobody/);
-  });
-
-  it("mounts nothing, and builds no context, without a readable spec", () => {
-    for (const spec of [null, "not json"]) {
-      const p = page(spec, ["main"]);
-      warn.mockClear();
-      expect(p.mount()).toEqual([]);
-      expect(warn).toHaveBeenCalledOnce();
-      expect(String(warn.mock.calls[0][0])).toMatch(/page-spec/);
-    }
-    expect(contexts).toHaveLength(0);
-  });
-});

package/src/page/mount.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mountIslands, type Registry } from "./mount";
-import type { PageSpec } from "./spec";
-
-type El = { slot: string };
-const ctx = { tag: "ctx" };
-const bus = { tag: "bus" };
-
-const spec: PageSpec = {
-  layout: "drawer",
-  islands: [
-    { name: "player", slot: "main", presentation: "page", config: { a: 1 } },
-    { name: "unknown", slot: "side", config: {} },
-    { name: "chat", slot: "missing", config: {} },
-    { name: "chat", slot: "drawer", presentation: "drawer", config: {} },
-  ],
-};
-
-describe("mountIslands", () => {
-  it("mounts each island in its slot with its config and the page's context, in spec order", () => {
-    const calls: unknown[][] = [];
-    const registry: Registry<typeof ctx, El, string, typeof bus> = {
-      player: (el, island, c, b) => (calls.push([el, island, c, b]), "player-component"),
-      chat: (el, island) => (calls.push([el, island.presentation]), "chat-component"),
-    };
-    const logs: string[] = [];
-    const out = mountIslands(spec, registry, (slot) => (slot === "missing" ? null : { slot }), () => ctx, bus, (m) => logs.push(m));
-    expect(out).toEqual(["player-component", "chat-component"]);
-    expect(calls).toEqual([
-      [{ slot: "main" }, spec.islands[0], ctx, bus],
-      [{ slot: "drawer" }, "drawer"],
-    ]);
-    // The unknown island and the missing slot are logged and skipped.
-    expect(logs).toHaveLength(2);
-    expect(logs.join("\n")).toMatch(/unknown/);
-    expect(logs.join("\n")).toMatch(/missing/);
-  });
-
-  it("doesn't take an island name from the registry's prototype", () => {
-    const logs: string[] = [];
-    const out = mountIslands({ layout: "a", islands: [{ name: "toString", slot: "main", config: {} }] }, {}, (slot) => ({ slot }), () => ctx, bus, (m) => logs.push(m));
-    expect(out).toEqual([]);
-    expect(logs).toHaveLength(1);
-  });
-
-  it("carries on when a factory throws", () => {
-    const logs: string[] = [];
-    const out = mountIslands(
-      spec,
-      {
-        player: () => {
-          throw new Error("boom");
-        },
-        chat: () => "ok",
-      },
-      (slot) => ({ slot }),
-      () => ctx,
-      bus,
-      (m) => logs.push(m),
-    );
-    expect(out).toEqual(["ok", "ok"]);
-    expect(logs.some((m) => m.includes("boom"))).toBe(true);
-  });
-
-  it("builds the page's context once, and only when there's an island to mount", () => {
-    let built = 0;
-    const context = () => (built++, ctx);
-    mountIslands({ layout: "index", islands: [] }, {}, () => ({ slot: "" }), context, bus, () => {});
-    expect(built).toBe(0);
-    mountIslands(spec, { player: () => "a", chat: () => "b" }, (slot) => ({ slot }), context, bus, () => {});
-    expect(built).toBe(1);
-  });
-});

package/src/page/spec.test.ts

@@ -1,65 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { readSpec } from "./spec";
-
-describe("readSpec", () => {
-  it("reads the spec goapplib's page.Spec writes (page/testdata/spec.json)", () => {
-    const text = readFileSync(join(__dirname, "../../../page/testdata/spec.json"), "utf8");
-    expect(readSpec(text)).toEqual({
-      layout: "drawer",
-      islands: [
-        { name: "player", slot: "main", presentation: "page", config: { note: "</script>", urls: ["/a.json"] } },
-        { name: "chat", slot: "side", config: {} },
-      ],
-    });
-  });
-
-  it("is null when there's no spec or it isn't one", () => {
-    for (const bad of [null, undefined, "", "not json", "null", "[]", '{"islands":[]}', '{"layout":"drawer"}', '{"layout":3,"islands":[]}']) {
-      expect(readSpec(bad), String(bad)).toBeNull();
-    }
-  });
-
-  it("drops islands it couldn't mount and cleans the rest", () => {
-    const spec = readSpec(
-      JSON.stringify({
-        layout: "drawer",
-        islands: [
-          { name: "player", slot: "main" },
-          { slot: "orphan" },
-          { name: "x", slot: 'main"] , body' },
-          { name: "chat", slot: "drawer", presentation: 7, config: "nope" },
-          "junk",
-        ],
-      }),
-    );
-    expect(spec).toEqual({
-      layout: "drawer",
-      islands: [
-        { name: "player", slot: "main", config: {} },
-        { name: "chat", slot: "drawer", config: {} },
-      ],
-    });
-  });
-
-  it("leaves an app's own fields out unless it reads them", () => {
-    expect(readSpec('{"layout":"a","islands":[],"things":[1]}')).toEqual({ layout: "a", islands: [] });
-  });
-
-  it("merges in what an extension reads, without letting it replace layout or islands", () => {
-    const text = JSON.stringify({ layout: "a", islands: [{ name: "p", slot: "main" }], things: [1, "x", 2] });
-    const spec = readSpec(text, (raw) => ({
-      things: Array.isArray(raw.things) ? raw.things.filter((t): t is number => typeof t === "number") : [],
-      layout: "overridden",
-    }));
-    expect(spec).toEqual({ layout: "a", islands: [{ name: "p", slot: "main", config: {} }], things: [1, 2] });
-  });
-
-  it("is null when the extension throws", () => {
-    const spec = readSpec('{"layout":"a","islands":[]}', () => {
-      throw new Error("bad things");
-    });
-    expect(spec).toBeNull();
-  });
-});