@praxisjs/decorators 1.7.0 → 2.0.1

package/src/__tests__/component.test.ts

@@ -1,167 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { StatefulComponent, StatelessComponent } from "@praxisjs/core";
-import { getComponentProps } from "@praxisjs/core/internal";
-
-import { Component } from "../component/component";
-
-// ── Component decorator ───────────────────────────────────────────────────────
-
-describe("Component decorator", () => {
-  it("sets __isComponent = true on the enhanced class", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyComp, {} as ClassDecoratorContext);
-    expect(Enhanced.__isComponent).toBe(true);
-  });
-
-  it("preserves the original class name", () => {
-    class MyButton extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyButton, {} as ClassDecoratorContext);
-    expect(Enhanced.name).toBe("MyButton");
-  });
-
-  it("marks __isStateless = false for StatefulComponent subclasses", () => {
-    class MyStateful extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyStateful, {} as ClassDecoratorContext);
-    expect(Enhanced.__isStateless).toBe(false);
-  });
-
-  it("marks __isStateless = true for StatelessComponent subclasses", () => {
-    class MyStateless extends StatelessComponent {
-      render() { return null; }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const Enhanced = Component()(MyStateless as any, {} as ClassDecoratorContext);
-    expect(Enhanced.__isStateless).toBe(true);
-  });
-
-  it("enhanced class can still be instantiated", () => {
-    class Counter extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(Counter, {} as ClassDecoratorContext);
-    const instance = new Enhanced();
-    expect(instance).toBeInstanceOf(Counter);
-  });
-
-  it("returns a subclass of the original constructor", () => {
-    class Base extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(Base, {} as ClassDecoratorContext);
-    expect(Enhanced.prototype).toBeInstanceOf(Base);
-  });
-
-  // ── Happy paths ──────────────────────────────────────────────────────────────
-
-  it("forwards constructor args — props reach the base constructor", () => {
-    class WithProps extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(WithProps, {} as ClassDecoratorContext);
-    const instance = new Enhanced({ greeting: "hello" });
-    expect((getComponentProps(instance) as { greeting: string }).greeting).toBe("hello");
-  });
-
-  it("instance methods from the original class remain accessible", () => {
-    class Greeter extends StatefulComponent {
-      greet() { return "hello"; }
-      render() { return null; }
-    }
-    const Enhanced = Component()(Greeter, {} as ClassDecoratorContext);
-    const instance = new Enhanced();
-    expect((instance as Greeter).greet()).toBe("hello");
-  });
-
-  it("static properties of the original class are preserved on Enhanced", () => {
-    class WithStatic extends StatefulComponent {
-      static readonly version = "1.0";
-      render() { return null; }
-    }
-    const Enhanced = Component()(WithStatic, {} as ClassDecoratorContext);
-    expect((Enhanced as typeof WithStatic).version).toBe("1.0");
-  });
-
-  // ── Edge cases ───────────────────────────────────────────────────────────────
-
-  it("applying Component() twice preserves name and flags", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-    const E1 = Component()(MyComp, {} as ClassDecoratorContext);
-    const E2 = Component()(E1, {} as ClassDecoratorContext);
-    expect(E2.__isComponent).toBe(true);
-    expect(E2.__isStateless).toBe(false);
-    expect(E2.name).toBe("MyComp"); // name survives double-wrap
-  });
-
-  it("deep StatelessComponent inheritance — __isStateless is still true", () => {
-    class BaseStateless extends StatelessComponent {
-      render() { return null; }
-    }
-    class DeepChild extends BaseStateless {
-      render() { return null; }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const Enhanced = Component()(DeepChild as any, {} as ClassDecoratorContext);
-    expect(Enhanced.__isStateless).toBe(true);
-  });
-
-  it("anonymous class gets an empty name", () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const Enhanced = Component()(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      class extends StatefulComponent { render() { return null; } } as any,
-      {} as ClassDecoratorContext,
-    );
-    expect(Enhanced.name).toBe("");
-  });
-
-  it("__isComponent and __isStateless are static — not own properties of instances", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyComp, {} as ClassDecoratorContext);
-    const instance = new Enhanced();
-    // Static fields live on the class, not on instances
-    expect(Object.prototype.hasOwnProperty.call(instance, "__isComponent")).toBe(false);
-    expect(Object.prototype.hasOwnProperty.call(instance, "__isStateless")).toBe(false);
-  });
-
-  it("subclassing Enhanced inherits __isComponent and __isStateless", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyComp, {} as ClassDecoratorContext);
-    // `class Sub extends Enhanced` sets Object.getPrototypeOf(Sub) === Enhanced,
-    // making static fields visible through the chain. Simulate that here to
-    // avoid TS2510 (conflicting constructor return types in the intersection type).
-    const Sub = Object.create(Enhanced) as typeof Enhanced;
-    expect(Sub.__isComponent).toBe(true);
-    expect(Sub.__isStateless).toBe(false);
-  });
-
-  it("Enhanced is a different reference from the original constructor", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyComp, {} as ClassDecoratorContext);
-    expect(Enhanced).not.toBe(MyComp);
-  });
-
-  it("render() falls through to originalRender when enhancement has no render override", () => {
-    class MyComp extends StatefulComponent {
-      render() { return null; }
-    }
-    const Enhanced = Component()(MyComp, {} as ClassDecoratorContext);
-    const instance = new Enhanced();
-    // ComponentBehavior.create() returns {} (no render), so line 48 is hit
-    expect((instance as StatefulComponent).render()).toBeNull();
-  });
-});

package/src/__tests__/compose.test.ts

@@ -1,202 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import { StatefulComponent } from "@praxisjs/core";
-import { signal } from "@praxisjs/core/internal";
-import type { Composable } from "@praxisjs/core";
-
-import { Compose } from "../properties/compose";
-
-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; }
-}
-
-// Simple composable returning plain values
-class CounterComposable implements Composable {
-  count = 0;
-  setup() {
-    return { count: this.count, label: "counter" };
-  }
-}
-
-// Composable returning a signal (reactive property)
-class ReactiveComposable implements Composable {
-  _count = signal(0);
-  setup() {
-    return { count: this._count };
-  }
-}
-
-// Composable with lifecycle hooks
-class LifecycleComposable implements Composable {
-  onMount = vi.fn();
-  onUnmount = vi.fn();
-  setup() {
-    return { active: true };
-  }
-}
-
-// Composable that uses constructor args
-class ArgsComposable implements Composable {
-  constructor(private multiplier: number) {}
-  setup() {
-    return { multiplier: this.multiplier };
-  }
-}
-
-// Composable returning a plain function (non-reactive) in its view
-class PlainFnComposable {
-  setup() {
-    return { handler: () => 42 };
-  }
-}
-
-describe("@Compose decorator", () => {
-  it("creates a view getter on the field", () => {
-    const { ctx, run } = fieldCtx("counter");
-    Compose(CounterComposable)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const view = (instance as unknown as Record<string, unknown>).counter as Record<string, unknown>;
-    expect(view).toBeDefined();
-    expect(view.count).toBe(0);
-    expect(view.label).toBe("counter");
-  });
-
-  it("reactive signal values are resolved via getter", () => {
-    const { ctx, run } = fieldCtx("reactive");
-    Compose(ReactiveComposable)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const view = (instance as unknown as Record<string, unknown>).reactive as Record<string, unknown>;
-    expect(view.count).toBe(0);
-  });
-
-  it("calls onMount when component mounts", () => {
-    const { ctx, run } = fieldCtx("lc");
-    Compose(LifecycleComposable)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const view = (instance as unknown as Record<string, unknown>).lc as Record<string, unknown>;
-    expect(view).toBeDefined();
-
-    // Trigger onMount
-    instance.onMount!();
-    const lc = new LifecycleComposable();
-    // The composable's onMount would have been called
-    // We verify the instance has an onMount wiring
-    expect(typeof instance.onMount).toBe("function");
-  });
-
-  it("calls onUnmount when component unmounts", () => {
-    const { ctx, run } = fieldCtx("lc2");
-    Compose(LifecycleComposable)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-    expect(typeof instance.onUnmount).toBe("function");
-  });
-
-  it("invoking instance.onUnmount() executes the composable's onUnmount", () => {
-    const unmountSpy = vi.fn();
-
-    class SpyComposable {
-      onUnmount = unmountSpy;
-      setup() { return {}; }
-    }
-
-    const { ctx, run } = fieldCtx("spyComp");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    Compose(SpyComposable as any)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    instance.onUnmount!();
-    expect(unmountSpy).toHaveBeenCalled();
-  });
-
-  it("passes constructor args to the composable", () => {
-    const { ctx, run } = fieldCtx("args");
-    Compose(ArgsComposable, 5)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const view = (instance as unknown as Record<string, unknown>).args as Record<string, unknown>;
-    expect(view.multiplier).toBe(5);
-  });
-
-  it("resolves string constructor args from instance properties", () => {
-    const { ctx, run } = fieldCtx("resolved");
-    Compose(ArgsComposable, "myMultiplier")(undefined, ctx);
-
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).myMultiplier = 10;
-    run(instance);
-
-    const view = (instance as unknown as Record<string, unknown>).resolved as Record<string, unknown>;
-    expect(view.multiplier).toBe(10);
-  });
-
-  it("each instance gets its own composable view", () => {
-    const { ctx, run } = fieldCtx("c");
-    Compose(CounterComposable)(undefined, ctx);
-
-    const a = new TestComponent();
-    const b = new TestComponent();
-    run(a);
-    run(b);
-
-    const viewA = (a as unknown as Record<string, unknown>).c;
-    const viewB = (b as unknown as Record<string, unknown>).c;
-    expect(viewA).not.toBe(viewB);
-  });
-
-  it("plain function value in view is stored as-is (not treated as reactive)", () => {
-    const { ctx, run } = fieldCtx("pfn");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    Compose(PlainFnComposable as any)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const view = (instance as unknown as Record<string, unknown>).pfn as Record<string, unknown>;
-    // handler is a plain function — isReactive returns false, stored directly
-    expect(typeof view.handler).toBe("function");
-    expect((view.handler as () => number)()).toBe(42);
-  });
-
-  it("view getter always returns same view object", () => {
-    const { ctx, run } = fieldCtx("stable");
-    Compose(CounterComposable)(undefined, ctx);
-
-    const instance = new TestComponent();
-    run(instance);
-
-    const v1 = (instance as unknown as Record<string, unknown>).stable;
-    const v2 = (instance as unknown as Record<string, unknown>).stable;
-    expect(v1).toBe(v2);
-  });
-});

package/src/__tests__/deep-state.test.ts

@@ -1,265 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { StatefulComponent } from "@praxisjs/core";
-import { effect } from "@praxisjs/core/internal";
-
-import { DeepState } from "../properties/deep-state";
-
-class TestComponent extends StatefulComponent {
-  render() { return null; }
-}
-
-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); });
-    },
-  };
-}
-
-describe("@DeepState decorator", () => {
-  it("reads initial value", () => {
-    const { ctx, run } = fieldCtx("config");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).config = { theme: "light" };
-    run(instance);
-
-    const inst = instance as unknown as { config: { theme: string } };
-    expect(inst.config.theme).toBe("light");
-  });
-
-  it("nested object mutation triggers reactive effect", () => {
-    const { ctx, run } = fieldCtx("config");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).config = { theme: { mode: "light" } };
-    run(instance);
-
-    const inst = instance as unknown as { config: { theme: { mode: string } } };
-    const log: string[] = [];
-    effect(() => { log.push(inst.config.theme.mode); });
-
-    inst.config.theme.mode = "dark";
-    expect(log).toEqual(["light", "dark"]);
-  });
-
-  it("array push triggers reactive effect", () => {
-    const { ctx, run } = fieldCtx("items");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).items = [1, 2];
-    run(instance);
-
-    const inst = instance as unknown as { items: number[] };
-    const log: number[][] = [];
-    effect(() => { log.push([...inst.items]); });
-
-    inst.items.push(3);
-    expect(log[log.length - 1]).toEqual([1, 2, 3]);
-  });
-
-  it("array index assignment triggers reactive effect", () => {
-    const { ctx, run } = fieldCtx("list");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).list = ["a", "b"];
-    run(instance);
-
-    const inst = instance as unknown as { list: string[] };
-    const log: string[][] = [];
-    effect(() => { log.push([...inst.list]); });
-
-    inst.list[0] = "z";
-    expect(log[log.length - 1]).toEqual(["z", "b"]);
-  });
-
-  it("property deletion triggers reactive effect", () => {
-    const { ctx, run } = fieldCtx("obj");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).obj = { a: 1, b: 2 };
-    run(instance);
-
-    const inst = instance as unknown as { obj: Record<string, number> };
-    const log: string[][] = [];
-    effect(() => { log.push(Object.keys(inst.obj)); });
-
-    delete inst.obj.a;
-    expect(log[log.length - 1]).not.toContain("a");
-  });
-
-  it("direct assignment replaces root and triggers effect", () => {
-    const { ctx, run } = fieldCtx("data");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).data = { x: 1 };
-    run(instance);
-
-    const inst = instance as unknown as { data: { x: number } };
-    const log: number[] = [];
-    effect(() => { log.push(inst.data.x); });
-
-    inst.data = { x: 99 };
-    expect(log).toEqual([1, 99]);
-  });
-
-  it("mutations on new root after reassignment are reactive", () => {
-    const { ctx, run } = fieldCtx("cfg");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).cfg = { v: 0 };
-    run(instance);
-
-    const inst = instance as unknown as { cfg: { v: number } };
-    inst.cfg = { v: 10 };
-
-    const log: number[] = [];
-    effect(() => { log.push(inst.cfg.v); });
-
-    inst.cfg.v = 20;
-    expect(log).toEqual([10, 20]);
-  });
-
-  it("null initial value is handled gracefully", () => {
-    const { ctx, run } = fieldCtx("maybe");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).maybe = null;
-    run(instance);
-
-    const inst = instance as unknown as { maybe: null | { x: number } };
-    expect(inst.maybe).toBeNull();
-
-    const log: unknown[] = [];
-    effect(() => { log.push(inst.maybe); });
-
-    inst.maybe = { x: 5 };
-    expect(log).toEqual([null, { x: 5 }]);
-  });
-
-  it("setter with null value — proxy not created, value is null", () => {
-    const { ctx, run } = fieldCtx("nullable");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).nullable = { x: 1 };
-    run(instance);
-
-    const inst = instance as unknown as { nullable: { x: number } | null };
-    inst.nullable = null;
-    expect(inst.nullable).toBeNull();
-  });
-
-  it("setter with primitive value — value stored directly without proxy", () => {
-    const { ctx, run } = fieldCtx("num");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).num = { v: 0 };
-    run(instance);
-
-    const inst = instance as unknown as { num: number | { v: number } };
-    inst.num = 99;
-    expect(inst.num).toBe(99);
-  });
-
-  it("deeply nested mutation triggers effect", () => {
-    const { ctx, run } = fieldCtx("deep");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).deep = { a: { b: { c: 0 } } };
-    run(instance);
-
-    const inst = instance as unknown as { deep: { a: { b: { c: number } } } };
-    const log: number[] = [];
-    effect(() => { log.push(inst.deep.a.b.c); });
-
-    inst.deep.a.b.c = 42;
-    expect(log).toEqual([0, 42]);
-  });
-});
-
-describe("@DeepState — proxy identity and notifications", () => {
-  function setup(initial: unknown) {
-    const { ctx, run } = fieldCtx("data");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).data = initial;
-    run(instance);
-    const inst = instance as unknown as { data: any };
-    let runs = 0;
-    effect(() => {
-      void inst.data;
-      runs++;
-    });
-    runs = 0;
-    return { inst, runs: () => runs };
-  }
-
-  it("returns the same proxy for the same nested object", () => {
-    const { inst } = setup({ nested: { a: 1 } });
-    expect(inst.data.nested).toBe(inst.data.nested);
-  });
-
-  it("keeps identity across reads after an unrelated mutation", () => {
-    const { inst } = setup({ nested: { a: 1 }, other: 0 });
-    const before = inst.data.nested;
-    inst.data.other = 1;
-    expect(inst.data.nested).toBe(before);
-  });
-
-  it("returns a fresh proxy once the root is replaced", () => {
-    const { inst } = setup({ nested: { a: 1 } });
-    const before = inst.data;
-    inst.data = { nested: { a: 1 } };
-    expect(inst.data).not.toBe(before);
-  });
-
-  it("does not notify when a property is set to the value it already has", () => {
-    const { inst, runs } = setup({ a: 1 });
-    inst.data.a = 1;
-    expect(runs()).toBe(0);
-  });
-
-  it("notifies when a property changes or a new key is added", () => {
-    const { inst, runs } = setup({ a: 1 });
-    inst.data.a = 2;
-    expect(runs()).toBe(1);
-    inst.data.b = 3;
-    expect(runs()).toBe(2);
-  });
-
-  it("notifies once for an array push", () => {
-    const { inst, runs } = setup({ list: [1] });
-    inst.data.list.push(2);
-    expect(runs()).toBe(1);
-    expect(inst.data.list.length).toBe(2);
-  });
-
-  it("notifies on delete only when the key existed", () => {
-    const { inst, runs } = setup({ a: 1 });
-    delete inst.data.missing;
-    expect(runs()).toBe(0);
-    delete inst.data.a;
-    expect(runs()).toBe(1);
-  });
-
-  it("assigning a primitive root and null roots still works", () => {
-    const { ctx, run } = fieldCtx("n");
-    DeepState()(undefined, ctx);
-    const instance = new TestComponent();
-    (instance as unknown as Record<string, unknown>).n = null;
-    run(instance);
-    const inst = instance as unknown as { n: unknown };
-    expect(inst.n).toBeNull();
-    inst.n = 5;
-    expect(inst.n).toBe(5);
-    inst.n = { x: 1 };
-    expect((inst.n as { x: number }).x).toBe(1);
-  });
-});