@praxisjs/decorators 1.7.0 → 2.0.0

package/src/__tests__/ref.test.ts

@@ -1,131 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect } from "vitest";
-
-import { StatefulComponent } from "@praxisjs/core";
-import { Ref, createRef } from "../properties/ref";
-
-function fieldCtx(name: string) {
-  const initializers: Array<(this: unknown) => void> = [];
-  return {
-    ctx: {
-      name,
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) {
-        initializers.push(fn);
-      },
-    } as ClassFieldDecoratorContext,
-    run(instance: unknown) {
-      initializers.forEach((fn) => { fn.call(instance); });
-    },
-  };
-}
-
-class TestComponent extends StatefulComponent {
-  render() { return null; }
-}
-
-describe("Ref decorator", () => {
-  it("initializes .current to null", () => {
-    const { ctx, run } = fieldCtx("elRef");
-    Ref()(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const ref = (instance as unknown as Record<string, unknown>).elRef as { current: unknown };
-    expect(ref.current).toBeNull();
-  });
-
-  it("is callable and sets .current", () => {
-    const { ctx, run } = fieldCtx("elRef");
-    Ref<HTMLDivElement>()(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const ref = (instance as unknown as Record<string, unknown>).elRef as ((el: HTMLDivElement | null) => void) & { current: HTMLDivElement | null };
-    const fakeEl = document.createElement("div") as HTMLDivElement;
-    ref(fakeEl);
-
-    expect(ref.current).toBe(fakeEl);
-  });
-
-  it("calling with null clears .current", () => {
-    const { ctx, run } = fieldCtx("elRef");
-    Ref<HTMLDivElement>()(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const ref = (instance as unknown as Record<string, unknown>).elRef as ((el: HTMLDivElement | null) => void) & { current: HTMLDivElement | null };
-    const fakeEl = document.createElement("div") as HTMLDivElement;
-    ref(fakeEl);
-    expect(ref.current).toBe(fakeEl);
-
-    ref(null);
-    expect(ref.current).toBeNull();
-  });
-
-  it("returns the same ref object on every access", () => {
-    const { ctx, run } = fieldCtx("elRef");
-    Ref()(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const inst = instance as unknown as Record<string, unknown>;
-    expect(inst.elRef).toBe(inst.elRef);
-  });
-
-  it("each instance gets its own independent ref", () => {
-    const { ctx: ctx1, run: run1 } = fieldCtx("elRef");
-    const { ctx: ctx2, run: run2 } = fieldCtx("elRef");
-    Ref<HTMLDivElement>()(undefined, ctx1);
-    Ref<HTMLDivElement>()(undefined, ctx2);
-
-    const a = new TestComponent();
-    const b = new TestComponent();
-    run1(a);
-    run2(b);
-
-    const refA = (a as unknown as Record<string, unknown>).elRef as ((el: HTMLDivElement | null) => void) & { current: HTMLDivElement | null };
-    const refB = (b as unknown as Record<string, unknown>).elRef as ((el: HTMLDivElement | null) => void) & { current: HTMLDivElement | null };
-
-    const el = document.createElement("div") as HTMLDivElement;
-    refA(el);
-
-    expect(refA.current).toBe(el);
-    expect(refB.current).toBeNull();
-  });
-});
-
-describe("createRef", () => {
-  it("initializes .current to null", () => {
-    const ref = createRef<HTMLDivElement>();
-    expect(ref.current).toBeNull();
-  });
-
-  it("is callable and sets .current", () => {
-    const ref = createRef<HTMLDivElement>();
-    const el = document.createElement("div") as HTMLDivElement;
-    ref(el);
-    expect(ref.current).toBe(el);
-  });
-
-  it("calling with null clears .current", () => {
-    const ref = createRef<HTMLDivElement>();
-    const el = document.createElement("div") as HTMLDivElement;
-    ref(el);
-    ref(null);
-    expect(ref.current).toBeNull();
-  });
-
-  it("each call creates an independent ref", () => {
-    const a = createRef<HTMLDivElement>();
-    const b = createRef<HTMLDivElement>();
-    const el = document.createElement("div") as HTMLDivElement;
-    a(el);
-    expect(a.current).toBe(el);
-    expect(b.current).toBeNull();
-  });
-});

package/src/__tests__/resource.test.ts

@@ -1,246 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-import { invalidateResource, _clearCache } from "@praxisjs/core/internal";
-
-import { Resource } from "../properties/resource";
-
-function makeFieldCtx(name: string) {
-  const initializers: Array<(this: unknown) => void> = [];
-  return {
-    ctx: {
-      name,
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
-    } as ClassFieldDecoratorContext,
-    run(instance: unknown) { initializers.forEach((fn) => { fn.call(instance); }); },
-  };
-}
-
-describe("@Resource", () => {
-  it("binds a Resource object to the field", () => {
-    const { ctx, run } = makeFieldCtx("users");
-    Resource(() => Promise.resolve([]))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.users as Record<string, unknown>;
-    expect(typeof r.data).toBe("function");
-    expect(typeof r.pending).toBe("function");
-    expect(typeof r.error).toBe("function");
-    expect(typeof r.status).toBe("function");
-    expect(typeof r.refetch).toBe("function");
-    expect(typeof r.cancel).toBe("function");
-    expect(typeof r.mutate).toBe("function");
-  });
-
-  it("starts in pending state when immediate=true (default)", () => {
-    const { ctx, run } = makeFieldCtx("data");
-    Resource(() => new Promise(() => {}))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.data as { pending: () => boolean; status: () => string };
-    expect(r.pending()).toBe(true);
-    expect(r.status()).toBe("pending");
-  });
-
-  it("starts idle when immediate=false", () => {
-    const { ctx, run } = makeFieldCtx("data");
-    Resource(() => Promise.resolve(42), { immediate: false })(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.data as { status: () => string; pending: () => boolean };
-    expect(r.status()).toBe("idle");
-    expect(r.pending()).toBe(false);
-  });
-
-  it("resolves data asynchronously", async () => {
-    const { ctx, run } = makeFieldCtx("items");
-    Resource(() => Promise.resolve([1, 2, 3]))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.items as { data: () => unknown; status: () => string };
-    await vi.waitFor(() => r.status() === "success");
-    expect(r.data()).toEqual([1, 2, 3]);
-  });
-
-  it("sets error state on rejection", async () => {
-    const { ctx, run } = makeFieldCtx("items");
-    Resource(() => Promise.reject(new Error("fetch failed")))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.items as { error: () => Error | null; status: () => string };
-    await new Promise((res) => setTimeout(res, 0));
-    expect(r.status()).toBe("error");
-    expect((r.error() as Error).message).toBe("fetch failed");
-  });
-
-  it("each instance gets its own resource", () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(0))(undefined, ctx);
-    const a: Record<string, unknown> = {};
-    const b: Record<string, unknown> = {};
-    run(a);
-    run(b);
-    expect(a.r).not.toBe(b.r);
-  });
-
-  it("mutate() updates data immediately", async () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(1))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.r as { mutate: (v: number) => void; data: () => number; status: () => string };
-    r.mutate(99);
-    expect(r.data()).toBe(99);
-    expect(r.status()).toBe("success");
-  });
-
-  it("cancel() stops a pending fetch", async () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => new Promise(() => {}))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.r as { cancel: () => void; status: () => string };
-    r.cancel();
-    expect(r.status()).toBe("idle");
-  });
-
-  it("uses initialData option", () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve("new"), { initialData: "default", immediate: false })(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.r as { data: () => string };
-    expect(r.data()).toBe("default");
-  });
-
-  it("cancel() called when not pending — no-op, no crash", () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(42), { immediate: false })(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.r as { cancel: () => void; status: () => string };
-    // Not pending (immediate=false → idle)
-    expect(r.status()).toBe("idle");
-    expect(() => r.cancel()).not.toThrow();
-    expect(r.status()).toBe("idle");
-  });
-
-  it("refetch() called after successful load — re-fetches", async () => {
-    let callCount = 0;
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(++callCount))(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const r = instance.r as { refetch: () => void; data: () => number; status: () => string };
-
-    await vi.waitFor(() => r.status() === "success");
-    expect(r.data()).toBe(1);
-
-    r.refetch();
-    await vi.waitFor(() => r.status() === "success" && r.data() === 2);
-    expect(callCount).toBe(2);
-  });
-
-  it("passes instance as self when fetcher has arity > 0", async () => {
-    const { ctx, run } = makeFieldCtx("r");
-    const fetcher = vi.fn((self: Record<string, unknown>) =>
-      Promise.resolve(self.value as number),
-    );
-    Resource(fetcher)(undefined, ctx);
-    const inst: Record<string, unknown> = { value: 42 };
-    run(inst);
-    const r = inst.r as { status: () => string; data: () => number };
-    await vi.waitFor(() => r.status() === "success");
-    expect(r.data()).toBe(42);
-    expect(fetcher).toHaveBeenCalledWith(inst);
-  });
-
-  it("setter is a no-op — assigning to the decorated field has no effect", () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(42), { immediate: false })(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const original = instance.r;
-    instance.r = "overwrite-attempt"; // triggers set(): void {} (no-op)
-    expect(instance.r).toBe(original);
-  });
-
-  it("onUnmount calls destroy() on the resource", async () => {
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(1))(undefined, ctx);
-    const inst: Record<string, unknown> = {};
-    run(inst);
-    const r = inst.r as { destroy: () => void };
-    const spy = vi.spyOn(r, "destroy");
-    (inst as { onUnmount?: () => void }).onUnmount?.();
-    expect(spy).toHaveBeenCalledOnce();
-  });
-});
-
-describe("@Resource — cache / SWR / invalidation", () => {
-  beforeEach(() => { _clearCache(); });
-
-  function makeFieldCtx(name: string) {
-    const initializers: Array<(this: unknown) => void> = [];
-    return {
-      ctx: {
-        name,
-        kind: "field" as const,
-        addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
-      } as ClassFieldDecoratorContext,
-      run(instance: unknown) { initializers.forEach((fn) => { fn.call(instance); }); },
-    };
-  }
-
-  it("key: serves stale cached data immediately while refetching (SWR)", async () => {
-    const { ctx: ctx1, run: run1 } = makeFieldCtx("r1");
-    Resource(() => Promise.resolve("first"), { key: "dec-swr" })(undefined, ctx1);
-    const inst1: Record<string, unknown> = {};
-    run1(inst1);
-    const r1 = inst1.r1 as { status: () => string; data: () => string; destroy: () => void };
-    await vi.waitFor(() => r1.status() === "success");
-
-    // Second decorator instance — should see cached data straight away
-    const { ctx: ctx2, run: run2 } = makeFieldCtx("r2");
-    Resource(() => Promise.resolve("second"), { key: "dec-swr" })(undefined, ctx2);
-    const inst2: Record<string, unknown> = {};
-    run2(inst2);
-    const r2 = inst2.r2 as { status: () => string; data: () => string; destroy: () => void };
-
-    expect(r2.data()).toBe("first"); // stale data shown immediately
-    await vi.waitFor(() => r2.data() === "second");
-    r1.destroy();
-    r2.destroy();
-  });
-
-  it("invalidateResource() triggers refetch on decorated field", async () => {
-    let call = 0;
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(++call), { key: "dec-inv" })(undefined, ctx);
-    const inst: Record<string, unknown> = {};
-    run(inst);
-    const r = inst.r as { status: () => string; data: () => number; destroy: () => void };
-    await vi.waitFor(() => r.status() === "success");
-    expect(r.data()).toBe(1);
-
-    invalidateResource("dec-inv");
-    await vi.waitFor(() => r.data() === 2);
-    r.destroy();
-  });
-
-  it("destroy() via onUnmount unregisters from cache — no refetch after unmount", async () => {
-    let call = 0;
-    const { ctx, run } = makeFieldCtx("r");
-    Resource(() => Promise.resolve(++call), { key: "dec-unreg" })(undefined, ctx);
-    const inst: Record<string, unknown> = {};
-    run(inst);
-    const r = inst.r as { status: () => string; data: () => number; destroy: () => void };
-    await vi.waitFor(() => r.status() === "success");
-
-    r.destroy();
-    const before = call;
-    invalidateResource("dec-unreg");
-    await new Promise((res) => setTimeout(res, 10));
-    expect(call).toBe(before);
-  });
-});

package/src/__tests__/slot.test.ts

@@ -1,179 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi } from "vitest";
-
-import { initSlots, getSlot, Slot } from "../properties/slot";
-import { StatefulComponent } from "@praxisjs/core";
-
-// ── initSlots / getSlot ──────────────────────────────────────────────────────
-
-describe("initSlots / getSlot", () => {
-  it("returns empty default slot when children is null", () => {
-    const instance = {};
-    initSlots(instance, null);
-    expect(getSlot(instance, "default")).toEqual([]);
-  });
-
-  it("returns empty array for unknown slot", () => {
-    const instance = {};
-    initSlots(instance, null);
-    expect(getSlot(instance, "unknown")).toEqual([]);
-  });
-
-  it("puts plain children into the default slot", () => {
-    const instance = {};
-    const child = document.createElement("span");
-    initSlots(instance, child);
-    expect(getSlot(instance, "default")).toEqual([child]);
-  });
-
-  it("flattens array children into the default slot", () => {
-    const instance = {};
-    const a = document.createElement("p");
-    const b = document.createElement("div");
-    initSlots(instance, [a, b]);
-    expect(getSlot(instance, "default")).toEqual([a, b]);
-  });
-
-  it("routes element with slot attribute to named slot", () => {
-    const instance = {};
-    const el = document.createElement("div");
-    el.setAttribute("slot", "header");
-    initSlots(instance, el);
-    expect(getSlot(instance, "header")).toEqual([el]);
-    expect(getSlot(instance, "default")).toEqual([]);
-    // slot attribute should be removed
-    expect(el.hasAttribute("slot")).toBe(false);
-  });
-
-  it("handles mixed named and default children", () => {
-    const instance = {};
-    const named = document.createElement("aside");
-    named.setAttribute("slot", "sidebar");
-    const plain = document.createElement("main");
-    initSlots(instance, [named, plain]);
-    expect(getSlot(instance, "sidebar")).toEqual([named]);
-    expect(getSlot(instance, "default")).toEqual([plain]);
-  });
-
-  it("skips null children in array", () => {
-    const instance = {};
-    const el = document.createElement("span");
-    initSlots(instance, [null, el, undefined]);
-    expect(getSlot(instance, "default")).toEqual([el]);
-  });
-
-  it("appends to existing named slot when same slot name appears twice", () => {
-    const instance = {};
-    const a = document.createElement("div");
-    a.setAttribute("slot", "header");
-    const b = document.createElement("div");
-    b.setAttribute("slot", "header");
-    initSlots(instance, [a, b]);
-    const headerSlot = getSlot(instance, "header");
-    expect(headerSlot).toHaveLength(2);
-    expect(headerSlot[0]).toBe(a);
-    expect(headerSlot[1]).toBe(b);
-  });
-});
-
-// ── Slot decorator ───────────────────────────────────────────────────────────
-
-describe("Slot decorator", () => {
-  it("provides the default slot via field decorator", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-
-    const initializers: Array<(this: unknown) => void> = [];
-    const ctx = {
-      name: "default",
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
-    } as ClassFieldDecoratorContext<StatefulComponent>;
-
-    Slot()(undefined, ctx);
-
-    const instance = new MyComp() as unknown as Record<string, unknown>;
-    initializers.forEach((fn) => { fn.call(instance); });
-
-    // No children initialized — slot should be empty
-    const children = document.createElement("p");
-    initSlots(instance as object, children);
-
-    expect(Array.isArray((instance as Record<string, unknown>).default)).toBe(true);
-  });
-
-  it("uses custom slot name when provided", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-
-    const initializers: Array<(this: unknown) => void> = [];
-    const ctx = {
-      name: "content",
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
-    } as ClassFieldDecoratorContext<StatefulComponent>;
-
-    Slot("header")(undefined, ctx);
-
-    const instance = new MyComp() as unknown as Record<string, unknown>;
-    initializers.forEach((fn) => { fn.call(instance); });
-
-    const el = document.createElement("nav");
-    el.setAttribute("slot", "header");
-    initSlots(instance as object, el);
-
-    const slot = (instance as Record<string, unknown>).content as unknown[];
-    expect(slot).toHaveLength(1);
-    expect(slot[0]).toBe(el);
-  });
-
-  it("skips warn on direct assignment in production mode", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-
-    const initializers: Array<(this: unknown) => void> = [];
-    const ctx = {
-      name: "default",
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
-    } as ClassFieldDecoratorContext<StatefulComponent>;
-
-    Slot()(undefined, ctx);
-
-    const instance = new MyComp() as unknown as Record<string, unknown>;
-    initializers.forEach((fn) => { fn.call(instance); });
-
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    vi.stubEnv("NODE_ENV", "production");
-    (instance as Record<string, unknown>).default = "bad";
-    expect(warn).not.toHaveBeenCalled();
-    vi.unstubAllEnvs();
-    warn.mockRestore();
-  });
-
-  it("warns on direct assignment in non-production", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-
-    const initializers: Array<(this: unknown) => void> = [];
-    const ctx = {
-      name: "default",
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
-    } as ClassFieldDecoratorContext<StatefulComponent>;
-
-    Slot()(undefined, ctx);
-
-    const instance = new MyComp() as unknown as Record<string, unknown>;
-    initializers.forEach((fn) => { fn.call(instance); });
-
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    (instance as Record<string, unknown>).default = "bad";
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining("[Slot]"));
-    warn.mockRestore();
-  });
-});