@praxisjs/runtime 0.7.0 → 0.8.0

package/src/__tests__/component.test.ts

@@ -1,363 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi, afterEach } from "vitest";
-
-import { StatefulComponent } from "@praxisjs/core";
-import { getComponentProps } from "@praxisjs/core/internal";
-
-import { mountComponent } from "../component";
-import { Scope } from "../scope";
-
-class SimpleComp extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  render() {
-    return document.createTextNode("hello");
-  }
-}
-
-class NullComp extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  render() { return null; }
-}
-
-class MultiComp extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  render() {
-    return [
-      document.createTextNode("a"),
-      document.createTextNode("b"),
-    ];
-  }
-}
-
-class ErrorComp extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  onError(_err: Error): undefined {}
-  render(): never {
-    throw new Error("render error");
-  }
-}
-
-class NonErrorThrowComp extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  onError(_err: Error): undefined {}
-  render(): never {
-    // eslint-disable-next-line @typescript-eslint/only-throw-error
-    throw "string render error";
-  }
-}
-
-class LifecycleComp extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  onBeforeMount() {}
-  onMount() {}
-  onUnmount() {}
-  render() { return null; }
-}
-
-describe("mountComponent", () => {
-  it("returns an array of nodes", () => {
-    const scope = new Scope();
-    const nodes = mountComponent(SimpleComp, {}, scope);
-    expect(Array.isArray(nodes)).toBe(true);
-    expect(nodes.length).toBeGreaterThan(0);
-    scope.dispose();
-  });
-
-  it("wraps output with start/end comment anchors", () => {
-    const scope = new Scope();
-    const nodes = mountComponent(SimpleComp, {}, scope);
-    expect(nodes[0].nodeType).toBe(Node.COMMENT_NODE);
-    expect(nodes[nodes.length - 1].nodeType).toBe(Node.COMMENT_NODE);
-    scope.dispose();
-  });
-
-  it("mounts the rendered content between comments", () => {
-    const scope = new Scope();
-    const container = document.createElement("div");
-    const nodes = mountComponent(SimpleComp, {}, scope);
-    nodes.forEach((n) => container.appendChild(n));
-    expect(container.textContent).toContain("hello");
-    scope.dispose();
-  });
-
-  it("calls onBeforeMount before render", () => {
-    const scope = new Scope();
-    const order: string[] = [];
-    class OrderComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onBeforeMount() { order.push("before"); }
-      render() {
-        order.push("render");
-        return null;
-      }
-    }
-    mountComponent(OrderComp, {}, scope);
-    expect(order).toEqual(["before", "render"]);
-    scope.dispose();
-  });
-
-  it("calls onMount asynchronously after mount", async () => {
-    const scope = new Scope();
-    const onMount = vi.spyOn(LifecycleComp.prototype, "onMount");
-    mountComponent(LifecycleComp, {}, scope);
-    expect(onMount).not.toHaveBeenCalled(); // not called synchronously
-    await Promise.resolve(); // flush microtask
-    expect(onMount).toHaveBeenCalled();
-    onMount.mockRestore();
-    scope.dispose();
-  });
-
-  it("calls onUnmount when scope is disposed", async () => {
-    const scope = new Scope();
-    const onUnmount = vi.spyOn(LifecycleComp.prototype, "onUnmount");
-    mountComponent(LifecycleComp, {}, scope);
-    await Promise.resolve();
-    scope.dispose();
-    expect(onUnmount).toHaveBeenCalled();
-    onUnmount.mockRestore();
-  });
-
-  it("calls onError when render throws", () => {
-    const scope = new Scope();
-    const onError = vi.spyOn(ErrorComp.prototype, "onError");
-    mountComponent(ErrorComp, {}, scope);
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-    onError.mockRestore();
-    scope.dispose();
-  });
-
-  it("wraps non-Error throws in Error before passing to onError", () => {
-    const scope = new Scope();
-    const onError = vi.spyOn(NonErrorThrowComp.prototype, "onError");
-    mountComponent(NonErrorThrowComp, {}, scope);
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-    expect((onError.mock.calls[0][0] as Error).message).toBe("string render error");
-    onError.mockRestore();
-    scope.dispose();
-  });
-
-  it("passes props to the component instance", () => {
-    let receivedProp: unknown;
-    class PropsComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      render() {
-        receivedProp = (getComponentProps(this) as Record<string, unknown>).msg;
-        return null;
-      }
-    }
-    const scope = new Scope();
-    mountComponent(PropsComp, { msg: "hello" }, scope);
-    expect(receivedProp).toBe("hello");
-    scope.dispose();
-  });
-
-  it("mounts array of children", () => {
-    const scope = new Scope();
-    const container = document.createElement("div");
-    const nodes = mountComponent(MultiComp, {}, scope);
-    nodes.forEach((n) => container.appendChild(n));
-    expect(container.textContent).toBe("ab");
-    scope.dispose();
-  });
-
-  it("onError handler that itself throws — outer error propagates", () => {
-    class ThrowingErrorComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onError(_err: Error): never {
-        throw new Error("onError also throws");
-      }
-      render(): never {
-        throw new Error("render error");
-      }
-    }
-    const scope = new Scope();
-    expect(() => mountComponent(ThrowingErrorComp, {}, scope)).toThrow("onError also throws");
-    scope.dispose();
-  });
-
-  it("onError returning a Node mounts it as fallback UI", () => {
-    class FallbackComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onError(_err: Error) {
-        const p = document.createElement("p");
-        p.textContent = "error boundary";
-        return p;
-      }
-      render(): never {
-        throw new Error("render error");
-      }
-    }
-    const scope = new Scope();
-    const container = document.createElement("div");
-    const nodes = mountComponent(FallbackComp, {}, scope);
-    nodes.forEach((n) => container.appendChild(n));
-    expect(container.querySelector("p")?.textContent).toBe("error boundary");
-    scope.dispose();
-  });
-
-  it("onError returning null renders nothing as fallback", () => {
-    class NullFallbackComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onError(_err: Error) {
-        return null;
-      }
-      render(): never {
-        throw new Error("render error");
-      }
-    }
-    const scope = new Scope();
-    const container = document.createElement("div");
-    const nodes = mountComponent(NullFallbackComp, {}, scope);
-    nodes.forEach((n) => container.appendChild(n));
-    expect(container.textContent).toBe("");
-    scope.dispose();
-  });
-
-  it("skips onMount and instance ref when disposed before the mount microtask", async () => {
-    class MountAfterDisposeComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onMount() {}
-      render() { return null; }
-    }
-    const scope = new Scope();
-    const onMount = vi.spyOn(MountAfterDisposeComp.prototype, "onMount");
-    const refs: Array<object | null> = [];
-    mountComponent(MountAfterDisposeComp, { ref: (inst: object | null) => { refs.push(inst); } }, scope);
-    scope.dispose(); // dispose before microtask flushes
-    await Promise.resolve(); // flush microtask
-    expect(onMount).not.toHaveBeenCalled();
-    expect(refs).toEqual([null]);
-    onMount.mockRestore();
-  });
-
-  it("ref callback receives the instance after onMount", async () => {
-    const scope = new Scope();
-    const refs: Array<object | null> = [];
-    const nodes = mountComponent(LifecycleComp, { ref: (inst: object | null) => { refs.push(inst); } }, scope);
-    expect(refs).toHaveLength(0); // not called synchronously
-    await Promise.resolve();
-    expect(refs).toHaveLength(1);
-    expect(refs[0]).toBeInstanceOf(LifecycleComp);
-    nodes.length; // suppress unused warning
-    scope.dispose();
-  });
-
-  it("ref callback is called with null on unmount", async () => {
-    const scope = new Scope();
-    const refs: Array<object | null> = [];
-    mountComponent(LifecycleComp, { ref: (inst: object | null) => { refs.push(inst); } }, scope);
-    await Promise.resolve();
-    scope.dispose();
-    expect(refs).toEqual([expect.any(LifecycleComp), null]);
-  });
-
-  it("ref is not forwarded to component props", () => {
-    let seenRef: unknown = "not-checked";
-    class RefCheckComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      render() {
-        seenRef = (getComponentProps(this) as Record<string, unknown>).ref;
-        return null;
-      }
-    }
-    const scope = new Scope();
-    const refFn = () => {};
-    mountComponent(RefCheckComp, { ref: refFn }, scope);
-    expect(seenRef).toBeUndefined();
-    scope.dispose();
-  });
-
-  it("component with no render() method — error reaches onError handler", () => {
-    let caughtError: Error | undefined;
-    class NoRenderComp extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onError(err: Error): undefined { caughtError = err; }
-      render(): Node[] { throw new TypeError("render is not implemented"); }
-    }
-    const scope = new Scope();
-    // mountComponent catches the TypeError and routes it through onError
-    expect(() => mountComponent(NoRenderComp as never, {}, scope)).not.toThrow();
-    expect(caughtError).toBeInstanceOf(Error);
-    scope.dispose();
-  });
-});
-
-describe("mountComponent onMount scheduling", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  function stubMicrotasks(): Array<() => void> {
-    const jobs: Array<() => void> = [];
-    vi.stubGlobal("queueMicrotask", (fn: () => void) => { jobs.push(fn); });
-    return jobs;
-  }
-
-  function lifecycleComp(onMount: () => void) {
-    return class extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      onMount() { onMount(); }
-      render() { return null; }
-    };
-  }
-
-  it("drains every component mounted in the same pass with a single microtask, in mount order", () => {
-    const jobs = stubMicrotasks();
-    const order: string[] = [];
-    const scope = new Scope();
-    mountComponent(lifecycleComp(() => order.push("a")), {}, scope);
-    mountComponent(lifecycleComp(() => order.push("b")), {}, scope);
-    expect(jobs).toHaveLength(1);
-    jobs.shift()?.();
-    expect(order).toEqual(["a", "b"]);
-  });
-
-  it("schedules a new microtask for components mounted after a drain", () => {
-    const jobs = stubMicrotasks();
-    const onMount = vi.fn();
-    const scope = new Scope();
-    mountComponent(lifecycleComp(onMount), {}, scope);
-    jobs.shift()?.();
-    mountComponent(lifecycleComp(onMount), {}, scope);
-    expect(jobs).toHaveLength(1);
-    jobs.shift()?.();
-    expect(onMount).toHaveBeenCalledTimes(2);
-  });
-
-  it("a throwing onMount does not stop the others and is rethrown on its own microtask", () => {
-    const jobs = stubMicrotasks();
-    const second = vi.fn();
-    const scope = new Scope();
-    mountComponent(lifecycleComp(() => { throw new Error("mount boom"); }), {}, scope);
-    mountComponent(lifecycleComp(second), {}, scope);
-    jobs.shift()?.();
-    expect(second).toHaveBeenCalledOnce();
-    expect(jobs).toHaveLength(1);
-    expect(() => { jobs.shift()?.(); }).toThrow("mount boom");
-  });
-
-  it("skips onMount for a component disposed before the drain", () => {
-    const jobs = stubMicrotasks();
-    const onMount = vi.fn();
-    const scope = new Scope();
-    mountComponent(lifecycleComp(onMount), {}, scope);
-    scope.dispose();
-    jobs.shift()?.();
-    expect(onMount).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/context.test.ts

@@ -1,128 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { runInScope, getCurrentScope } from "../context";
-import { Scope } from "../scope";
-
-describe("runInScope / getCurrentScope", () => {
-  it("getCurrentScope throws when called outside of a render context", () => {
-    expect(() => getCurrentScope()).toThrow("[PraxisJS]");
-  });
-
-  it("runInScope makes the scope available via getCurrentScope", () => {
-    const scope = new Scope();
-    let captured: Scope | null = null;
-    runInScope(scope, () => {
-      captured = getCurrentScope();
-    });
-    expect(captured).toBe(scope);
-  });
-
-  it("restores previous scope after runInScope exits", () => {
-    const outer = new Scope();
-    const inner = new Scope();
-    let innerCaptured: Scope | null = null;
-    let outerAfter: Scope | null = null;
-
-    runInScope(outer, () => {
-      runInScope(inner, () => {
-        innerCaptured = getCurrentScope();
-      });
-      outerAfter = getCurrentScope();
-    });
-
-    expect(innerCaptured).toBe(inner);
-    expect(outerAfter).toBe(outer);
-  });
-
-  it("restores null scope even when the callback throws", () => {
-    const scope = new Scope();
-    expect(() =>
-      runInScope(scope, () => {
-        throw new Error("boom");
-      }),
-    ).toThrow("boom");
-
-    expect(() => getCurrentScope()).toThrow("[PraxisJS]");
-  });
-
-  it("returns the callback's return value", () => {
-    const scope = new Scope();
-    const result = runInScope(scope, () => 42);
-    expect(result).toBe(42);
-  });
-
-  it("multiple sequential runInScope() calls at same nesting level do not leak state", () => {
-    const a = new Scope();
-    const b = new Scope();
-    let capturedA: Scope | null = null;
-    let capturedB: Scope | null = null;
-    runInScope(a, () => { capturedA = getCurrentScope(); });
-    runInScope(b, () => { capturedB = getCurrentScope(); });
-    expect(capturedA).toBe(a);
-    expect(capturedB).toBe(b);
-    // After both calls, we should be back outside any scope
-    expect(() => getCurrentScope()).toThrow("[PraxisJS]");
-  });
-
-  it("very deeply nested runInScope() (5+ levels) restores all scopes correctly", () => {
-    const scopes = Array.from({ length: 6 }, () => new Scope());
-    const captured: (Scope | null)[] = [];
-
-    runInScope(scopes[0], () => {
-      captured.push(getCurrentScope());
-      runInScope(scopes[1], () => {
-        captured.push(getCurrentScope());
-        runInScope(scopes[2], () => {
-          captured.push(getCurrentScope());
-          runInScope(scopes[3], () => {
-            captured.push(getCurrentScope());
-            runInScope(scopes[4], () => {
-              captured.push(getCurrentScope());
-              runInScope(scopes[5], () => {
-                captured.push(getCurrentScope());
-              });
-              captured.push(getCurrentScope()); // back to 4
-            });
-            captured.push(getCurrentScope()); // back to 3
-          });
-          captured.push(getCurrentScope()); // back to 2
-        });
-        captured.push(getCurrentScope()); // back to 1
-      });
-      captured.push(getCurrentScope()); // back to 0
-    });
-
-    expect(captured).toEqual([
-      scopes[0],
-      scopes[1],
-      scopes[2],
-      scopes[3],
-      scopes[4],
-      scopes[5],
-      scopes[4],
-      scopes[3],
-      scopes[2],
-      scopes[1],
-      scopes[0],
-    ]);
-    expect(() => getCurrentScope()).toThrow("[PraxisJS]");
-  });
-
-  it("exception at different nesting depths always restores outer scope", () => {
-    const outer = new Scope();
-    const middle = new Scope();
-
-    // Exception in middle scope restores outer
-    expect(() => {
-      runInScope(outer, () => {
-        runInScope(middle, () => {
-          throw new Error("middle throws");
-        });
-      });
-    }).toThrow("middle throws");
-
-    // outer is still active since the outer runInScope completed normally
-    // (exception propagated through it too), so after all we should be back to null
-    expect(() => getCurrentScope()).toThrow("[PraxisJS]");
-  });
-});