@adobe/data-lit 0.10.31 → 0.10.33

package/src/hooks/use-memo.test.ts

@@ -0,0 +1,66 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import { useMemo } from "./use-memo.js";
+import { createHost, render, unmount } from "./test-host.test-utils.js";
+
+describe("useMemo", () => {
+    it("returns the cached value while dependencies are equal", () => {
+        const host = createHost();
+        const calculate = vi.fn(() => ({}));
+        const first = render(host, () => useMemo(calculate, [1, "a"]));
+        expect(render(host, () => useMemo(calculate, [1, "a"]))).toBe(first);
+        expect(calculate).toHaveBeenCalledTimes(1);
+    });
+
+    it("recalculates when a dependency changes", () => {
+        const host = createHost();
+        render(host, () => useMemo(() => 1, [1]));
+        expect(render(host, () => useMemo(() => 2, [2]))).toBe(2);
+    });
+
+    it("calculates once with the default dependencies", () => {
+        const host = createHost();
+        const calculate = vi.fn(() => 1);
+        render(host, () => useMemo(calculate));
+        render(host, () => useMemo(calculate));
+        expect(calculate).toHaveBeenCalledTimes(1);
+    });
+
+    it.each([undefined, null, 0, false])("caches the falsy result %s", result => {
+        const host = createHost();
+        const calculate = vi.fn(() => result);
+        render(host, () => useMemo(calculate, []));
+        expect(render(host, () => useMemo(calculate, []))).toBe(result);
+        expect(calculate).toHaveBeenCalledTimes(1);
+    });
+
+    it("retries a calculation that threw", () => {
+        const host = createHost();
+        expect(() => render(host, () => useMemo(() => { throw new Error("failed"); }, []))).toThrow("failed");
+        expect(render(host, () => useMemo(() => 1, []))).toBe(1);
+    });
+
+    it("never requests a render", () => {
+        const host = createHost();
+        render(host, () => useMemo(() => 1, [1]));
+        render(host, () => useMemo(() => 2, [2]));
+        expect(host.requestUpdate).not.toHaveBeenCalled();
+    });
+
+    it("keeps independent memos per slot", () => {
+        const host = createHost();
+        const read = (n: number) => [useMemo(() => `a${n}`, [n]), useMemo(() => "b", [])];
+        render(host, () => read(1));
+        expect(render(host, () => read(2))).toEqual(["a2", "b"]);
+    });
+
+    it("recalculates after an unmount", () => {
+        const host = createHost();
+        const calculate = vi.fn(() => 1);
+        render(host, () => useMemo(calculate, []));
+        unmount(host);
+        render(host, () => useMemo(calculate, []));
+        expect(calculate).toHaveBeenCalledTimes(2);
+    });
+});

package/src/hooks/use-memo.ts

@@ -1,16 +1,21 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { useEffect } from "./use-effect.js";
-import { useState } from "./use-state.js";
+import { equalsShallow } from "@adobe/data/equals-shallow";
+import { Component_stack } from "./component/stack.js";
 
-export function useMemo<T>(calculateValue: () => T, dependencies: unknown[] = []): T {
-    const [state, setState] = useState<T | undefined>(undefined);
-    let currentValue = state;
-
-    useEffect(() => {
-        currentValue = calculateValue();
-        setState(currentValue);
-    }, dependencies);
+interface Memo<T> {
+    value: T;
+    dependencies: unknown[];
+}
 
-    return currentValue!;
+export function useMemo<T>(calculateValue: () => T, dependencies: unknown[] = []): T {
+    const component = Component_stack.active();
+    const hookIndex = component.hookIndex++;
+    const memo = component.hooks[hookIndex] as Memo<T> | undefined;
+    if (memo && equalsShallow(dependencies, memo.dependencies)) {
+        return memo.value;
+    }
+    const value = calculateValue();
+    component.hooks[hookIndex] = { value, dependencies } satisfies Memo<T>;
+    return value;
 }

package/src/hooks/use-observable-values.test.ts

@@ -0,0 +1,53 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import { Observe } from "@adobe/data/observe";
+import { useObservableValues } from "./use-observable-values.js";
+import { createHost, render, unmount } from "./test-host.test-utils.js";
+
+describe("useObservableValues", () => {
+    it("returns undefined until every source has emitted, then all latest values", () => {
+        const host = createHost();
+        const [name, setName] = Observe.createEvent<string>();
+        const [count, setCount] = Observe.createEvent<number>();
+        const factory = () => ({ name, count });
+
+        expect(render(host, () => useObservableValues(factory))).toBeUndefined();
+        setName("a");
+        expect(render(host, () => useObservableValues(factory))).toBeUndefined();
+        setCount(1);
+        expect(render(host, () => useObservableValues(factory))).toEqual({ name: "a", count: 1 });
+        setName("b");
+        expect(render(host, () => useObservableValues(factory))).toEqual({ name: "b", count: 1 });
+        unmount(host);
+    });
+
+    it("combines sources that emit synchronously in the first render", () => {
+        const host = createHost();
+        const factory = () => ({ a: Observe.fromConstant(1), b: Observe.fromConstant("x") });
+        expect(render(host, () => useObservableValues(factory))).toEqual({ a: 1, b: "x" });
+        unmount(host);
+    });
+
+    it("calls the factory again only when dependencies change", () => {
+        const host = createHost();
+        const factory = vi.fn(() => ({ a: Observe.fromConstant(1) }));
+        render(host, () => useObservableValues(factory, [1]));
+        render(host, () => useObservableValues(factory, [1]));
+        render(host, () => useObservableValues(factory, [2]));
+        expect(factory).toHaveBeenCalledTimes(2);
+        unmount(host);
+    });
+
+    it("unsubscribes from every source on unmount", () => {
+        const host = createHost();
+        const unsubscribed = vi.fn();
+        const tracked = <T,>(value: T): Observe<T> => observer => {
+            observer(value);
+            return unsubscribed;
+        };
+        render(host, () => useObservableValues(() => ({ a: tracked(1), b: tracked(2) })));
+        unmount(host);
+        expect(unsubscribed).toHaveBeenCalledTimes(2);
+    });
+});

package/src/hooks/use-observable.test.ts

@@ -0,0 +1,63 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import { Observe } from "@adobe/data/observe";
+import { useObservable } from "./use-observable.js";
+import { createHost, render, unmount } from "./test-host.test-utils.js";
+
+function source<T>() {
+    const [observe, notify] = Observe.createEvent<T>();
+    const subscribe = vi.fn(observe);
+    return { observable: subscribe as Observe<T>, notify, subscribe };
+}
+
+describe("useObservable", () => {
+    it("returns undefined until the source emits, then the latest value", () => {
+        const host = createHost();
+        const { observable, notify } = source<number>();
+        expect(render(host, () => useObservable(observable))).toBeUndefined();
+        notify(1);
+        notify(2);
+        expect(render(host, () => useObservable(observable))).toBe(2);
+    });
+
+    it("returns a value emitted synchronously on subscribe in the same render", () => {
+        const host = createHost();
+        const observable: Observe<number> = observer => { observer(7); return () => {}; };
+        expect(render(host, () => useObservable(observable))).toBe(7);
+    });
+
+    it("requests a render for every notification, including a repeated reference", () => {
+        const host = createHost();
+        const { observable, notify } = source<{ count: number }>();
+        const value = { count: 0 };
+        render(host, () => useObservable(observable));
+        notify(value);
+        value.count = 1;
+        notify(value);
+        expect(host.requestUpdate).toHaveBeenCalledTimes(2);
+        expect(render(host, () => useObservable(observable))).toBe(value);
+    });
+
+    it("subscribes once per source and resubscribes when the source changes", () => {
+        const host = createHost();
+        const a = source<number>();
+        const b = source<number>();
+        render(host, () => useObservable(a.observable));
+        render(host, () => useObservable(a.observable));
+        render(host, () => useObservable(b.observable));
+        a.notify(1);
+        expect(a.subscribe).toHaveBeenCalledTimes(1);
+        expect(b.subscribe).toHaveBeenCalledTimes(1);
+        expect(host.requestUpdate).not.toHaveBeenCalled();
+    });
+
+    it("unsubscribes on unmount", () => {
+        const host = createHost();
+        const { observable, notify } = source<number>();
+        render(host, () => useObservable(observable));
+        unmount(host);
+        notify(1);
+        expect(host.requestUpdate).not.toHaveBeenCalled();
+    });
+});

package/src/hooks/use-observable.ts

@@ -1,15 +1,20 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { useState } from "./use-state.js";
+import { Component_stack } from "./component/stack.js";
 import { useEffect } from "./use-effect.js";
+import { useRef } from "./use-ref.js";
 import { Observe } from "@adobe/data/observe";
 
+/**
+ * Subscribes to `observable` and returns its latest value. Every notification
+ * requests a render, including one that repeats the previous value or reference.
+ */
 export function useObservable<T>(observable: Observe<T>): T | undefined {
-    let [value, setValue] = useState<T | undefined>(undefined);
-    useEffect(() => {
-        return observable(newValue => {
-            setValue(value = newValue);
-        });
-    }, [observable]);
-    return value;
+    const component = Component_stack.active();
+    const latest = useRef<T | undefined>(undefined);
+    useEffect(() => observable(value => {
+        latest.current = value;
+        component.requestUpdate();
+    }), [observable]);
+    return latest.current;
 }

package/src/hooks/use-pointer-observe.test.ts

@@ -0,0 +1,59 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import type { Vec2 } from "@adobe/data/math";
+import { usePointerObserve } from "./use-pointer-observe.js";
+import { createHost, render, unmount, type TestHost } from "./test-host.test-utils.js";
+
+function placeAt(host: TestHost, left: number, top: number) {
+    host.getBoundingClientRect = () => ({ left, top, x: left, y: top, width: 100, height: 100, right: left + 100, bottom: top + 100, toJSON() {} });
+}
+
+const pointerMoveOver = (host: TestHost, clientX: number, clientY: number) =>
+    host.dispatchEvent(new PointerEvent("pointermove", { clientX, clientY }));
+
+describe("usePointerObserve", () => {
+    it("emits pointer positions relative to the host", () => {
+        const host = createHost();
+        placeAt(host, 10, 20);
+        const positions: Vec2[] = [];
+        render(host, () => usePointerObserve([]))(position => positions.push(position));
+
+        pointerMoveOver(host, 15, 30);
+        pointerMoveOver(host, 50, 60);
+        expect(positions).toEqual([[5, 10], [40, 40]]);
+        unmount(host);
+    });
+
+    it("returns the same stream while dependencies are equal", () => {
+        const host = createHost();
+        const first = render(host, () => usePointerObserve([1]));
+        expect(render(host, () => usePointerObserve([1]))).toBe(first);
+        expect(render(host, () => usePointerObserve([2]))).not.toBe(first);
+        unmount(host);
+    });
+
+    it("delivers to every subscriber", () => {
+        const host = createHost();
+        placeAt(host, 0, 0);
+        const observe = render(host, () => usePointerObserve([]));
+        const a: Vec2[] = [];
+        const b: Vec2[] = [];
+        observe(position => a.push(position));
+        observe(position => b.push(position));
+        pointerMoveOver(host, 1, 2);
+        expect(a).toEqual([[1, 2]]);
+        expect(b).toEqual([[1, 2]]);
+        unmount(host);
+    });
+
+    it("stops listening on unmount", () => {
+        const host = createHost();
+        placeAt(host, 0, 0);
+        const positions: Vec2[] = [];
+        render(host, () => usePointerObserve([]))(position => positions.push(position));
+        unmount(host);
+        pointerMoveOver(host, 1, 1);
+        expect(positions).toEqual([]);
+    });
+});

package/src/hooks/use-ref.test.ts

@@ -0,0 +1,50 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { useRef } from "./use-ref.js";
+import { createHost, render, unmount } from "./test-host.test-utils.js";
+
+describe("useRef", () => {
+    it("returns the same ref across renders and keeps its mutations", () => {
+        const host = createHost();
+        const ref = render(host, () => useRef(1));
+        ref.current = 2;
+
+        const next = render(host, () => useRef(1));
+        expect(next).toBe(ref);
+        expect(next.current).toBe(2);
+    });
+
+    it("ignores the initial value after the first render", () => {
+        const host = createHost();
+        render(host, () => useRef("first"));
+        expect(render(host, () => useRef("second")).current).toBe("first");
+    });
+
+    it("stores a function as a value", () => {
+        const host = createHost();
+        const callback = () => 1;
+        expect(render(host, () => useRef(callback)).current).toBe(callback);
+    });
+
+    it("does not request a render when current changes", () => {
+        const host = createHost();
+        render(host, () => useRef(0)).current = 1;
+        expect(host.requestUpdate).not.toHaveBeenCalled();
+    });
+
+    it("keeps independent refs per slot and per host", () => {
+        const host = createHost();
+        const other = createHost();
+        const [a, b] = render(host, () => [useRef(0), useRef(0)]);
+        const c = render(other, () => useRef(0));
+        expect(new Set([a, b, c]).size).toBe(3);
+    });
+
+    it("starts from the initial value after an unmount", () => {
+        const host = createHost();
+        render(host, () => useRef(0)).current = 5;
+        unmount(host);
+        expect(render(host, () => useRef(0)).current).toBe(0);
+    });
+});

package/src/hooks/use-ref.ts

@@ -1,8 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { useState } from "./use-state.js";
+import { Component_stack } from "./component/stack.js";
 
 export function useRef<T>(initialValue: T): { current: T } {
-    const [state] = useState({ current: initialValue });
-    return state;
+    const component = Component_stack.active();
+    const hookIndex = component.hookIndex++;
+    return component.hooks[hookIndex] ??= { current: initialValue };
 }

package/src/hooks/use-updated.test.ts

@@ -0,0 +1,98 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { LitElement, html } from "lit";
+import { attachDecorator } from "./attach-decorator.js";
+import { withHooks } from "./with-hooks.js";
+import { useUpdated, type UpdateEventHost } from "./use-updated.js";
+import { createHost, render } from "./test-host.test-utils.js";
+
+class UpdatedProbe extends LitElement {
+    listeners: (() => void)[] = [];
+    dependency = 0;
+    originalUpdated = vi.fn();
+
+    constructor() {
+        super();
+        attachDecorator(this, "render", withHooks);
+    }
+
+    override updated() {
+        this.originalUpdated();
+    }
+
+    render() {
+        for (const listener of this.listeners) {
+            useUpdated(listener, [this.dependency]);
+        }
+        return html``;
+    }
+}
+customElements.define("use-updated-probe", UpdatedProbe);
+
+async function mount(...listeners: (() => void)[]) {
+    const element = document.createElement("use-updated-probe") as UpdatedProbe;
+    element.listeners = listeners;
+    document.body.append(element);
+    await element.updateComplete;
+    return element;
+}
+
+afterEach(async () => {
+    document.body.replaceChildren();
+    await Promise.resolve();
+});
+
+describe("useUpdated", () => {
+    it("calls the listener after every update, after the element's own updated", async () => {
+        const calls: string[] = [];
+        const element = await mount(() => calls.push("listener"));
+        expect(calls).toEqual(["listener"]);
+        element.originalUpdated.mockImplementation(() => calls.push("updated"));
+        calls.length = 0;
+
+        element.requestUpdate();
+        await element.updateComplete;
+        expect(calls).toEqual(["updated", "listener"]);
+    });
+
+    it("calls multiple listeners in registration order through one wrapper", async () => {
+        const calls: string[] = [];
+        const element = await mount(() => calls.push("a"), () => calls.push("b"));
+        calls.length = 0;
+        element.requestUpdate();
+        await element.updateComplete;
+        expect(calls).toEqual(["a", "b"]);
+        expect(element.originalUpdated).toHaveBeenCalledTimes(2);
+    });
+
+    it("replaces the listener when dependencies change", async () => {
+        const first = vi.fn();
+        const second = vi.fn();
+        const element = await mount(first);
+        element.listeners = [second];
+        element.dependency = 1;
+        element.requestUpdate();
+        await element.updateComplete;
+        first.mockClear();
+        second.mockClear();
+
+        element.requestUpdate();
+        await element.updateComplete;
+        expect(first).not.toHaveBeenCalled();
+        expect(second).toHaveBeenCalledTimes(1);
+    });
+
+    it("removes the listener on unmount", async () => {
+        const element = await mount(() => {});
+        const listeners = (element as unknown as UpdateEventHost).updateListeners;
+        expect(listeners.size).toBe(1);
+        element.remove();
+        await Promise.resolve();
+        expect(listeners.size).toBe(0);
+    });
+
+    it("throws for a host without an updated method", () => {
+        expect(() => render(createHost(), () => useUpdated(() => {}))).toThrow("does not have an updated method");
+    });
+});

package/src/hooks/use-window-event.test.ts

@@ -0,0 +1,61 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import { useWindowEvent } from "./use-window-event.js";
+import { createHost, render, unmount } from "./test-host.test-utils.js";
+
+describe("useWindowEvent", () => {
+    it("listens on window with the callback from the factory", () => {
+        const host = createHost();
+        const listener = vi.fn();
+        render(host, () => useWindowEvent("resize", () => listener, []));
+        window.dispatchEvent(new Event("resize"));
+        expect(listener).toHaveBeenCalledTimes(1);
+        unmount(host);
+    });
+
+    it("keeps the first callback while factory dependencies are equal", () => {
+        const host = createHost();
+        const first = vi.fn();
+        const second = vi.fn();
+        render(host, () => useWindowEvent("resize", () => first, [1]));
+        render(host, () => useWindowEvent("resize", () => second, [1]));
+        window.dispatchEvent(new Event("resize"));
+        expect(first).toHaveBeenCalledTimes(1);
+        expect(second).not.toHaveBeenCalled();
+        unmount(host);
+    });
+
+    it("replaces the callback when factory dependencies change", () => {
+        const host = createHost();
+        const first = vi.fn();
+        const second = vi.fn();
+        render(host, () => useWindowEvent("resize", () => first, [1]));
+        render(host, () => useWindowEvent("resize", () => second, [2]));
+        window.dispatchEvent(new Event("resize"));
+        expect(first).not.toHaveBeenCalled();
+        expect(second).toHaveBeenCalledTimes(1);
+        unmount(host);
+    });
+
+    it("moves its listener when the event name changes", () => {
+        const host = createHost();
+        const received: string[] = [];
+        const listener = (event: Event) => received.push(event.type);
+        render(host, () => useWindowEvent("resize", () => listener, []));
+        render(host, () => useWindowEvent("scroll", () => listener, []));
+        window.dispatchEvent(new Event("resize"));
+        window.dispatchEvent(new Event("scroll"));
+        expect(received).toEqual(["scroll"]);
+        unmount(host);
+    });
+
+    it("removes its listener on unmount", () => {
+        const host = createHost();
+        const listener = vi.fn();
+        render(host, () => useWindowEvent("resize", () => listener, []));
+        unmount(host);
+        window.dispatchEvent(new Event("resize"));
+        expect(listener).not.toHaveBeenCalled();
+    });
+});

package/src/hooks/use-window-event.ts

@@ -12,5 +12,5 @@ export function useWindowEvent<K extends keyof WindowEventMap>(
     useEffect(() => {
         window.addEventListener(event, callback);
         return () => window.removeEventListener(event, callback);
-    }, [callback]);
+    }, [event, callback]);
 }

package/src/hooks/with-hooks.test.ts

@@ -0,0 +1,45 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import type { ReactiveController } from "lit";
+import { Component_stack } from "./component/stack.js";
+import { withHooks } from "./with-hooks.js";
+import { createHost } from "./test-host.test-utils.js";
+
+function wrap<Args extends unknown[], Return>(method: (...args: Args) => Return) {
+    return withHooks({}, "render", { value: method }).value!;
+}
+
+describe("withHooks", () => {
+    it("makes the host active during the call and forwards arguments and return value", () => {
+        const host = createHost();
+        const render = wrap(function (this: unknown, a: number, b: number) {
+            expect(Component_stack.active()).toBe(this);
+            return a + b;
+        });
+        expect(render.call(host, 1, 2)).toBe(3);
+        expect(Component_stack.active()).toBeUndefined();
+    });
+
+    it("resets the hook cursor before each call", () => {
+        const host = createHost();
+        host.hookIndex = 4;
+        const render = wrap(() => Component_stack.active().hookIndex);
+        expect(render.call(host)).toBe(0);
+    });
+
+    it("restores the stack when the method throws", () => {
+        const host = createHost();
+        const render = wrap(() => { throw new Error("render failed"); });
+        expect(() => render.call(host)).toThrow("render failed");
+        expect(Component_stack.active()).toBeUndefined();
+    });
+
+    it("installs the lifecycle controller once on a reactive host", () => {
+        const host = Object.assign(createHost(), { addController: vi.fn((_: ReactiveController) => {}) });
+        const render = wrap(() => {});
+        render.call(host);
+        render.call(host);
+        expect(host.addController).toHaveBeenCalledTimes(1);
+    });
+});

package/src/index.test.ts

@@ -0,0 +1,26 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import * as dataLit from "./index.js";
+
+describe("@adobe/data-lit public exports", () => {
+    it.each([
+        "useState", "useEffect", "useConnected", "useMemo", "useRef", "useObservable", "useObservableValues",
+        "useWindowEvent", "useResizeObserver", "useDebounce", "useElement", "useUpdated", "usePointerObserve",
+        "useDraggable", "useDragObserve", "useDragGenerator", "useDragTransaction",
+        "withHooks", "attachDecorator", "installHooksController",
+        "ApplicationHost", "ApplicationElement", "DatabaseElement",
+        "applyDecorator", "applyServiceDecorators", "requireService",
+    ])("exports the function %s", name => {
+        expect(typeof (dataLit as Record<string, unknown>)[name]).toBe("function");
+    });
+
+    it("exports the component stack and the Template helpers", () => {
+        expect(typeof dataLit.Component_stack.active).toBe("function");
+        expect(typeof dataLit.Template.from).toBe("function");
+    });
+
+    it("registers the application-host element", () => {
+        expect(customElements.get("application-host")).toBe(dataLit.ApplicationHost);
+    });
+});

package/src/public-types.type-test.ts

@@ -0,0 +1,17 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * Compile-time tests for public element and hook declarations.
+ */
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { ApplicationHost } from "./elements/application-host.js";
+import { useElement } from "./hooks/use-element.js";
+
+const _hostTag = (): ApplicationHost => document.createElement("application-host");
+
+const _tagSelector = (): HTMLButtonElement | null => useElement("button");
+const _cssSelector = (): HTMLElement | null => useElement(".target");
+const _typedCssSelector = (): HTMLInputElement | null => useElement<HTMLInputElement>("input.name");
+const _component = (): HTMLElement => useElement();

package/tsconfig.json

@@ -7,5 +7,6 @@
     "types": []
   },
   "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.test-utils.ts", "src/**/*.type-test.ts"],
   "references": []
 }

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  // Type-checks all of src, including the runtime and compile-time tests the build excludes.
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false,
+    "noEmit": true
+  },
+  "exclude": []
+}