velocious 1.0.430 → 1.0.431

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

@@ -1,9 +1,12 @@
 // @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";
+
+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"
+
 /**
  * FrontendModelClass type.
   @typedef {typeof import("./base.js").default} FrontendModelClass */
@@ -25,27 +28,31 @@ import useModelClassEvent from "./use-model-class-event.js";
 /**
  * FrontendModelUpdateEventCallback type.
   @typedef {(payload: FrontendModelUpdateEventPayload) => void} FrontendModelUpdateEventCallback */
+
 /**
  * Runs assert no unknown options.
  * @param {Record<string, import("./query.js").FrontendModelTransportValue | (() => void) | undefined>} 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(", ")}`);
-    }
+  const unknownOptionNames = Object.keys(restOptions)
+
+  if (unknownOptionNames.length > 0) {
+    throw new Error(`Unknown options given to useUpdatedEvent: ${unknownOptionNames.join(", ")}`)
+  }
 }
+
 /**
  * Runs event query dependency payload.
  * @param {import("./query.js").default<FrontendModelClass> | undefined} query - Event query option.
  * @returns {import("./query.js").FrontendModelEventOptionsPayload | null} Stable dependency payload.
  */
 function eventQueryDependencyPayload(query) {
-    if (!query)
-        return null;
-    return query.eventOptionsPayload();
+  if (!query) return null
+
+  return query.eventOptionsPayload()
 }
+
 /**
  * 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.
@@ -55,18 +62,21 @@ function eventQueryDependencyPayload(query) {
  * @returns {void}
  */
 export default function useUpdatedEvent(modelClassOrModels, callback, options = {}) {
-    const { active = true, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount, ...restOptions } = options;
-    assertNoUnknownOptions(restOptions);
-    const classModel = typeof modelClassOrModels === "function" ? modelClassOrModels : null;
-    const instanceModels = typeof modelClassOrModels === "function" ? null : modelClassOrModels;
-    const projectionOptions = { abilities, preload, query, queryData, select, selectsExtra, withCount };
-    useModelClassEvent(classModel, "update", (payload) => {
-        callback(/**
-                  * Narrows the runtime value to the documented type.
-                   @type {FrontendModelClassUpdateEventPayload} */ (payload));
-    }, { active: active && Boolean(classModel), debounce, onConnected, ...projectionOptions });
-    useInstanceUpdatedEvent(instanceModels, callback, { active: active && !classModel, debounce, onConnected, ...projectionOptions });
+  const {active = true, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount, ...restOptions} = options
+  assertNoUnknownOptions(restOptions)
+
+  const classModel = typeof modelClassOrModels === "function" ? modelClassOrModels : null
+  const instanceModels = typeof modelClassOrModels === "function" ? null : modelClassOrModels
+  const projectionOptions = {abilities, preload, query, queryData, select, selectsExtra, withCount}
+
+  useModelClassEvent(classModel, "update", (payload) => {
+    callback(/**
+              * Narrows the runtime value to the documented type.
+               @type {FrontendModelClassUpdateEventPayload} */ (payload))
+  }, {active: active && Boolean(classModel), debounce, onConnected, ...projectionOptions})
+  useInstanceUpdatedEvent(instanceModels, callback, {active: active && !classModel, debounce, onConnected, ...projectionOptions})
 }
+
 /**
  * Runs use instance updated event.
  * @param {FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelOrModels - Model or models.
@@ -75,65 +85,68 @@ export default function useUpdatedEvent(modelClassOrModels, callback, options =
  * @returns {void}
  */
 function useInstanceUpdatedEvent(modelOrModels, callback, options) {
-    const { active = true, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount } = options;
-    const projectionKey = JSON.stringify({ abilities, preload, query: eventQueryDependencyPayload(query), queryData, select, selectsExtra, withCount });
-    const projectionOptionsRef = useRef({ abilities, preload, query, queryData, select, selectsExtra, withCount });
-    const callbackRef = useRef(callback);
-    const activeRef = useRef(active);
-    projectionOptionsRef.current = { abilities, preload, query, queryData, select, selectsExtra, withCount };
-    callbackRef.current = callback;
-    activeRef.current = active;
-    const modelsKey = modelsDependencyKey(modelOrModels);
-    const eventCallback = useMemo(() => {
-        const wrappedCallback = (/**
-                                  * Narrows the runtime value to the documented type.
-                                   @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;
-        /**
-         * Unsubscribe callbacks.
-          @type {Array<() => void>} */
-        const unsubscribeCallbacks = [];
-        const subscriptionCallback = (/**
-                                       * Narrows the runtime value to the documented type.
-                                        @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {
-            if (!closed)
-                eventCallback(payload);
-        };
-        void (async () => {
-            for (const model of models) {
-                const unsubscribe = await model.onUpdate(subscriptionCallback, projectionOptionsRef.current);
-                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, projectionKey]);
+  const {active = true, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount} = options
+  const projectionKey = JSON.stringify({abilities, preload, query: eventQueryDependencyPayload(query), queryData, select, selectsExtra, withCount})
+  const projectionOptionsRef = useRef({abilities, preload, query, queryData, select, selectsExtra, withCount})
+  const callbackRef = useRef(callback)
+  const activeRef = useRef(active)
+  projectionOptionsRef.current = {abilities, preload, query, queryData, select, selectsExtra, withCount}
+  callbackRef.current = callback
+  activeRef.current = active
+
+  const modelsKey = modelsDependencyKey(modelOrModels)
+  const eventCallback = useMemo(() => {
+    const wrappedCallback = (/**
+                              * Narrows the runtime value to the documented type.
+                               @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
+    /**
+     * Unsubscribe callbacks.
+      @type {Array<() => void>} */
+    const unsubscribeCallbacks = []
+    const subscriptionCallback = (/**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {
+      if (!closed) eventCallback(payload)
+    }
+
+    void (async () => {
+      for (const model of models) {
+        const unsubscribe = await model.onUpdate(subscriptionCallback, projectionOptionsRef.current)
+
+        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, projectionKey])
 }
-//# 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/**\n * FrontendModelClass type.\n  @typedef {typeof import(\"./base.js\").default} FrontendModelClass */\n/**\n * FrontendModelInstance type.\n  @typedef {import(\"./base.js\").default} FrontendModelInstance */\n/**\n * FrontendModelClassUpdateEventPayload type.\n  @typedef {import(\"./use-model-class-event.js\").FrontendModelCreateUpdateEventPayload} FrontendModelClassUpdateEventPayload */\n/**\n * Defines this typedef.\n  @typedef {{id: string, model: FrontendModelInstance}} FrontendModelInstanceUpdateEventPayload */\n/**\n * FrontendModelUpdateEventPayload type.\n  @typedef {FrontendModelClassUpdateEventPayload | FrontendModelInstanceUpdateEventPayload} FrontendModelUpdateEventPayload */\n/**\n * UseUpdatedEventOptions type.\n  @typedef {import(\"./use-model-class-event.js\").UseModelClassEventOptions} UseUpdatedEventOptions */\n/**\n * FrontendModelUpdateEventCallback type.\n  @typedef {(payload: FrontendModelUpdateEventPayload) => void} FrontendModelUpdateEventCallback */\n\n/**\n * Runs assert no unknown options.\n * @param {Record<string, import(\"./query.js\").FrontendModelTransportValue | (() => void) | undefined>} 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 * Runs event query dependency payload.\n * @param {import(\"./query.js\").default<FrontendModelClass> | undefined} query - Event query option.\n * @returns {import(\"./query.js\").FrontendModelEventOptionsPayload | null} Stable dependency payload.\n */\nfunction eventQueryDependencyPayload(query) {\n  if (!query) return null\n\n  return query.eventOptionsPayload()\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, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount, ...restOptions} = options\n  assertNoUnknownOptions(restOptions)\n\n  const classModel = typeof modelClassOrModels === \"function\" ? modelClassOrModels : null\n  const instanceModels = typeof modelClassOrModels === \"function\" ? null : modelClassOrModels\n  const projectionOptions = {abilities, preload, query, queryData, select, selectsExtra, withCount}\n\n  useModelClassEvent(classModel, \"update\", (payload) => {\n    callback(/**\n              * Narrows the runtime value to the documented type.\n               @type {FrontendModelClassUpdateEventPayload} */ (payload))\n  }, {active: active && Boolean(classModel), debounce, onConnected, ...projectionOptions})\n  useInstanceUpdatedEvent(instanceModels, callback, {active: active && !classModel, debounce, onConnected, ...projectionOptions})\n}\n\n/**\n * Runs use instance updated event.\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, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount} = options\n  const projectionKey = JSON.stringify({abilities, preload, query: eventQueryDependencyPayload(query), queryData, select, selectsExtra, withCount})\n  const projectionOptionsRef = useRef({abilities, preload, query, queryData, select, selectsExtra, withCount})\n  const callbackRef = useRef(callback)\n  const activeRef = useRef(active)\n  projectionOptionsRef.current = {abilities, preload, query, queryData, select, selectsExtra, withCount}\n  callbackRef.current = callback\n  activeRef.current = active\n\n  const modelsKey = modelsDependencyKey(modelOrModels)\n  const eventCallback = useMemo(() => {\n    const wrappedCallback = (/**\n                              * Narrows the runtime value to the documented type.\n                               @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    /**\n     * Unsubscribe callbacks.\n      @type {Array<() => void>} */\n    const unsubscribeCallbacks = []\n    const subscriptionCallback = (/**\n                                   * Narrows the runtime value to the documented type.\n                                    @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, projectionOptionsRef.current)\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, projectionKey])\n}\n"]}