@praxisjs/decorators 0.4.1 → 0.4.3

package/src/__tests__/component.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect } from "vitest";
+
+import { StatefulComponent, StatelessComponent } from "@praxisjs/core";
+
+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(instance.props.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);
+  });
+});

package/src/__tests__/events.test.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi } from "vitest";
+
+import { StatefulComponent } from "@praxisjs/core";
+
+import { createCommand } from "../events/command";
+import { Emit } from "../events/emit";
+import { readProp } from "../events/helper";
+import { OnCommand } from "../events/on-command";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+class TestComponent extends StatefulComponent {
+  render() { return null; }
+}
+
+function methodCtx(name: string) {
+  const initializers: Array<(this: unknown) => void> = [];
+  return {
+    ctx: {
+      name,
+      kind: "method" as const,
+      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
+    } as ClassMethodDecoratorContext,
+    run(instance: unknown) { initializers.forEach((fn) => { fn.call(instance); }); },
+  };
+}
+
+// ── createCommand ─────────────────────────────────────────────────────────────
+
+describe("createCommand", () => {
+  it("trigger calls all subscribed handlers with the argument", () => {
+    const cmd = createCommand<number>();
+    const h1 = vi.fn();
+    const h2 = vi.fn();
+    cmd.subscribe(h1);
+    cmd.subscribe(h2);
+    cmd.trigger(42);
+    expect(h1).toHaveBeenCalledWith(42);
+    expect(h2).toHaveBeenCalledWith(42);
+  });
+
+  it("trigger does nothing when no handlers are subscribed", () => {
+    const cmd = createCommand<string>();
+    expect(() => cmd.trigger("hello")).not.toThrow();
+  });
+
+  it("subscribe returns an unsubscribe function", () => {
+    const cmd = createCommand<void>();
+    const handler = vi.fn();
+    const unsub = cmd.subscribe(handler);
+    unsub();
+    cmd.trigger();
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("void command can be triggered without args", () => {
+    const cmd = createCommand();
+    const handler = vi.fn();
+    cmd.subscribe(handler);
+    cmd.trigger(undefined as unknown as void);
+    expect(handler).toHaveBeenCalledOnce();
+  });
+});
+
+// ── readProp ──────────────────────────────────────────────────────────────────
+
+describe("readProp", () => {
+  it("returns value from _rawProps when defined", () => {
+    const instance = new TestComponent({ myProp: "fromParent" });
+    expect(readProp(instance, "myProp")).toBe("fromParent");
+  });
+
+  it("falls back to _defaults when _rawProps does not define the prop", () => {
+    const instance = new TestComponent();
+    instance._defaults.myProp = "default";
+    expect(readProp(instance, "myProp")).toBe("default");
+  });
+
+  it("returns undefined when prop is not in either", () => {
+    const instance = new TestComponent();
+    expect(readProp(instance, "missing")).toBeUndefined();
+  });
+});
+
+// ── Emit ─────────────────────────────────────────────────────────────────────
+
+describe("Emit decorator", () => {
+  it("calls the prop callback with the return value of the method", () => {
+    const { ctx, run } = methodCtx("handleInput");
+    const original = function (this: object, value: string) { return value.toUpperCase(); };
+    Emit("onChange")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onChange: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, (v: string) => void>).handleInput;
+    method.call(instance, "hello");
+    expect(callback).toHaveBeenCalledWith("HELLO");
+  });
+
+  it("calls the prop callback with the method args when return value is undefined", () => {
+    const { ctx, run } = methodCtx("doSomething");
+    const original = function (this: object, a: number, b: number) { return undefined; };
+    Emit("onDo")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onDo: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, (a: number, b: number) => void>).doSomething;
+    method.call(instance, 1, 2);
+    expect(callback).toHaveBeenCalledWith(1, 2);
+  });
+
+  it("calls the prop callback with no args when return is undefined and no args", () => {
+    const { ctx, run } = methodCtx("fire");
+    const original = function (this: object) { return undefined; };
+    Emit("onFire")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onFire: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, () => void>).fire;
+    method.call(instance);
+    expect(callback).toHaveBeenCalledOnce();
+    expect(callback).toHaveBeenCalledWith();
+  });
+
+  it("does not throw when the prop callback is not a function", () => {
+    const { ctx, run } = methodCtx("submit");
+    const original = function (this: object) { return "result"; };
+    Emit("onSubmit")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const instance = new TestComponent(); // no onSubmit prop
+    run(instance);
+
+    const method = (instance as unknown as Record<string, () => void>).submit;
+    expect(() => method.call(instance)).not.toThrow();
+  });
+
+  it("still returns the original method's return value", () => {
+    const { ctx, run } = methodCtx("compute");
+    const original = function (this: object) { return 99; };
+    Emit("onResult")(original as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const callback = vi.fn();
+    const instance = new TestComponent({ onResult: callback });
+    run(instance);
+
+    const method = (instance as unknown as Record<string, () => number>).compute;
+    const result = method.call(instance);
+    expect(result).toBe(99);
+  });
+});
+
+// ── OnCommand ─────────────────────────────────────────────────────────────────
+
+describe("OnCommand decorator", () => {
+  it("subscribes to the command on mount and calls the method when triggered", () => {
+    const { ctx, run } = methodCtx("handleCmd");
+    const handler = vi.fn();
+    OnCommand("myCommand")(handler as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const cmd = createCommand<string>();
+    const instance = new TestComponent({ myCommand: cmd });
+    run(instance);
+
+    instance.onMount?.();
+    cmd.trigger("payload");
+    expect(handler).toHaveBeenCalledWith("payload");
+  });
+
+  it("unsubscribes from the command on unmount", () => {
+    const { ctx, run } = methodCtx("onMsg");
+    const handler = vi.fn();
+    OnCommand("msg")(handler as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const cmd = createCommand<string>();
+    const instance = new TestComponent({ msg: cmd });
+    run(instance);
+
+    instance.onMount?.();
+    instance.onUnmount?.();
+    cmd.trigger("after-unmount");
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("warns when the command prop is not provided", () => {
+    const { ctx, run } = methodCtx("onMissing");
+    OnCommand("missingProp")(vi.fn() as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const instance = new TestComponent(); // no missingProp
+    run(instance);
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    instance.onMount?.();
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("[OnCommand]"));
+    warn.mockRestore();
+  });
+
+  it("warns when the command prop is not a valid Command", () => {
+    const { ctx, run } = methodCtx("onBadCmd");
+    OnCommand("badProp")(vi.fn() as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const instance = new TestComponent({ badProp: "not-a-command" });
+    run(instance);
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    instance.onMount?.();
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining("[OnCommand]"));
+    warn.mockRestore();
+  });
+
+  it("preserves the original onMount and onUnmount implementations", () => {
+    const { ctx, run } = methodCtx("onEvt");
+    OnCommand("evt")(vi.fn() as never, ctx as unknown as ClassMethodDecoratorContext<StatefulComponent>);
+
+    const cmd = createCommand<void>();
+    const instance = new TestComponent({ evt: cmd });
+    run(instance);
+
+    const mountSpy = vi.fn();
+    const unmountSpy = vi.fn();
+    const prevMount = instance.onMount?.bind(instance);
+    const prevUnmount = instance.onUnmount?.bind(instance);
+    instance.onMount = function () { mountSpy(); prevMount?.(); };
+    instance.onUnmount = function () { unmountSpy(); prevUnmount?.(); };
+
+    instance.onMount();
+    instance.onUnmount();
+    expect(mountSpy).toHaveBeenCalled();
+    expect(unmountSpy).toHaveBeenCalled();
+  });
+});