velocious 1.0.395 → 1.0.397

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

@@ -0,0 +1,19 @@
+// @ts-check
+import useModelClassEvent from "./use-model-class-event.js";
+/** @typedef {typeof import("./base.js").default} FrontendModelClass */
+/** @typedef {import("./use-model-class-event.js").FrontendModelCreateUpdateEventPayload} FrontendModelCreateEventPayload */
+/** @typedef {import("./use-model-class-event.js").UseModelClassEventOptions} UseCreatedEventOptions */
+/** @typedef {(payload: FrontendModelCreateEventPayload) => void} FrontendModelCreateEventCallback */
+/**
+ * React hook for frontend-model class create events.
+ * @param {FrontendModelClass | null | undefined} modelClass - Frontend model class.
+ * @param {FrontendModelCreateEventCallback} callback - Event callback.
+ * @param {UseCreatedEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useCreatedEvent(modelClass, callback, options = {}) {
+    useModelClassEvent(modelClass, "create", (payload) => {
+        callback(/** @type {FrontendModelCreateEventPayload} */ (payload));
+    }, options);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+/**
+ * React hook for frontend-model destroy events. Pass a model class for class-level
+ * destroy events, or a model / model array for instance-level destroy events.
+ * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.
+ * @param {FrontendModelDestroyEventCallback} callback - Event callback.
+ * @param {UseDestroyedEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useDestroyedEvent(modelClassOrModels: FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined, callback: FrontendModelDestroyEventCallback, options?: UseDestroyedEventOptions): void;
+export type FrontendModelClass = typeof import("./base.js").default;
+export type FrontendModelInstance = import("./base.js").default;
+export type FrontendModelClassDestroyEventPayload = import("./use-model-class-event.js").FrontendModelDestroyEventPayload;
+export type FrontendModelInstanceDestroyEventPayload = {
+    id: string;
+};
+export type FrontendModelDestroyEventPayload = FrontendModelClassDestroyEventPayload | FrontendModelInstanceDestroyEventPayload;
+export type UseDestroyedEventOptions = import("./use-model-class-event.js").UseModelClassEventOptions;
+export type FrontendModelDestroyEventCallback = (payload: FrontendModelDestroyEventPayload) => void;
+//# sourceMappingURL=use-destroyed-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-destroyed-event.d.ts","sourceRoot":"","sources":["../../../src/frontend-models/use-destroyed-event.js"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,8DALW,kBAAkB,GAAG,qBAAqB,GAAG,qBAAqB,EAAE,GAAG,IAAI,GAAG,SAAS,YACvF,iCAAiC,YACjC,wBAAwB,GACtB,IAAI,CAWhB;iCArCa,cAAc,WAAW,EAAE,OAAO;oCAClC,OAAO,WAAW,EAAE,OAAO;oDAC3B,OAAO,4BAA4B,EAAE,gCAAgC;uDACrE;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC;+CACZ,qCAAqC,GAAG,wCAAwC;uCAChF,OAAO,4BAA4B,EAAE,yBAAyB;gDAC9D,CAAC,OAAO,EAAE,gCAAgC,KAAK,IAAI"}

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

@@ -0,0 +1,99 @@
+// @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").FrontendModelDestroyEventPayload} FrontendModelClassDestroyEventPayload */
+/** @typedef {{id: string}} FrontendModelInstanceDestroyEventPayload */
+/** @typedef {FrontendModelClassDestroyEventPayload | FrontendModelInstanceDestroyEventPayload} FrontendModelDestroyEventPayload */
+/** @typedef {import("./use-model-class-event.js").UseModelClassEventOptions} UseDestroyedEventOptions */
+/** @typedef {(payload: FrontendModelDestroyEventPayload) => void} FrontendModelDestroyEventCallback */
+/**
+ * @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 useDestroyedEvent: ${unknownOptionNames.join(", ")}`);
+    }
+}
+/**
+ * React hook for frontend-model destroy events. Pass a model class for class-level
+ * destroy events, or a model / model array for instance-level destroy events.
+ * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.
+ * @param {FrontendModelDestroyEventCallback} callback - Event callback.
+ * @param {UseDestroyedEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useDestroyedEvent(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, "destroy", callback, { active: active && Boolean(classModel), debounce, onConnected });
+    useInstanceDestroyedEvent(instanceModels, callback, { active: active && !classModel, debounce, onConnected });
+}
+/**
+ * @param {FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelOrModels - Model or models.
+ * @param {FrontendModelDestroyEventCallback} callback - Event callback.
+ * @param {UseDestroyedEventOptions} options - Hook options.
+ * @returns {void}
+ */
+function useInstanceDestroyedEvent(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 {FrontendModelInstanceDestroyEventPayload} */ 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 {FrontendModelInstanceDestroyEventPayload} */ payload) => {
+            if (!closed)
+                eventCallback(payload);
+        };
+        void (async () => {
+            for (const model of models) {
+                const unsubscribe = await model.onDestroy(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-destroyed-event.js","sourceRoot":"","sources":["../../../src/frontend-models/use-destroyed-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\").FrontendModelDestroyEventPayload} FrontendModelClassDestroyEventPayload */\n/** @typedef {{id: string}} FrontendModelInstanceDestroyEventPayload */\n/** @typedef {FrontendModelClassDestroyEventPayload | FrontendModelInstanceDestroyEventPayload} FrontendModelDestroyEventPayload */\n/** @typedef {import(\"./use-model-class-event.js\").UseModelClassEventOptions} UseDestroyedEventOptions */\n/** @typedef {(payload: FrontendModelDestroyEventPayload) => void} FrontendModelDestroyEventCallback */\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 useDestroyedEvent: ${unknownOptionNames.join(\", \")}`)\n  }\n}\n\n/**\n * React hook for frontend-model destroy events. Pass a model class for class-level\n * destroy events, or a model / model array for instance-level destroy events.\n * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.\n * @param {FrontendModelDestroyEventCallback} callback - Event callback.\n * @param {UseDestroyedEventOptions} [options] - Hook options.\n * @returns {void}\n */\nexport default function useDestroyedEvent(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, \"destroy\", callback, {active: active && Boolean(classModel), debounce, onConnected})\n  useInstanceDestroyedEvent(instanceModels, callback, {active: active && !classModel, debounce, onConnected})\n}\n\n/**\n * @param {FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelOrModels - Model or models.\n * @param {FrontendModelDestroyEventCallback} callback - Event callback.\n * @param {UseDestroyedEventOptions} options - Hook options.\n * @returns {void}\n */\nfunction useInstanceDestroyedEvent(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 {FrontendModelInstanceDestroyEventPayload} */ 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 {FrontendModelInstanceDestroyEventPayload} */ payload) => {\n      if (!closed) eventCallback(payload)\n    }\n\n    void (async () => {\n      for (const model of models) {\n        const unsubscribe = await model.onDestroy(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/frontend-models/use-model-class-event.d.ts

@@ -0,0 +1,27 @@
+/**
+ * React hook for frontend-model class lifecycle events.
+ * @param {FrontendModelClass | null | undefined} modelClass - Frontend model class.
+ * @param {FrontendModelClassEventName | FrontendModelClassEventName[]} eventOrEvents - Event name or names.
+ * @param {FrontendModelClassEventCallback} callback - Event callback.
+ * @param {UseModelClassEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useModelClassEvent(modelClass: FrontendModelClass | null | undefined, eventOrEvents: FrontendModelClassEventName | FrontendModelClassEventName[], callback: FrontendModelClassEventCallback, options?: UseModelClassEventOptions): void;
+export type FrontendModelClass = typeof import("./base.js").default;
+export type FrontendModelInstance = InstanceType<FrontendModelClass>;
+export type FrontendModelClassEventName = "create" | "update" | "destroy";
+export type FrontendModelCreateUpdateEventPayload = {
+    id: string;
+    model: FrontendModelInstance;
+};
+export type FrontendModelDestroyEventPayload = {
+    id: string;
+};
+export type FrontendModelClassEventPayload = FrontendModelCreateUpdateEventPayload | FrontendModelDestroyEventPayload;
+export type FrontendModelClassEventCallback = (payload: FrontendModelClassEventPayload) => void;
+export type UseModelClassEventOptions = {
+    active?: boolean;
+    debounce?: boolean | number;
+    onConnected?: () => void;
+};
+//# sourceMappingURL=use-model-class-event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-model-class-event.d.ts","sourceRoot":"","sources":["../../../src/frontend-models/use-model-class-event.js"],"names":[],"mappings":"AA0DA;;;;;;;GAOG;AACH,uDANW,kBAAkB,GAAG,IAAI,GAAG,SAAS,iBACrC,2BAA2B,GAAG,2BAA2B,EAAE,YAC3D,+BAA+B,YAC/B,yBAAyB,GACvB,IAAI,CA0DhB;iCAnHa,cAAc,WAAW,EAAE,OAAO;oCAClC,YAAY,CAAC,kBAAkB,CAAC;0CAChC,QAAQ,GAAG,QAAQ,GAAG,SAAS;oDAC/B;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,qBAAqB,CAAA;CAAC;+CAC1C;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC;6CACZ,qCAAqC,GAAG,gCAAgC;8CACxE,CAAC,OAAO,EAAE,8BAA8B,KAAK,IAAI;wCACjD;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;CAAC"}

package/build/src/frontend-models/use-model-class-event.js

@@ -0,0 +1,112 @@
+// @ts-check
+import debounceFunction from "debounce";
+import { useEffect, useMemo, useRef } from "react";
+import clearPendingDebouncedCallback from "./clear-pending-debounced-callback.js";
+/** @typedef {typeof import("./base.js").default} FrontendModelClass */
+/** @typedef {InstanceType<FrontendModelClass>} FrontendModelInstance */
+/** @typedef {"create" | "update" | "destroy"} FrontendModelClassEventName */
+/** @typedef {{id: string, model: FrontendModelInstance}} FrontendModelCreateUpdateEventPayload */
+/** @typedef {{id: string}} FrontendModelDestroyEventPayload */
+/** @typedef {FrontendModelCreateUpdateEventPayload | FrontendModelDestroyEventPayload} FrontendModelClassEventPayload */
+/** @typedef {(payload: FrontendModelClassEventPayload) => void} FrontendModelClassEventCallback */
+/** @typedef {{active?: boolean, debounce?: boolean | number, onConnected?: () => void}} UseModelClassEventOptions */
+/**
+ * @param {FrontendModelClassEventName | FrontendModelClassEventName[]} eventOrEvents - Event name or names.
+ * @returns {FrontendModelClassEventName[]} - Normalized event names.
+ */
+function normalizeEventNames(eventOrEvents) {
+    return Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents];
+}
+/**
+ * @param {FrontendModelClassEventName[]} eventNames - Event names.
+ * @returns {string} - Stable dependency key.
+ */
+function eventNamesDependencyKey(eventNames) {
+    return eventNames.join("|");
+}
+/**
+ * @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 useModelClassEvent: ${unknownOptionNames.join(", ")}`);
+    }
+}
+/**
+ * @param {FrontendModelClass} modelClass - Frontend model class.
+ * @param {FrontendModelClassEventName} eventName - Event name.
+ * @param {FrontendModelClassEventCallback} callback - Event callback.
+ * @returns {Promise<() => void>} - Unsubscribe callback.
+ */
+async function subscribeToModelClassEvent(modelClass, eventName, callback) {
+    if (eventName === "create")
+        return await modelClass.onCreate(callback);
+    if (eventName === "update")
+        return await modelClass.onUpdate(callback);
+    if (eventName === "destroy")
+        return await modelClass.onDestroy(callback);
+    throw new Error(`Unsupported frontend model class event: ${eventName}`);
+}
+/**
+ * React hook for frontend-model class lifecycle events.
+ * @param {FrontendModelClass | null | undefined} modelClass - Frontend model class.
+ * @param {FrontendModelClassEventName | FrontendModelClassEventName[]} eventOrEvents - Event name or names.
+ * @param {FrontendModelClassEventCallback} callback - Event callback.
+ * @param {UseModelClassEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useModelClassEvent(modelClass, eventOrEvents, callback, options = {}) {
+    const { active = true, debounce = false, onConnected, ...restOptions } = options;
+    assertNoUnknownOptions(restOptions);
+    const callbackRef = useRef(callback);
+    const activeRef = useRef(active);
+    callbackRef.current = callback;
+    activeRef.current = active;
+    const eventNames = normalizeEventNames(eventOrEvents);
+    const eventsKey = eventNamesDependencyKey(eventNames);
+    const eventCallback = useMemo(() => {
+        const wrappedCallback = (/** @type {FrontendModelClassEventPayload} */ 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 || !modelClass)
+            return undefined;
+        let closed = false;
+        /** @type {Array<() => void>} */
+        const unsubscribeCallbacks = [];
+        const subscriptionCallback = (/** @type {FrontendModelClassEventPayload} */ payload) => {
+            if (!closed)
+                eventCallback(payload);
+        };
+        void (async () => {
+            for (const eventName of eventNames) {
+                const unsubscribe = await subscribeToModelClassEvent(modelClass, eventName, subscriptionCallback);
+                if (closed) {
+                    unsubscribe();
+                }
+                else {
+                    unsubscribeCallbacks.push(unsubscribe);
+                }
+            }
+            if (!closed && onConnected)
+                onConnected();
+        })();
+        return () => {
+            closed = true;
+            for (const unsubscribe of unsubscribeCallbacks) {
+                unsubscribe();
+            }
+            clearPendingDebouncedCallback(eventCallback);
+        };
+    }, [active, eventsKey, eventCallback, modelClass, onConnected]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-model-class-event.js","sourceRoot":"","sources":["../../../src/frontend-models/use-model-class-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\"\n\n/** @typedef {typeof import(\"./base.js\").default} FrontendModelClass */\n/** @typedef {InstanceType<FrontendModelClass>} FrontendModelInstance */\n/** @typedef {\"create\" | \"update\" | \"destroy\"} FrontendModelClassEventName */\n/** @typedef {{id: string, model: FrontendModelInstance}} FrontendModelCreateUpdateEventPayload */\n/** @typedef {{id: string}} FrontendModelDestroyEventPayload */\n/** @typedef {FrontendModelCreateUpdateEventPayload | FrontendModelDestroyEventPayload} FrontendModelClassEventPayload */\n/** @typedef {(payload: FrontendModelClassEventPayload) => void} FrontendModelClassEventCallback */\n/** @typedef {{active?: boolean, debounce?: boolean | number, onConnected?: () => void}} UseModelClassEventOptions */\n\n/**\n * @param {FrontendModelClassEventName | FrontendModelClassEventName[]} eventOrEvents - Event name or names.\n * @returns {FrontendModelClassEventName[]} - Normalized event names.\n */\nfunction normalizeEventNames(eventOrEvents) {\n  return Array.isArray(eventOrEvents) ? eventOrEvents : [eventOrEvents]\n}\n\n/**\n * @param {FrontendModelClassEventName[]} eventNames - Event names.\n * @returns {string} - Stable dependency key.\n */\nfunction eventNamesDependencyKey(eventNames) {\n  return eventNames.join(\"|\")\n}\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 useModelClassEvent: ${unknownOptionNames.join(\", \")}`)\n  }\n}\n\n/**\n * @param {FrontendModelClass} modelClass - Frontend model class.\n * @param {FrontendModelClassEventName} eventName - Event name.\n * @param {FrontendModelClassEventCallback} callback - Event callback.\n * @returns {Promise<() => void>} - Unsubscribe callback.\n */\nasync function subscribeToModelClassEvent(modelClass, eventName, callback) {\n  if (eventName === \"create\") return await modelClass.onCreate(callback)\n  if (eventName === \"update\") return await modelClass.onUpdate(callback)\n  if (eventName === \"destroy\") return await modelClass.onDestroy(callback)\n\n  throw new Error(`Unsupported frontend model class event: ${eventName}`)\n}\n\n/**\n * React hook for frontend-model class lifecycle events.\n * @param {FrontendModelClass | null | undefined} modelClass - Frontend model class.\n * @param {FrontendModelClassEventName | FrontendModelClassEventName[]} eventOrEvents - Event name or names.\n * @param {FrontendModelClassEventCallback} callback - Event callback.\n * @param {UseModelClassEventOptions} [options] - Hook options.\n * @returns {void}\n */\nexport default function useModelClassEvent(modelClass, eventOrEvents, callback, options = {}) {\n  const {active = true, debounce = false, onConnected, ...restOptions} = options\n  assertNoUnknownOptions(restOptions)\n\n  const callbackRef = useRef(callback)\n  const activeRef = useRef(active)\n  callbackRef.current = callback\n  activeRef.current = active\n\n  const eventNames = normalizeEventNames(eventOrEvents)\n  const eventsKey = eventNamesDependencyKey(eventNames)\n  const eventCallback = useMemo(() => {\n    const wrappedCallback = (/** @type {FrontendModelClassEventPayload} */ 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 || !modelClass) return undefined\n\n    let closed = false\n    /** @type {Array<() => void>} */\n    const unsubscribeCallbacks = []\n    const subscriptionCallback = (/** @type {FrontendModelClassEventPayload} */ payload) => {\n      if (!closed) eventCallback(payload)\n    }\n\n    void (async () => {\n      for (const eventName of eventNames) {\n        const unsubscribe = await subscribeToModelClassEvent(modelClass, eventName, 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, eventsKey, eventCallback, modelClass, onConnected])\n}\n"]}

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"}