velocious 1.0.396 → 1.0.397

package/build/src/frontend-models/use-updated-event.d.ts

@@ -0,0 +1,20 @@
+/**
+ * React hook for frontend-model update events. Pass a model class for class-level
+ * update events, or a model / model array for instance-level update events.
+ * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.
+ * @param {FrontendModelUpdateEventCallback} callback - Event callback.
+ * @param {UseUpdatedEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useUpdatedEvent(modelClassOrModels: FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined, callback: FrontendModelUpdateEventCallback, options?: UseUpdatedEventOptions): void;
+export type FrontendModelClass = typeof import("./base.js").default;
+export type FrontendModelInstance = import("./base.js").default;
+export type FrontendModelClassUpdateEventPayload = import("./use-model-class-event.js").FrontendModelCreateUpdateEventPayload;
+export type FrontendModelInstanceUpdateEventPayload = {
+    id: string;
+    model: FrontendModelInstance;
+};
+export type FrontendModelUpdateEventPayload = FrontendModelClassUpdateEventPayload | FrontendModelInstanceUpdateEventPayload;
+export type UseUpdatedEventOptions = import("./use-model-class-event.js").UseModelClassEventOptions;
+export type FrontendModelUpdateEventCallback = (payload: FrontendModelUpdateEventPayload) => void;
+//# sourceMappingURL=use-updated-event.d.ts.map

package/build/src/frontend-models/use-updated-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-updated-event.d.ts","sourceRoot":"","sources":["../../../src/frontend-models/use-updated-event.js"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,4DALW,kBAAkB,GAAG,qBAAqB,GAAG,qBAAqB,EAAE,GAAG,IAAI,GAAG,SAAS,YACvF,gCAAgC,YAChC,sBAAsB,GACpB,IAAI,CAahB;iCAvCa,cAAc,WAAW,EAAE,OAAO;oCAClC,OAAO,WAAW,EAAE,OAAO;mDAC3B,OAAO,4BAA4B,EAAE,qCAAqC;sDAC1E;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,qBAAqB,CAAA;CAAC;8CAC1C,oCAAoC,GAAG,uCAAuC;qCAC9E,OAAO,4BAA4B,EAAE,yBAAyB;+CAC9D,CAAC,OAAO,EAAE,+BAA+B,KAAK,IAAI"}

package/build/src/frontend-models/use-updated-event.js

@@ -0,0 +1,101 @@
+// @ts-check
+import debounceFunction from "debounce";
+import { useEffect, useMemo, useRef } from "react";
+import clearPendingDebouncedCallback from "./clear-pending-debounced-callback.js";
+import { modelsDependencyKey, modelsFromInput } from "./event-hook-models.js";
+import useModelClassEvent from "./use-model-class-event.js";
+/** @typedef {typeof import("./base.js").default} FrontendModelClass */
+/** @typedef {import("./base.js").default} FrontendModelInstance */
+/** @typedef {import("./use-model-class-event.js").FrontendModelCreateUpdateEventPayload} FrontendModelClassUpdateEventPayload */
+/** @typedef {{id: string, model: FrontendModelInstance}} FrontendModelInstanceUpdateEventPayload */
+/** @typedef {FrontendModelClassUpdateEventPayload | FrontendModelInstanceUpdateEventPayload} FrontendModelUpdateEventPayload */
+/** @typedef {import("./use-model-class-event.js").UseModelClassEventOptions} UseUpdatedEventOptions */
+/** @typedef {(payload: FrontendModelUpdateEventPayload) => void} FrontendModelUpdateEventCallback */
+/**
+ * @param {Record<string, unknown>} restOptions - Unknown options object.
+ * @returns {void}
+ */
+function assertNoUnknownOptions(restOptions) {
+    const unknownOptionNames = Object.keys(restOptions);
+    if (unknownOptionNames.length > 0) {
+        throw new Error(`Unknown options given to useUpdatedEvent: ${unknownOptionNames.join(", ")}`);
+    }
+}
+/**
+ * React hook for frontend-model update events. Pass a model class for class-level
+ * update events, or a model / model array for instance-level update events.
+ * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.
+ * @param {FrontendModelUpdateEventCallback} callback - Event callback.
+ * @param {UseUpdatedEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useUpdatedEvent(modelClassOrModels, callback, options = {}) {
+    const { active = true, debounce = false, onConnected, ...restOptions } = options;
+    assertNoUnknownOptions(restOptions);
+    const classModel = typeof modelClassOrModels === "function" ? modelClassOrModels : null;
+    const instanceModels = typeof modelClassOrModels === "function" ? null : modelClassOrModels;
+    useModelClassEvent(classModel, "update", (payload) => {
+        callback(/** @type {FrontendModelClassUpdateEventPayload} */ (payload));
+    }, { active: active && Boolean(classModel), debounce, onConnected });
+    useInstanceUpdatedEvent(instanceModels, callback, { active: active && !classModel, debounce, onConnected });
+}
+/**
+ * @param {FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelOrModels - Model or models.
+ * @param {FrontendModelUpdateEventCallback} callback - Event callback.
+ * @param {UseUpdatedEventOptions} options - Hook options.
+ * @returns {void}
+ */
+function useInstanceUpdatedEvent(modelOrModels, callback, options) {
+    const { active = true, debounce = false, onConnected } = options;
+    const callbackRef = useRef(callback);
+    const activeRef = useRef(active);
+    callbackRef.current = callback;
+    activeRef.current = active;
+    const modelsKey = modelsDependencyKey(modelOrModels);
+    const eventCallback = useMemo(() => {
+        const wrappedCallback = (/** @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {
+            if (activeRef.current)
+                callbackRef.current(payload);
+        };
+        if (typeof debounce === "number")
+            return debounceFunction(wrappedCallback, debounce);
+        if (debounce)
+            return debounceFunction(wrappedCallback);
+        return wrappedCallback;
+    }, [debounce]);
+    useEffect(() => {
+        if (!active)
+            return undefined;
+        const models = modelsFromInput(modelOrModels);
+        if (models.length < 1)
+            return undefined;
+        let closed = false;
+        /** @type {Array<() => void>} */
+        const unsubscribeCallbacks = [];
+        const subscriptionCallback = (/** @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {
+            if (!closed)
+                eventCallback(payload);
+        };
+        void (async () => {
+            for (const model of models) {
+                const unsubscribe = await model.onUpdate(subscriptionCallback);
+                if (closed) {
+                    unsubscribe();
+                }
+                else {
+                    unsubscribeCallbacks.push(unsubscribe);
+                }
+            }
+            if (!closed && onConnected)
+                onConnected();
+        })();
+        return () => {
+            closed = true;
+            for (const unsubscribe of unsubscribeCallbacks) {
+                unsubscribe();
+            }
+            clearPendingDebouncedCallback(eventCallback);
+        };
+    }, [active, eventCallback, modelsKey, onConnected]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-updated-event.js","sourceRoot":"","sources":["../../../src/frontend-models/use-updated-event.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport debounceFunction from \"debounce\"\nimport {useEffect, useMemo, useRef} from \"react\"\n\nimport clearPendingDebouncedCallback from \"./clear-pending-debounced-callback.js\"\nimport {modelsDependencyKey, modelsFromInput} from \"./event-hook-models.js\"\nimport useModelClassEvent from \"./use-model-class-event.js\"\n\n/** @typedef {typeof import(\"./base.js\").default} FrontendModelClass */\n/** @typedef {import(\"./base.js\").default} FrontendModelInstance */\n/** @typedef {import(\"./use-model-class-event.js\").FrontendModelCreateUpdateEventPayload} FrontendModelClassUpdateEventPayload */\n/** @typedef {{id: string, model: FrontendModelInstance}} FrontendModelInstanceUpdateEventPayload */\n/** @typedef {FrontendModelClassUpdateEventPayload | FrontendModelInstanceUpdateEventPayload} FrontendModelUpdateEventPayload */\n/** @typedef {import(\"./use-model-class-event.js\").UseModelClassEventOptions} UseUpdatedEventOptions */\n/** @typedef {(payload: FrontendModelUpdateEventPayload) => void} FrontendModelUpdateEventCallback */\n\n/**\n * @param {Record<string, unknown>} restOptions - Unknown options object.\n * @returns {void}\n */\nfunction assertNoUnknownOptions(restOptions) {\n  const unknownOptionNames = Object.keys(restOptions)\n\n  if (unknownOptionNames.length > 0) {\n    throw new Error(`Unknown options given to useUpdatedEvent: ${unknownOptionNames.join(\", \")}`)\n  }\n}\n\n/**\n * React hook for frontend-model update events. Pass a model class for class-level\n * update events, or a model / model array for instance-level update events.\n * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.\n * @param {FrontendModelUpdateEventCallback} callback - Event callback.\n * @param {UseUpdatedEventOptions} [options] - Hook options.\n * @returns {void}\n */\nexport default function useUpdatedEvent(modelClassOrModels, callback, options = {}) {\n  const {active = true, debounce = false, onConnected, ...restOptions} = options\n  assertNoUnknownOptions(restOptions)\n\n  const classModel = typeof modelClassOrModels === \"function\" ? modelClassOrModels : null\n  const instanceModels = typeof modelClassOrModels === \"function\" ? null : modelClassOrModels\n\n  useModelClassEvent(classModel, \"update\", (payload) => {\n    callback(/** @type {FrontendModelClassUpdateEventPayload} */ (payload))\n  }, {active: active && Boolean(classModel), debounce, onConnected})\n  useInstanceUpdatedEvent(instanceModels, callback, {active: active && !classModel, debounce, onConnected})\n}\n\n/**\n * @param {FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelOrModels - Model or models.\n * @param {FrontendModelUpdateEventCallback} callback - Event callback.\n * @param {UseUpdatedEventOptions} options - Hook options.\n * @returns {void}\n */\nfunction useInstanceUpdatedEvent(modelOrModels, callback, options) {\n  const {active = true, debounce = false, onConnected} = options\n  const callbackRef = useRef(callback)\n  const activeRef = useRef(active)\n  callbackRef.current = callback\n  activeRef.current = active\n\n  const modelsKey = modelsDependencyKey(modelOrModels)\n  const eventCallback = useMemo(() => {\n    const wrappedCallback = (/** @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {\n      if (activeRef.current) callbackRef.current(payload)\n    }\n\n    if (typeof debounce === \"number\") return debounceFunction(wrappedCallback, debounce)\n    if (debounce) return debounceFunction(wrappedCallback)\n\n    return wrappedCallback\n  }, [debounce])\n\n  useEffect(() => {\n    if (!active) return undefined\n\n    const models = modelsFromInput(modelOrModels)\n    if (models.length < 1) return undefined\n\n    let closed = false\n    /** @type {Array<() => void>} */\n    const unsubscribeCallbacks = []\n    const subscriptionCallback = (/** @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {\n      if (!closed) eventCallback(payload)\n    }\n\n    void (async () => {\n      for (const model of models) {\n        const unsubscribe = await model.onUpdate(subscriptionCallback)\n\n        if (closed) {\n          unsubscribe()\n        } else {\n          unsubscribeCallbacks.push(unsubscribe)\n        }\n      }\n\n      if (!closed && onConnected) onConnected()\n    })()\n\n    return () => {\n      closed = true\n\n      for (const unsubscribe of unsubscribeCallbacks) {\n        unsubscribe()\n      }\n\n      clearPendingDebouncedCallback(eventCallback)\n    }\n  }, [active, eventCallback, modelsKey, onConnected])\n}\n"]}

package/build/src/testing/browser-frontend-model-event-hook-scenarios.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @param {keyof typeof scenarios} scenarioName - Scenario name.
+ * @returns {Promise<Record<string, number>>} - Scenario result.
+ */
+export default function runFrontendModelEventHookScenario(scenarioName: keyof typeof scenarios): Promise<Record<string, number>>;
+export type FakeSubscriptions = {
+    /**
+     * - Create callbacks.
+     */
+    create: Set<(payload: unknown) => void>;
+    /**
+     * - Destroy callbacks.
+     */
+    destroy: Set<(payload: unknown) => void>;
+    /**
+     * - Update callbacks.
+     */
+    update: Set<(payload: unknown) => void>;
+};
+declare namespace scenarios {
+    export { classLifecycleScenario as classLifecycle };
+    export { debounceUnmountScenario as debounceUnmount };
+    export { instanceLifecycleScenario as instanceLifecycle };
+    export { resubscribeInstanceScenario as resubscribeInstance };
+}
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+declare function classLifecycleScenario(): Promise<Record<string, number>>;
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+declare function debounceUnmountScenario(): Promise<Record<string, number>>;
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+declare function instanceLifecycleScenario(): Promise<Record<string, number>>;
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+declare function resubscribeInstanceScenario(): Promise<Record<string, number>>;
+export {};
+//# sourceMappingURL=browser-frontend-model-event-hook-scenarios.d.ts.map

package/build/src/testing/browser-frontend-model-event-hook-scenarios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-frontend-model-event-hook-scenarios.d.ts","sourceRoot":"","sources":["../../../src/testing/browser-frontend-model-event-hook-scenarios.js"],"names":[],"mappings":"AAiTA;;;GAGG;AACH,wEAHW,MAAM,OAAO,SAAS,GACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAQ3C;;;;;YA/Sa,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;;;;aAC/B,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;;;;YAC/B,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;;;;;;;;AAqH7C,oEAAoE;AACpE,2CADc,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAyC5C;AA6CD,oEAAoE;AACpE,4CADc,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA2B5C;AAtED,oEAAoE;AACpE,8CADc,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAyC5C;AA+BD,oEAAoE;AACpE,gDADc,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkD5C"}

package/build/src/testing/browser-frontend-model-event-hook-scenarios.js

@@ -0,0 +1,259 @@
+// @ts-check
+import React from "react";
+import { createRoot } from "react-dom/client";
+import useDestroyedEvent from "../frontend-models/use-destroyed-event.js";
+import useCreatedEvent from "../frontend-models/use-created-event.js";
+import useModelClassEvent from "../frontend-models/use-model-class-event.js";
+import useUpdatedEvent from "../frontend-models/use-updated-event.js";
+/**
+ * @typedef {object} FakeSubscriptions
+ * @property {Set<(payload: unknown) => void>} create - Create callbacks.
+ * @property {Set<(payload: unknown) => void>} destroy - Destroy callbacks.
+ * @property {Set<(payload: unknown) => void>} update - Update callbacks.
+ */
+/** @returns {Promise<void>} - Resolves after React effects have run. */
+async function flushEffects() {
+    await Promise.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+ * @param {number} milliseconds - Milliseconds to wait.
+ * @returns {Promise<void>} - Resolves after the delay.
+ */
+async function sleep(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+/**
+ * @param {() => boolean} callback - Predicate to wait for.
+ * @returns {Promise<void>} - Resolves when the predicate returns true.
+ */
+async function waitFor(callback) {
+    const startedAt = Date.now();
+    while (!callback()) {
+        if (Date.now() - startedAt > 1000)
+            return;
+        await sleep(10);
+    }
+}
+/**
+ * @param {React.ReactElement} element - Element to render.
+ * @returns {Promise<{rerender: (nextElement: React.ReactElement) => Promise<void>, unmount: () => Promise<void>}>} - Render controls.
+ */
+async function renderElement(element) {
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    root.render(element);
+    await flushEffects();
+    return {
+        rerender: async (nextElement) => {
+            root.render(nextElement);
+            await flushEffects();
+        },
+        unmount: async () => {
+            root.unmount();
+            container.remove();
+            await flushEffects();
+        }
+    };
+}
+/** @returns {{ModelClass: typeof import("../frontend-models/base.js").default, subscriptions: FakeSubscriptions}} - Fake model class setup. */
+function buildFakeModelClass() {
+    const subscriptions = {
+        create: new Set(),
+        destroy: new Set(),
+        update: new Set()
+    };
+    const ModelClass = /** @type {typeof import("../frontend-models/base.js").default} */ ( /** @type {unknown} */({
+        onCreate: async (/** @type {(payload: unknown) => void} */ callback) => {
+            subscriptions.create.add(callback);
+            return () => subscriptions.create.delete(callback);
+        },
+        onDestroy: async (/** @type {(payload: unknown) => void} */ callback) => {
+            subscriptions.destroy.add(callback);
+            return () => subscriptions.destroy.delete(callback);
+        },
+        onUpdate: async (/** @type {(payload: unknown) => void} */ callback) => {
+            subscriptions.update.add(callback);
+            return () => subscriptions.update.delete(callback);
+        }
+    }));
+    return { ModelClass, subscriptions };
+}
+/**
+ * @param {FakeSubscriptions} subscriptions - Callback sets.
+ * @param {"create" | "destroy" | "update"} eventName - Event name.
+ * @param {unknown} payload - Event payload.
+ * @returns {void}
+ */
+function emitEvent(subscriptions, eventName, payload) {
+    for (const callback of subscriptions[eventName]) {
+        callback(payload);
+    }
+}
+/**
+ * @param {string} id - Model id.
+ * @param {FakeSubscriptions} subscriptions - Callback sets.
+ * @returns {import("../frontend-models/base.js").default} - Fake model instance.
+ */
+function buildFakeModel(id, subscriptions) {
+    return /** @type {import("../frontend-models/base.js").default} */ ( /** @type {unknown} */({
+        onDestroy: async (/** @type {(payload: unknown) => void} */ callback) => {
+            subscriptions.destroy.add(callback);
+            return () => subscriptions.destroy.delete(callback);
+        },
+        onUpdate: async (/** @type {(payload: unknown) => void} */ callback) => {
+            subscriptions.update.add(callback);
+            return () => subscriptions.update.delete(callback);
+        },
+        primaryKeyValue: () => id
+    }));
+}
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+async function classLifecycleScenario() {
+    const { ModelClass, subscriptions } = buildFakeModelClass();
+    const receivedEvents = /** @type {unknown[]} */ ([]);
+    let connectedCount = 0;
+    /** @returns {React.ReactElement} - Test element. */
+    function TestComponent() {
+        useModelClassEvent(ModelClass, ["create", "update"], (payload) => receivedEvents.push(payload), {
+            onConnected: () => { connectedCount += 1; }
+        });
+        useCreatedEvent(ModelClass, (payload) => receivedEvents.push(payload));
+        return React.createElement("div");
+    }
+    const controls = await renderElement(React.createElement(TestComponent));
+    await waitFor(() => subscriptions.create.size === 2 && subscriptions.update.size === 1);
+    const mountedCreateSubscriptions = subscriptions.create.size;
+    const mountedUpdateSubscriptions = subscriptions.update.size;
+    const mountedDestroySubscriptions = subscriptions.destroy.size;
+    const mountedConnectedCount = connectedCount;
+    emitEvent(subscriptions, "create", { id: "1", model: { id: "1" } });
+    emitEvent(subscriptions, "update", { id: "1", model: { id: "1" } });
+    emitEvent(subscriptions, "destroy", { id: "1" });
+    const receivedEventsAfterEmit = receivedEvents.length;
+    await controls.unmount();
+    return {
+        mountedConnectedCount,
+        mountedCreateSubscriptions,
+        mountedDestroySubscriptions,
+        mountedUpdateSubscriptions,
+        receivedEventsAfterEmit,
+        unmountedCreateSubscriptions: subscriptions.create.size,
+        unmountedUpdateSubscriptions: subscriptions.update.size
+    };
+}
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+async function instanceLifecycleScenario() {
+    const subscriptions = { create: new Set(), destroy: new Set(), update: new Set() };
+    const model = buildFakeModel("task-1", subscriptions);
+    const receivedEvents = /** @type {unknown[]} */ ([]);
+    let connectedCount = 0;
+    /** @returns {React.ReactElement} - Test element. */
+    function TestComponent() {
+        useUpdatedEvent(model, (payload) => receivedEvents.push(payload), {
+            onConnected: () => { connectedCount += 1; }
+        });
+        useDestroyedEvent([model], (payload) => receivedEvents.push(payload), {
+            onConnected: () => { connectedCount += 1; }
+        });
+        return React.createElement("div");
+    }
+    const controls = await renderElement(React.createElement(TestComponent));
+    await waitFor(() => subscriptions.update.size === 1 && subscriptions.destroy.size === 1);
+    const mountedConnectedCount = connectedCount;
+    const mountedDestroySubscriptions = subscriptions.destroy.size;
+    const mountedUpdateSubscriptions = subscriptions.update.size;
+    emitEvent(subscriptions, "update", { id: "task-1", model });
+    emitEvent(subscriptions, "destroy", { id: "task-1" });
+    const receivedEventsAfterEmit = receivedEvents.length;
+    await controls.unmount();
+    return {
+        mountedConnectedCount,
+        mountedDestroySubscriptions,
+        mountedUpdateSubscriptions,
+        receivedEventsAfterEmit,
+        unmountedDestroySubscriptions: subscriptions.destroy.size,
+        unmountedUpdateSubscriptions: subscriptions.update.size
+    };
+}
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+async function debounceUnmountScenario() {
+    const { ModelClass, subscriptions: classSubscriptions } = buildFakeModelClass();
+    const instanceSubscriptions = { create: new Set(), destroy: new Set(), update: new Set() };
+    const model = buildFakeModel("task-1", instanceSubscriptions);
+    const receivedEvents = /** @type {unknown[]} */ ([]);
+    /** @returns {React.ReactElement} - Test element. */
+    function TestComponent() {
+        useModelClassEvent(ModelClass, "update", (payload) => receivedEvents.push(payload), { debounce: 20 });
+        useUpdatedEvent(model, (payload) => receivedEvents.push(payload), { debounce: 20 });
+        useDestroyedEvent(model, (payload) => receivedEvents.push(payload), { debounce: 20 });
+        return React.createElement("div");
+    }
+    const controls = await renderElement(React.createElement(TestComponent));
+    await waitFor(() => classSubscriptions.update.size === 1 && instanceSubscriptions.update.size === 1 && instanceSubscriptions.destroy.size === 1);
+    emitEvent(classSubscriptions, "update", { id: "task-1", model });
+    emitEvent(instanceSubscriptions, "update", { id: "task-1", model });
+    emitEvent(instanceSubscriptions, "destroy", { id: "task-1" });
+    await controls.unmount();
+    await sleep(30);
+    return { receivedEventsAfterDebounceWindow: receivedEvents.length };
+}
+/** @returns {Promise<Record<string, number>>} - Scenario result. */
+async function resubscribeInstanceScenario() {
+    const firstSubscriptions = { create: new Set(), destroy: new Set(), update: new Set() };
+    const secondSubscriptions = { create: new Set(), destroy: new Set(), update: new Set() };
+    const firstModel = buildFakeModel("task-1", firstSubscriptions);
+    const secondModel = buildFakeModel("task-1", secondSubscriptions);
+    const receivedEvents = /** @type {unknown[]} */ ([]);
+    /**
+     * @param {{model: import("../frontend-models/base.js").default}} props - Component props.
+     * @returns {React.ReactElement} - Test element.
+     */
+    function TestComponent({ model }) {
+        useUpdatedEvent(model, (payload) => receivedEvents.push(payload));
+        useDestroyedEvent(model, (payload) => receivedEvents.push(payload));
+        return React.createElement("div");
+    }
+    const controls = await renderElement(React.createElement(TestComponent, { model: firstModel }));
+    await waitFor(() => firstSubscriptions.update.size === 1 && firstSubscriptions.destroy.size === 1);
+    const firstMountedDestroySubscriptions = firstSubscriptions.destroy.size;
+    const firstMountedUpdateSubscriptions = firstSubscriptions.update.size;
+    await controls.rerender(React.createElement(TestComponent, { model: secondModel }));
+    await waitFor(() => firstSubscriptions.update.size === 0 && firstSubscriptions.destroy.size === 0 && secondSubscriptions.update.size === 1 && secondSubscriptions.destroy.size === 1);
+    const firstAfterRerenderDestroySubscriptions = firstSubscriptions.destroy.size;
+    const firstAfterRerenderUpdateSubscriptions = firstSubscriptions.update.size;
+    const secondAfterRerenderDestroySubscriptions = secondSubscriptions.destroy.size;
+    const secondAfterRerenderUpdateSubscriptions = secondSubscriptions.update.size;
+    emitEvent(firstSubscriptions, "update", { id: "task-1", model: firstModel });
+    emitEvent(secondSubscriptions, "update", { id: "task-1", model: secondModel });
+    emitEvent(secondSubscriptions, "destroy", { id: "task-1" });
+    const receivedEventsAfterEmit = receivedEvents.length;
+    await controls.unmount();
+    return {
+        firstAfterRerenderDestroySubscriptions,
+        firstAfterRerenderUpdateSubscriptions,
+        firstMountedDestroySubscriptions,
+        firstMountedUpdateSubscriptions,
+        receivedEventsAfterEmit,
+        secondAfterRerenderDestroySubscriptions,
+        secondAfterRerenderUpdateSubscriptions
+    };
+}
+const scenarios = {
+    classLifecycle: classLifecycleScenario,
+    debounceUnmount: debounceUnmountScenario,
+    instanceLifecycle: instanceLifecycleScenario,
+    resubscribeInstance: resubscribeInstanceScenario
+};
+/**
+ * @param {keyof typeof scenarios} scenarioName - Scenario name.
+ * @returns {Promise<Record<string, number>>} - Scenario result.
+ */
+export default async function runFrontendModelEventHookScenario(scenarioName) {
+    const scenario = scenarios[scenarioName];
+    if (!scenario)
+        throw new Error(`Unknown frontend model event hook scenario: ${scenarioName}`);
+    return await scenario();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-frontend-model-event-hook-scenarios.js","sourceRoot":"","sources":["../../../src/testing/browser-frontend-model-event-hook-scenarios.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport React from \"react\"\nimport {createRoot} from \"react-dom/client\"\n\nimport useDestroyedEvent from \"../frontend-models/use-destroyed-event.js\"\nimport useCreatedEvent from \"../frontend-models/use-created-event.js\"\nimport useModelClassEvent from \"../frontend-models/use-model-class-event.js\"\nimport useUpdatedEvent from \"../frontend-models/use-updated-event.js\"\n\n/**\n * @typedef {object} FakeSubscriptions\n * @property {Set<(payload: unknown) => void>} create - Create callbacks.\n * @property {Set<(payload: unknown) => void>} destroy - Destroy callbacks.\n * @property {Set<(payload: unknown) => void>} update - Update callbacks.\n */\n\n/** @returns {Promise<void>} - Resolves after React effects have run. */\nasync function flushEffects() {\n  await Promise.resolve()\n  await new Promise((resolve) => setTimeout(resolve, 0))\n}\n\n/**\n * @param {number} milliseconds - Milliseconds to wait.\n * @returns {Promise<void>} - Resolves after the delay.\n */\nasync function sleep(milliseconds) {\n  await new Promise((resolve) => setTimeout(resolve, milliseconds))\n}\n\n/**\n * @param {() => boolean} callback - Predicate to wait for.\n * @returns {Promise<void>} - Resolves when the predicate returns true.\n */\nasync function waitFor(callback) {\n  const startedAt = Date.now()\n\n  while (!callback()) {\n    if (Date.now() - startedAt > 1000) return\n\n    await sleep(10)\n  }\n}\n\n/**\n * @param {React.ReactElement} element - Element to render.\n * @returns {Promise<{rerender: (nextElement: React.ReactElement) => Promise<void>, unmount: () => Promise<void>}>} - Render controls.\n */\nasync function renderElement(element) {\n  const container = document.createElement(\"div\")\n  document.body.appendChild(container)\n  const root = createRoot(container)\n\n  root.render(element)\n  await flushEffects()\n\n  return {\n    rerender: async (nextElement) => {\n      root.render(nextElement)\n      await flushEffects()\n    },\n    unmount: async () => {\n      root.unmount()\n      container.remove()\n      await flushEffects()\n    }\n  }\n}\n\n/** @returns {{ModelClass: typeof import(\"../frontend-models/base.js\").default, subscriptions: FakeSubscriptions}} - Fake model class setup. */\nfunction buildFakeModelClass() {\n  const subscriptions = {\n    create: new Set(),\n    destroy: new Set(),\n    update: new Set()\n  }\n  const ModelClass = /** @type {typeof import(\"../frontend-models/base.js\").default} */ (/** @type {unknown} */ ({\n    onCreate: async (/** @type {(payload: unknown) => void} */ callback) => {\n      subscriptions.create.add(callback)\n\n      return () => subscriptions.create.delete(callback)\n    },\n    onDestroy: async (/** @type {(payload: unknown) => void} */ callback) => {\n      subscriptions.destroy.add(callback)\n\n      return () => subscriptions.destroy.delete(callback)\n    },\n    onUpdate: async (/** @type {(payload: unknown) => void} */ callback) => {\n      subscriptions.update.add(callback)\n\n      return () => subscriptions.update.delete(callback)\n    }\n  }))\n\n  return {ModelClass, subscriptions}\n}\n\n/**\n * @param {FakeSubscriptions} subscriptions - Callback sets.\n * @param {\"create\" | \"destroy\" | \"update\"} eventName - Event name.\n * @param {unknown} payload - Event payload.\n * @returns {void}\n */\nfunction emitEvent(subscriptions, eventName, payload) {\n  for (const callback of subscriptions[eventName]) {\n    callback(payload)\n  }\n}\n\n/**\n * @param {string} id - Model id.\n * @param {FakeSubscriptions} subscriptions - Callback sets.\n * @returns {import(\"../frontend-models/base.js\").default} - Fake model instance.\n */\nfunction buildFakeModel(id, subscriptions) {\n  return /** @type {import(\"../frontend-models/base.js\").default} */ (/** @type {unknown} */ ({\n    onDestroy: async (/** @type {(payload: unknown) => void} */ callback) => {\n      subscriptions.destroy.add(callback)\n\n      return () => subscriptions.destroy.delete(callback)\n    },\n    onUpdate: async (/** @type {(payload: unknown) => void} */ callback) => {\n      subscriptions.update.add(callback)\n\n      return () => subscriptions.update.delete(callback)\n    },\n    primaryKeyValue: () => id\n  }))\n}\n\n/** @returns {Promise<Record<string, number>>} - Scenario result. */\nasync function classLifecycleScenario() {\n  const {ModelClass, subscriptions} = buildFakeModelClass()\n  const receivedEvents = /** @type {unknown[]} */ ([])\n  let connectedCount = 0\n\n  /** @returns {React.ReactElement} - Test element. */\n  function TestComponent() {\n    useModelClassEvent(ModelClass, [\"create\", \"update\"], (payload) => receivedEvents.push(payload), {\n      onConnected: () => { connectedCount += 1 }\n    })\n    useCreatedEvent(ModelClass, (payload) => receivedEvents.push(payload))\n\n    return React.createElement(\"div\")\n  }\n\n  const controls = await renderElement(React.createElement(TestComponent))\n  await waitFor(() => subscriptions.create.size === 2 && subscriptions.update.size === 1)\n\n  const mountedCreateSubscriptions = subscriptions.create.size\n  const mountedUpdateSubscriptions = subscriptions.update.size\n  const mountedDestroySubscriptions = subscriptions.destroy.size\n  const mountedConnectedCount = connectedCount\n\n  emitEvent(subscriptions, \"create\", {id: \"1\", model: {id: \"1\"}})\n  emitEvent(subscriptions, \"update\", {id: \"1\", model: {id: \"1\"}})\n  emitEvent(subscriptions, \"destroy\", {id: \"1\"})\n\n  const receivedEventsAfterEmit = receivedEvents.length\n\n  await controls.unmount()\n\n  return {\n    mountedConnectedCount,\n    mountedCreateSubscriptions,\n    mountedDestroySubscriptions,\n    mountedUpdateSubscriptions,\n    receivedEventsAfterEmit,\n    unmountedCreateSubscriptions: subscriptions.create.size,\n    unmountedUpdateSubscriptions: subscriptions.update.size\n  }\n}\n\n/** @returns {Promise<Record<string, number>>} - Scenario result. */\nasync function instanceLifecycleScenario() {\n  const subscriptions = {create: new Set(), destroy: new Set(), update: new Set()}\n  const model = buildFakeModel(\"task-1\", subscriptions)\n  const receivedEvents = /** @type {unknown[]} */ ([])\n  let connectedCount = 0\n\n  /** @returns {React.ReactElement} - Test element. */\n  function TestComponent() {\n    useUpdatedEvent(model, (payload) => receivedEvents.push(payload), {\n      onConnected: () => { connectedCount += 1 }\n    })\n    useDestroyedEvent([model], (payload) => receivedEvents.push(payload), {\n      onConnected: () => { connectedCount += 1 }\n    })\n\n    return React.createElement(\"div\")\n  }\n\n  const controls = await renderElement(React.createElement(TestComponent))\n  await waitFor(() => subscriptions.update.size === 1 && subscriptions.destroy.size === 1)\n\n  const mountedConnectedCount = connectedCount\n  const mountedDestroySubscriptions = subscriptions.destroy.size\n  const mountedUpdateSubscriptions = subscriptions.update.size\n\n  emitEvent(subscriptions, \"update\", {id: \"task-1\", model})\n  emitEvent(subscriptions, \"destroy\", {id: \"task-1\"})\n\n  const receivedEventsAfterEmit = receivedEvents.length\n\n  await controls.unmount()\n\n  return {\n    mountedConnectedCount,\n    mountedDestroySubscriptions,\n    mountedUpdateSubscriptions,\n    receivedEventsAfterEmit,\n    unmountedDestroySubscriptions: subscriptions.destroy.size,\n    unmountedUpdateSubscriptions: subscriptions.update.size\n  }\n}\n\n/** @returns {Promise<Record<string, number>>} - Scenario result. */\nasync function debounceUnmountScenario() {\n  const {ModelClass, subscriptions: classSubscriptions} = buildFakeModelClass()\n  const instanceSubscriptions = {create: new Set(), destroy: new Set(), update: new Set()}\n  const model = buildFakeModel(\"task-1\", instanceSubscriptions)\n  const receivedEvents = /** @type {unknown[]} */ ([])\n\n  /** @returns {React.ReactElement} - Test element. */\n  function TestComponent() {\n    useModelClassEvent(ModelClass, \"update\", (payload) => receivedEvents.push(payload), {debounce: 20})\n    useUpdatedEvent(model, (payload) => receivedEvents.push(payload), {debounce: 20})\n    useDestroyedEvent(model, (payload) => receivedEvents.push(payload), {debounce: 20})\n\n    return React.createElement(\"div\")\n  }\n\n  const controls = await renderElement(React.createElement(TestComponent))\n  await waitFor(() => classSubscriptions.update.size === 1 && instanceSubscriptions.update.size === 1 && instanceSubscriptions.destroy.size === 1)\n\n  emitEvent(classSubscriptions, \"update\", {id: \"task-1\", model})\n  emitEvent(instanceSubscriptions, \"update\", {id: \"task-1\", model})\n  emitEvent(instanceSubscriptions, \"destroy\", {id: \"task-1\"})\n\n  await controls.unmount()\n  await sleep(30)\n\n  return {receivedEventsAfterDebounceWindow: receivedEvents.length}\n}\n\n/** @returns {Promise<Record<string, number>>} - Scenario result. */\nasync function resubscribeInstanceScenario() {\n  const firstSubscriptions = {create: new Set(), destroy: new Set(), update: new Set()}\n  const secondSubscriptions = {create: new Set(), destroy: new Set(), update: new Set()}\n  const firstModel = buildFakeModel(\"task-1\", firstSubscriptions)\n  const secondModel = buildFakeModel(\"task-1\", secondSubscriptions)\n  const receivedEvents = /** @type {unknown[]} */ ([])\n\n  /**\n   * @param {{model: import(\"../frontend-models/base.js\").default}} props - Component props.\n   * @returns {React.ReactElement} - Test element.\n   */\n  function TestComponent({model}) {\n    useUpdatedEvent(model, (payload) => receivedEvents.push(payload))\n    useDestroyedEvent(model, (payload) => receivedEvents.push(payload))\n\n    return React.createElement(\"div\")\n  }\n\n  const controls = await renderElement(React.createElement(TestComponent, {model: firstModel}))\n  await waitFor(() => firstSubscriptions.update.size === 1 && firstSubscriptions.destroy.size === 1)\n\n  const firstMountedDestroySubscriptions = firstSubscriptions.destroy.size\n  const firstMountedUpdateSubscriptions = firstSubscriptions.update.size\n\n  await controls.rerender(React.createElement(TestComponent, {model: secondModel}))\n  await waitFor(() => firstSubscriptions.update.size === 0 && firstSubscriptions.destroy.size === 0 && secondSubscriptions.update.size === 1 && secondSubscriptions.destroy.size === 1)\n\n  const firstAfterRerenderDestroySubscriptions = firstSubscriptions.destroy.size\n  const firstAfterRerenderUpdateSubscriptions = firstSubscriptions.update.size\n  const secondAfterRerenderDestroySubscriptions = secondSubscriptions.destroy.size\n  const secondAfterRerenderUpdateSubscriptions = secondSubscriptions.update.size\n\n  emitEvent(firstSubscriptions, \"update\", {id: \"task-1\", model: firstModel})\n  emitEvent(secondSubscriptions, \"update\", {id: \"task-1\", model: secondModel})\n  emitEvent(secondSubscriptions, \"destroy\", {id: \"task-1\"})\n\n  const receivedEventsAfterEmit = receivedEvents.length\n\n  await controls.unmount()\n\n  return {\n    firstAfterRerenderDestroySubscriptions,\n    firstAfterRerenderUpdateSubscriptions,\n    firstMountedDestroySubscriptions,\n    firstMountedUpdateSubscriptions,\n    receivedEventsAfterEmit,\n    secondAfterRerenderDestroySubscriptions,\n    secondAfterRerenderUpdateSubscriptions\n  }\n}\n\nconst scenarios = {\n  classLifecycle: classLifecycleScenario,\n  debounceUnmount: debounceUnmountScenario,\n  instanceLifecycle: instanceLifecycleScenario,\n  resubscribeInstance: resubscribeInstanceScenario\n}\n\n/**\n * @param {keyof typeof scenarios} scenarioName - Scenario name.\n * @returns {Promise<Record<string, number>>} - Scenario result.\n */\nexport default async function runFrontendModelEventHookScenario(scenarioName) {\n  const scenario = scenarios[scenarioName]\n\n  if (!scenario) throw new Error(`Unknown frontend model event hook scenario: ${scenarioName}`)\n\n  return await scenario()\n}\n"]}

package/build/src/testing/browser-test-app.js

@@ -1,6 +1,7 @@
 // @ts-check
 import SystemTestBrowserHelper from "system-testing/build/system-test-browser-helper.js";
 import BrowserEnvironmentHandler from "../environment-handlers/browser.js";
+import runFrontendModelEventHookScenario from "./browser-frontend-model-event-hook-scenarios.js";
 const root = document.getElementById("root") || (() => {
     const element = document.createElement("div");
     element.id = "root";
@@ -19,6 +20,7 @@ const systemTestBrowserHelper = new SystemTestBrowserHelper();
 systemTestBrowserHelper.enableOnBrowser();
 globalThis.velociousBrowserTest = {
     BrowserEnvironmentHandler,
+    runFrontendModelEventHookScenario,
     systemTestBrowserHelper
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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