@adobe/data 0.1.3 → 0.2.0

package/src/internal/typed-array/typed-array.ts

@@ -0,0 +1,25 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+export type TypedArray =
+    Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array
+;

package/src/is-data.ts

@@ -0,0 +1,47 @@
+import { Assert } from "./types/assert.js";
+
+type Primitive = string | number | boolean | null;
+
+/** invariant type-equality check (handles `readonly` correctly) */
+type EqualReadonly<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends
+    (<T>() => T extends Y ? 1 : 2)
+      ? (<T>() => T extends Y ? 1 : 2) extends
+          (<T>() => T extends X ? 1 : 2)
+          ? true
+          : false
+      : false;
+
+/** are *all* own props already `readonly`?  */
+type IsFullyReadonly<T> = EqualReadonly<T, Readonly<T>>;
+
+export type IsData<T> =
+  // primitives
+  [T] extends [Primitive]
+    ? true
+    // **readonly** arrays whose items are Data
+    : T extends ReadonlyArray<infer U>
+      ? EqualReadonly<T, ReadonlyArray<U>> extends true
+        ? IsData<U>
+        : false
+      // plain objects: 1) fully readonly, 2) every value is Data
+      : T extends object
+        ? IsFullyReadonly<T> extends true
+          ? { [K in keyof T]-?: IsData<T[K]> }[keyof T] extends false
+            ? false
+            : true
+          : false
+        : false;
+
+// Compile time tests
+
+interface Foo {
+  x: number;          // mutable  ❌
+}
+
+interface Bar {
+  readonly x: number; // readonly ✔️
+}
+
+type IsFooData = Assert<EqualReadonly<IsData<Foo>, false>>; // false
+type IsBarData = Assert<EqualReadonly<IsData<Bar>, true>>; // true

package/src/lit/decorators/apply-decorator.ts

@@ -0,0 +1,24 @@
+export function applyDecorator(
+    target: any,
+    propertyKey: string,
+    decorator: (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor
+) {
+    // Get the prototype chain
+    let currentPrototype = target;
+    let descriptor: PropertyDescriptor | undefined;
+
+    // Walk up the prototype chain until we find the property
+    while (currentPrototype && !descriptor) {
+        descriptor = Object.getOwnPropertyDescriptor(currentPrototype, propertyKey);
+        if (!descriptor) {
+            currentPrototype = Object.getPrototypeOf(currentPrototype);
+        }
+    }
+
+    if (!descriptor) {
+        throw new Error(`Property ${propertyKey} not found in prototype chain`);
+    }
+
+    const newDescriptor = decorator(target, propertyKey, descriptor);
+    Object.defineProperty(target, propertyKey, newDescriptor);
+} 

package/src/lit/decorators/apply-service-decorators.ts

@@ -0,0 +1,13 @@
+import { withHooks } from "../hooks/with-hooks.js";
+import { requireService } from "./require-service.js";
+import { TemplateResult } from "lit";
+
+export function applyServiceDecorators(target: any) {
+    const prototype = Object.getPrototypeOf(target);
+    const originalRender = prototype.render;
+    const withService = requireService()(target, 'render', {
+        value: originalRender
+    });
+    const withHooksAndService = withHooks(target, 'render', withService);
+    target.render = withHooksAndService.value as () => TemplateResult | null;
+} 

package/src/lit/decorators/index.ts

@@ -0,0 +1,24 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export * from "./apply-decorator.js";
+export * from "./apply-service-decorators.js";
+export * from "./require-service.js";

package/src/lit/decorators/require-service.ts

@@ -0,0 +1,19 @@
+
+export function requireService() {
+    return function (
+        target: any,
+        propertyKey: string,
+        descriptor: PropertyDescriptor
+    ) {
+        const originalRender = descriptor.value;
+
+        descriptor.value = function (this: any) {
+            if (!this.service) {
+                return null;
+            }
+            return originalRender.call(this);
+        };
+
+        return descriptor;
+    };
+} 

package/src/lit/elements/index.ts

@@ -0,0 +1,3 @@
+export * from "./service-application.js";
+export * from "./service-context.js";
+export * from "./service-element.js";

package/src/lit/elements/service-application.ts

@@ -0,0 +1,26 @@
+import { LitElement } from "lit";
+import { property } from "lit/decorators.js";
+import { provide } from "@lit/context";
+import { serviceContext } from "./service-context.js";
+import { Service } from "../../service/index.js";
+import { applyServiceDecorators } from "../decorators/apply-service-decorators.js";
+
+export abstract class ServiceApplication<S extends Service> extends LitElement {
+
+    @provide({context: serviceContext})
+    @property({type: Object})
+    protected service!: S;
+
+    protected abstract createService(): Promise<S>;
+
+    override async connectedCallback() {
+        super.connectedCallback();
+        applyServiceDecorators(this);
+        this.service = await this.createService();
+    }
+
+    override disconnectedCallback() {
+        super.disconnectedCallback();
+        this.service?.dispose?.();
+    }
+}

package/src/lit/elements/service-context.ts

@@ -0,0 +1,3 @@
+import { createContext } from "@lit/context";
+
+export const serviceContext = createContext(Symbol("service"));

package/src/lit/elements/service-element.ts

@@ -0,0 +1,18 @@
+import { LitElement } from "lit";
+import { serviceContext } from "./service-context.js";
+import { property } from "lit/decorators.js";
+import { Service } from "../../service/index.js";
+import { consume } from "@lit/context";
+import { applyServiceDecorators } from "../decorators/apply-service-decorators.js";
+
+export class ServiceElement<S extends Service> extends LitElement {
+
+    @consume({context: serviceContext})
+    @property({type: Object})
+    protected service!: S;
+
+    override connectedCallback() {
+        super.connectedCallback();
+        applyServiceDecorators(this);
+    }
+}

package/src/lit/hooks/component/component.ts

@@ -0,0 +1,10 @@
+
+export interface Component extends EventTarget {
+    /**
+     * Is this component active and connected to the containing dom?
+     */
+    readonly isConnected: boolean;
+    hookIndex: number
+    hooks: any[]
+    requestUpdate(): void
+}

package/src/lit/hooks/component/stack.ts

@@ -0,0 +1,17 @@
+import type { Component } from "./component.js";
+
+const activeComponentStack: Component[] = [];
+export const Component_stack = {
+    active(): Component {
+        return activeComponentStack[activeComponentStack.length - 1]!;
+    },
+    push(component: Component) {
+        component.hookIndex = 0;
+        component.hooks ??= [];
+        activeComponentStack.push(component)
+    },
+    pop() {
+        activeComponentStack.pop()
+    }
+} as const;
+

package/src/lit/hooks/index.ts

@@ -0,0 +1,13 @@
+export * from "./component/component.js";
+export * from "./component/stack.js";
+export * from "./use-state.js";
+export * from "./use-effect.js";
+export * from "./use-connected.js";
+export * from "./use-memo.js";
+export * from "./use-ref.js";
+export * from "./use-observable-values.js";
+export * from "./use-observable.js";
+export * from "./use-window-event.js";
+export * from "./use-resize-observer.js";
+export * from "./use-element.js";
+export * from "./with-hooks.js";

package/src/lit/hooks/use-connected.ts

@@ -0,0 +1,39 @@
+import type { EffectCallback } from "./use-effect.js";
+import { useEffect } from "./use-effect.js";
+import { Component_stack } from "./component/stack.js";
+
+export function useConnected(callback: EffectCallback, dependencies?: unknown[]) {
+    const component = Component_stack.active();
+
+    let disconnect: (() => void) | void;
+    function onConnect() {
+        if (!disconnect) {
+            disconnect = callback();
+        }
+    }
+
+    function onDisconnect() {
+        if (disconnect) {
+            disconnect?.();
+            disconnect = undefined;
+        }
+    }
+
+    //  TODO
+    if (component.isConnected) {
+        onConnect();
+    }
+
+    useEffect(() => {
+        component.addEventListener("connected", onConnect);
+        component.addEventListener("disconnected", onDisconnect);
+
+        return () => {
+            component.removeEventListener("connected", onConnect);
+            component.removeEventListener("disconnected", onDisconnect);
+
+            onDisconnect();
+        }
+
+    }, dependencies);
+}

package/src/lit/hooks/use-effect.ts

@@ -0,0 +1,17 @@
+import { equalsShallow } from "../../equals-shallow.js";
+import type { Component } from "./component/component.js"
+import { Component_stack } from "./component/stack.js";
+
+export type EffectCallback = () => (void | (() => void))
+type EffectHookState = { dispose?: () => void, dependencies: unknown[] };
+
+export function useEffect<T extends Component>(callback: EffectCallback, dependencies: unknown[] = []) {
+    const component = Component_stack.active() as T;
+    const hookIndex = component.hookIndex++;
+    const oldHookState = component.hooks[hookIndex] as EffectHookState | undefined;
+    let rerunEffect = !oldHookState || !equalsShallow(dependencies, oldHookState.dependencies);
+    if (rerunEffect) {
+        oldHookState?.dispose?.();
+        component.hooks[hookIndex] = { dispose: callback.call(component) ?? undefined, dependencies };
+    }
+}

package/src/lit/hooks/use-element.ts

@@ -0,0 +1,8 @@
+import { Component_stack } from "./component/stack.js";
+
+/**
+ * Hook that returns the currently active component.
+ */
+export function useElement<T = HTMLElement>(): T {
+    return Component_stack.active() as unknown as T;
+}

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

@@ -0,0 +1,14 @@
+import { useEffect } from "./use-effect.js";
+import { useState } from "./use-state.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);
+
+    return currentValue!;
+}

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

@@ -0,0 +1,9 @@
+import { fromProperties, Observe } from "../../observe/index.js";
+import { useMemo } from "./use-memo.js";
+import { useObservable } from "./use-observable.js";
+import { Data } from "../../index.js";
+
+export function useObservableValues<T extends Record<string,Observe<Data>>>(factory: () => T, deps: unknown[] = []): { [K in keyof T]: T[K] extends Observe<infer U> ? U : never } | undefined {
+    const observable = useMemo(() => fromProperties(factory()), deps);
+    return useObservable(observable);
+}

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

@@ -0,0 +1,13 @@
+import { useState } from "./use-state.js";
+import { useEffect } from "./use-effect.js";
+import { Observe } from "../../observe/index.js";
+
+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;
+}

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

@@ -0,0 +1,6 @@
+import { useState } from "./use-state.js";
+
+export function useRef<T>(value: T): { value: T } {
+    const [state] = useState({ value });
+    return state;
+}

package/src/lit/hooks/use-resize-observer.ts

@@ -0,0 +1,27 @@
+import { useEffect } from "./use-effect.js";
+import { useElement } from "./use-element.js";
+
+export interface ResizeInfo {
+    width: number;
+    height: number;
+    entry: ResizeObserverEntry;
+}
+
+/**
+ * Hook to observe element resizes. Calls callback with width, height, and the original entry
+ * when the element's size changes.
+ */
+export function useResizeObserver(onResize: (info: ResizeInfo) => void) {
+    const element = useElement();
+    
+    useEffect(() => {
+        const observer = new ResizeObserver(entries => {
+            for (const entry of entries) {
+                const { width, height } = entry.contentRect;
+                onResize({ width, height, entry });
+            }
+        });
+        observer.observe(element);
+        return () => observer.disconnect();
+    }, [element, onResize]);
+} 

package/src/lit/hooks/use-state.ts

@@ -0,0 +1,17 @@
+import { Component_stack } from "./component/stack.js";
+
+export function useState<T>(initializer: () => T): [T, (value: T) => void]
+export function useState<T>(initialValue: T): [T, (value: T) => void]
+export function useState<T>(initial: () => T) {
+    const component = Component_stack.active();
+    const hookIndex = component.hookIndex++;
+    const value = component.hooks[hookIndex] ??= (typeof initial === "function" ? initial() : initial);
+    return [
+        value,
+        (newValue: T) => {
+            component.hooks[hookIndex] = newValue;
+            component.requestUpdate();
+        }
+    ];
+
+}

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

@@ -0,0 +1,14 @@
+import { useEffect } from "./use-effect.js";
+import { useMemo } from "./use-memo.js";
+
+export function useWindowEvent<K extends keyof WindowEventMap>(
+    event: K,
+    callbackFactory: () => (e: WindowEventMap[K]) => void,
+    deps: any[] = []
+) {
+    const callback = useMemo(callbackFactory, deps);
+    useEffect(() => {
+        window.addEventListener(event, callback);
+        return () => window.removeEventListener(event, callback);
+    }, [callback]);
+}

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

@@ -0,0 +1,20 @@
+import type { Component } from "./component/component.js";
+import { Component_stack } from "./component/stack.js";
+
+export function withHooks<This extends Component, Args extends any[], Return>(
+    target: object,
+    propertyKey: string,
+    descriptor: TypedPropertyDescriptor<(this: This, ...args: Args) => Return>
+): TypedPropertyDescriptor<(this: This, ...args: Args) => Return> {
+    const originalMethod = descriptor.value!;
+    descriptor.value = function(this: This, ...args: Args): Return {
+        Component_stack.push(this);
+        try {
+            return originalMethod.apply(this, args);
+        }
+        finally {
+            Component_stack.pop();
+        }
+    }
+    return descriptor;
+}

package/src/lit/index.ts

@@ -0,0 +1,3 @@
+export * from "./hooks/index.js";
+export * from "./elements/index.js";
+export * from "./decorators/index.js";

package/src/mutable-clone.ts

@@ -0,0 +1,29 @@
+
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P] extends object ? Mutable<T[P]> : T[P];
+};
+
+export const mutableClone = <T extends object>(obj: T): Mutable<T> => {
+    return structuredClone(obj) as Mutable<T>;
+};

package/{core/data.test.js → src/normalize.test.ts}

@@ -19,30 +19,30 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.*/
-import { normalize } from "./data.js";
+import { normalize } from "./normalize.js";
 import { describe, expect, it } from "vitest";
+
 describe("Data.normalize", () => {
-    it("should sort object keys alphabetically", () => {
-        expect(normalize({ b: 1, a: 2, c: null })).toEqual({
-            a: 2,
-            b: 1,
-            c: null,
-        });
-        expect(normalize([{ A: [], b: 1, a: 2 }])).toEqual([{ a: 2, A: [], b: 1 }]);
-        expect(normalize([[{ b: 1, a: 2 }]])).toEqual([[{ a: 2, b: 1 }]]);
-        expect(normalize({ z: [[{ b: 1, a: 2 }]], q: 10 })).toEqual({
-            q: 10,
-            z: [[{ a: 2, b: 1 }]],
-        });
+  it("should sort object keys alphabetically", () => {
+    expect(normalize({ b: 1, a: 2, c: null })).toEqual({
+      a: 2,
+      b: 1,
+      c: null,
+    });
+    expect(normalize([{ A: [], b: 1, a: 2 }])).toEqual([{ a: 2, A: [], b: 1 }]);
+    expect(normalize([[{ b: 1, a: 2 }]])).toEqual([[{ a: 2, b: 1 }]]);
+    expect(normalize({ z: [[{ b: 1, a: 2 }]], q: 10 })).toEqual({
+      q: 10,
+      z: [[{ a: 2, b: 1 }]],
     });
-    it("should remove undefined values", () => {
-        expect(normalize({ b: 1, a: 2, value: undefined })).toEqual({
-            a: 2,
-            b: 1,
-        });
-        expect(normalize([{ b: 1, a: 2, value: undefined }])).toEqual([
-            { a: 2, b: 1 },
-        ]);
+  });
+  it("should remove undefined values", () => {
+    expect(normalize({ b: 1, a: 2, value: undefined })).toEqual({
+      a: 2,
+      b: 1,
     });
+    expect(normalize([{ b: 1, a: 2, value: undefined }])).toEqual([
+      { a: 2, b: 1 },
+    ]);
+  });
 });
-//# sourceMappingURL=data.test.js.map

package/src/normalize.ts

@@ -0,0 +1,37 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+
+export function normalize<D>(d: D): D {
+  //  we could structured clone but let's explicitly shed any keys with undefined values.
+  return JSON.parse(JSON.stringify(d), (_key: string, value: unknown) => {
+    if (value && !Array.isArray(value) && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).sort(([a], [b]) =>
+          //  not using String.localeCompare
+          //  we want this consistent no matter locale
+          a < b ? -1 : a > b ? 1 : 0
+        )
+      );
+    }
+    return value;
+  });
+}

package/src/observe/create-observable-event.ts

@@ -0,0 +1,47 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { Notify, Observe } from "./types.js";
+
+/**
+ * Creates a new observe function that will serve as an event stream and a notify function
+ * which can be used to notify all observers of a new value.
+ * Note that Observers will only see values when notify is called.
+ */
+export function createObservableEvent<T>(): [
+  Observe<T>,
+  (value: T) => void,
+] {
+  const observers = new Set<Notify<T>>();
+  return [
+    (observer) => {
+      observers.add(observer);
+      return () => {
+        observers.delete(observer);
+      };
+    },
+    (value) => {
+      for (const observer of observers) {
+        observer(value);
+      }
+    },
+  ];
+}