@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/use-model-class-event.js

@@ -1,9 +1,19 @@
+// @ts-check
 import { ShapeHook, useShapeHook } from "set-state-compare";
 import { useEffect } from "react";
 import ModelEvents from "./model-events.js"; // eslint-disable-line sort-imports
 import PropTypes from "prop-types";
 import debounceFunction from "debounce";
 import propTypesExact from "prop-types-exact";
+/** @typedef {import("./base-model.js").default} BaseModel */
+/** @typedef {string | number | boolean | null} EventArgumentPrimitive */
+/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */
+/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string}} ModelClassEventPayload */
+/** @typedef {{model: BaseModel}} CreatedEventPayload */
+/** @typedef {CreatedEventPayload | ModelClassEventPayload} ModelClassSubscriptionPayload */
+/** @typedef {{active?: boolean, debounce?: boolean|number, onConnected?: () => void}} UseModelClassEventArgs */
+/** @typedef {typeof import("./base-model.js").default} ModelClassType */
+/** @typedef {(payload: ModelClassSubscriptionPayload) => void} EventCallback */
 /** Hook state container for model-class event subscriptions. */
 class UseModelClassEventShapeHook extends ShapeHook {
     static defaultProps = {
@@ -12,7 +22,7 @@ class UseModelClassEventShapeHook extends ShapeHook {
         onConnected: undefined
     };
     static propTypes = propTypesExact({
-        active: PropTypes.bool.isRequired,
+        active: PropTypes.bool,
         debounce: PropTypes.oneOfType([
             PropTypes.bool,
             PropTypes.number
@@ -31,22 +41,26 @@ class UseModelClassEventShapeHook extends ShapeHook {
             return debounceFunction(this.p.onCallback);
         }, [this.p.debounce, this.p.onCallback]);
     }
-    /** @param {any[]} callbackArgs */
-    onModelClassEventCallback(...callbackArgs) {
+    /**
+     * Forwards a model-class subscription payload to the caller.
+     * @param {ModelClassSubscriptionPayload} payload
+     * @returns {void}
+     */
+    onModelClassEventCallback(payload) {
         if (!this.p.active) {
             return;
         }
         if (this.p.debounce) {
-            this.debouncedOnCallback()(...callbackArgs);
+            this.debouncedOnCallback()(payload);
         }
         else {
-            this.p.onCallback(...callbackArgs);
+            this.p.onCallback(payload);
         }
     }
     /** @returns {void} */
     setup() {
         useEffect(() => {
-            const callback = (...callbackArgs) => this.onModelClassEventCallback(...callbackArgs);
+            const callback = (payload) => this.onModelClassEventCallback(payload);
             const modelClassConnection = this.p.event == "creates"
                 ? ModelEvents.connectCreated(this.p.modelClass, callback)
                 : ModelEvents.connectModelClass(this.p.modelClass, this.p.event, callback);
@@ -63,16 +77,12 @@ class UseModelClassEventShapeHook extends ShapeHook {
     }
 }
 /**
- * @param {Function} modelClass
+ * @param {ModelClassType} modelClass
  * @param {string} event
- * @param {Function} onCallback
- * @param {object} [args]
-  * @param {boolean} [args.active]
-  * @param {number} [args.debounce]
-  * @param {Function} [args.onConnected]
-  * @returns {void}
-  */
-/** apiMakerUseModelClassEvent. */
+ * @param {EventCallback} onCallback
+ * @param {UseModelClassEventArgs} [args]
+ * @returns {void}
+ */
 // eslint-disable-next-line max-params
 const apiMakerUseModelClassEvent = (modelClass, event, onCallback, args = {}) => {
     const { active = true, debounce = 0, onConnected, ...restProps } = args;
@@ -82,4 +92,4 @@ const apiMakerUseModelClassEvent = (modelClass, event, onCallback, args = {}) =>
     useShapeHook(UseModelClassEventShapeHook, { active, debounce, event, modelClass, onCallback, onConnected });
 };
 export default apiMakerUseModelClassEvent;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-model-class-event.js","sourceRoot":"/src/","sources":["use-model-class-event.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport {ShapeHook, useShapeHook} from \"set-state-compare\"\nimport {useEffect} from \"react\"\nimport ModelEvents from \"./model-events.js\" // eslint-disable-line sort-imports\nimport PropTypes from \"prop-types\"\nimport debounceFunction from \"debounce\"\nimport propTypesExact from \"prop-types-exact\"\n\n/** @typedef {import(\"./base-model.js\").default} BaseModel */\n/** @typedef {string | number | boolean | null} EventArgumentPrimitive */\n/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */\n/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string}} ModelClassEventPayload */\n/** @typedef {{model: BaseModel}} CreatedEventPayload */\n/** @typedef {CreatedEventPayload | ModelClassEventPayload} ModelClassSubscriptionPayload */\n/** @typedef {{active?: boolean, debounce?: boolean|number, onConnected?: () => void}} UseModelClassEventArgs */\n/** @typedef {typeof import(\"./base-model.js\").default} ModelClassType */\n/** @typedef {(payload: ModelClassSubscriptionPayload) => void} EventCallback */\n\n/** Hook state container for model-class event subscriptions. */\nclass UseModelClassEventShapeHook extends ShapeHook {\n  static defaultProps = {\n    active: true,\n    debounce: 0,\n    onConnected: undefined\n  }\n\n  static propTypes = propTypesExact({\n    active: PropTypes.bool,\n    debounce: PropTypes.oneOfType([\n      PropTypes.bool,\n      PropTypes.number\n    ]),\n    event: PropTypes.string.isRequired,\n    modelClass: PropTypes.func.isRequired,\n    onCallback: PropTypes.func.isRequired,\n    onConnected: PropTypes.func\n  })\n\n  /** @returns {Function} */\n  debouncedOnCallback() {\n    return this.cache(\n      \"debouncedOnCallback\",\n      () => {\n        if (typeof this.p.debounce == \"number\") {\n          return debounceFunction(this.p.onCallback, this.p.debounce)\n        }\n\n        return debounceFunction(this.p.onCallback)\n      },\n      [this.p.debounce, this.p.onCallback]\n    )\n  }\n\n  /**\n   * Forwards a model-class subscription payload to the caller.\n   * @param {ModelClassSubscriptionPayload} payload\n   * @returns {void}\n   */\n  onModelClassEventCallback(payload) {\n    if (!this.p.active) {\n      return\n    }\n\n    if (this.p.debounce) {\n      this.debouncedOnCallback()(payload)\n    } else {\n      this.p.onCallback(payload)\n    }\n  }\n\n  /** @returns {void} */\n  setup() {\n    useEffect(() => {\n      const callback = (payload) => this.onModelClassEventCallback(payload)\n      const modelClassConnection = this.p.event == \"creates\"\n        ? ModelEvents.connectCreated(this.p.modelClass, callback)\n        : ModelEvents.connectModelClass(this.p.modelClass, this.p.event, callback)\n\n      if (this.p.onConnected) {\n        modelClassConnection.events.addListener(\"connected\", this.p.onConnected)\n      }\n\n      return () => {\n        if (this.p.onConnected) {\n          modelClassConnection.events.removeListener(\"connected\", this.p.onConnected)\n        }\n\n        modelClassConnection.unsubscribe()\n      }\n    }, [])\n  }\n}\n\n/**\n * @param {ModelClassType} modelClass\n * @param {string} event\n * @param {EventCallback} onCallback\n * @param {UseModelClassEventArgs} [args]\n * @returns {void}\n */\n// eslint-disable-next-line max-params\nconst apiMakerUseModelClassEvent = (modelClass, event, onCallback, args = {}) => {\n  const {active = true, debounce = 0, onConnected, ...restProps} = args\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to apiMakerUseModelClassEvent: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  useShapeHook(UseModelClassEventShapeHook, {active, debounce, event, modelClass, onCallback, onConnected})\n}\n\nexport default apiMakerUseModelClassEvent\n"]}

package/build/use-model-event.d.ts

@@ -1,14 +1,127 @@
 export default apiMakerUseModelEvent;
+export type EventArgumentPrimitive = string | number | boolean | null;
+export type EventArgumentValue = EventArgumentPrimitive | EventArgumentPrimitive[];
+export type UseModelEventProps = {
+    active?: boolean;
+    debounce?: number;
+    onConnected?: () => void;
+};
+export type EventModel = {
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("./base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+};
+export type EventModelWithId = EventModel & {
+    id: () => number | string;
+};
+export type ModelEventPayload = {
+    args: Record<string, EventArgumentValue>;
+    eventName: string;
+    model: EventModel;
+};
+export type EventCallback = (payload: ModelEventPayload) => void;
 /**
- * @param {import("./base-model.js").default|import("./base-model.js").default[]} model
+ * @param {EventModel | EventModel[]} model
  * @param {string} event
- * @param {Function} onCallback
- * @param {object} [props]
- * @param {boolean} [props.active]
- * @param {number} [props.debounce]
- * @param {Function} [props.onConnected]
+ * @param {EventCallback} onCallback
+ * @param {UseModelEventProps} [props]
  * @returns {void}
  */
-/** apiMakerUseModelEvent. */
-declare function apiMakerUseModelEvent(model: any, event: any, onCallback: any, props: any): void;
+declare function apiMakerUseModelEvent(model: EventModel | EventModel[], event: string, onCallback: EventCallback, props?: UseModelEventProps): void;
 //# sourceMappingURL=use-model-event.d.ts.map

package/build/use-model-event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-model-event.d.ts","sourceRoot":"/src/","sources":["use-model-event.js"],"names":[],"mappings":";AA0CA;;;;;;;;;GASG;AACH,6BAA6B;AAE7B,kGAwEC"}
+{"version":3,"file":"use-model-event.d.ts","sourceRoot":"/src/","sources":["use-model-event.js"],"names":[],"mappings":";qCAOc,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI;iCAChC,sBAAsB,GAAG,sBAAsB,EAAE;iCACjD;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA+Hk3xB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA7Hzh4B,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,MAAM,GAAC,MAAM,CAAA;CAAC;gCACtC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAC;4BAChF,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI;AAwClD;;;;;;GAMG;AAEH,8CAPW,UAAU,GAAG,UAAU,EAAE,SACzB,MAAM,cACN,aAAa,UACb,kBAAkB,GAChB,IAAI,CA2EhB"}

package/build/use-model-event.js

@@ -1,11 +1,19 @@
+// @ts-check
 /* eslint-disable sort-imports */
 import { useCallback, useLayoutEffect, useMemo, useRef } from "react";
 import debounceFunction from "debounce";
 import ModelEvents from "./model-events.js";
 import useShape from "./use-shape.js";
+/** @typedef {string | number | boolean | null} EventArgumentPrimitive */
+/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */
+/** @typedef {{active?: boolean, debounce?: number, onConnected?: () => void}} UseModelEventProps */
+/** @typedef {import("./base-model.js").default} EventModel */
+/** @typedef {EventModel & {id: () => number|string}} EventModelWithId */
+/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string, model: EventModel}} ModelEventPayload */
+/** @typedef {(payload: ModelEventPayload) => void} EventCallback */
 /**
- * @param {object|object[]|undefined|null} modelOrModels
- * @returns {object[]}
+ * @param {EventModel | EventModel[] | undefined | null} modelOrModels
+ * @returns {EventModel[]}
  */
 const modelsFromInput = (modelOrModels) => {
     if (!modelOrModels) {
@@ -19,32 +27,29 @@ const modelsFromInput = (modelOrModels) => {
     }
 };
 /**
- * @param {object|object[]|undefined|null} modelOrModels
+ * @param {EventModel | EventModel[] | undefined | null} modelOrModels
  * @returns {string}
  */
-const modelsDependencyKey = (modelOrModels) => JSON.stringify(modelsFromInput(modelOrModels).map((model) => model.id()));
+const modelsDependencyKey = (modelOrModels) => JSON.stringify(modelsFromInput(modelOrModels).map((model) => /** @type {EventModelWithId} */ (model).id()));
 /**
- * @param {object|object[]|undefined|null} modelOrModels
- * @returns {Record<string, object>}
+ * @param {EventModel | EventModel[] | undefined | null} modelOrModels
+ * @returns {Record<string, EventModelWithId>}
  */
 const modelsByIdFromInput = (modelOrModels) => {
-    const modelsById = {};
+    const modelsById = /** @type {Record<string, EventModelWithId>} */ ({});
     modelsFromInput(modelOrModels).forEach((model) => {
-        modelsById[model.id()] = model;
+        const modelWithId = /** @type {EventModelWithId} */ (model);
+        modelsById[modelWithId.id()] = modelWithId;
     });
     return modelsById;
 };
 /**
- * @param {import("./base-model.js").default|import("./base-model.js").default[]} model
+ * @param {EventModel | EventModel[]} model
  * @param {string} event
- * @param {Function} onCallback
- * @param {object} [props]
- * @param {boolean} [props.active]
- * @param {number} [props.debounce]
- * @param {Function} [props.onConnected]
+ * @param {EventCallback} onCallback
+ * @param {UseModelEventProps} [props]
  * @returns {void}
  */
-/** apiMakerUseModelEvent. */
 // eslint-disable-next-line max-params
 const apiMakerUseModelEvent = (model, event, onCallback, props) => {
     const { active = true, debounce, onConnected, ...restProps } = props || {};
@@ -62,15 +67,15 @@ const apiMakerUseModelEvent = (model, event, onCallback, props) => {
         }
     }, [debounce]);
     s.updateMeta({ debounceCallback });
-    const onCallbackCallback = useCallback((...args) => {
+    const onCallbackCallback = useCallback((payload) => {
         if (!s.p.active) {
             return;
         }
         if (s.p.debounce) {
-            s.m.debounceCallback(...args);
+            s.m.debounceCallback(payload);
         }
         else {
-            s.p.onCallback(...args);
+            s.p.onCallback(payload);
         }
     }, []);
     useLayoutEffect(() => {
@@ -107,4 +112,4 @@ const apiMakerUseModelEvent = (model, event, onCallback, props) => {
     }, []);
 };
 export default apiMakerUseModelEvent;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-model-event.js","sourceRoot":"/src/","sources":["use-model-event.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable sort-imports */\nimport {useCallback, useLayoutEffect, useMemo, useRef} from \"react\"\nimport debounceFunction from \"debounce\"\nimport ModelEvents from \"./model-events.js\"\nimport useShape from \"./use-shape.js\"\n\n/**\n * @param {object|object[]|undefined|null} modelOrModels\n * @returns {object[]}\n */\nconst modelsFromInput = (modelOrModels) => {\n  if (!modelOrModels) {\n    return []\n  } else if (Array.isArray(modelOrModels)) {\n    return modelOrModels.filter(Boolean)\n  } else {\n    return [modelOrModels]\n  }\n}\n\n/**\n * @param {object|object[]|undefined|null} modelOrModels\n * @returns {string}\n */\nconst modelsDependencyKey = (modelOrModels) => JSON.stringify(\n  modelsFromInput(modelOrModels).map((model) => model.id())\n)\n\n/**\n * @param {object|object[]|undefined|null} modelOrModels\n * @returns {Record<string, object>}\n */\nconst modelsByIdFromInput = (modelOrModels) => {\n  const modelsById = {}\n\n  modelsFromInput(modelOrModels).forEach((model) => {\n    modelsById[model.id()] = model\n  })\n\n  return modelsById\n}\n\n/**\n * @param {import(\"./base-model.js\").default|import(\"./base-model.js\").default[]} model\n * @param {string} event\n * @param {Function} onCallback\n * @param {object} [props]\n * @param {boolean} [props.active]\n * @param {number} [props.debounce]\n * @param {Function} [props.onConnected]\n * @returns {void}\n */\n/** apiMakerUseModelEvent. */\n// eslint-disable-next-line max-params\nconst apiMakerUseModelEvent = (model, event, onCallback, props) => {\n  const {active = true, debounce, onConnected, ...restProps} = props || {}\n  const connectionsRef = useRef({})\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to apiMakerUseModelEvent: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape({active, debounce, model, onCallback})\n\n  const debounceCallback = useMemo(() => {\n    if (typeof debounce == \"number\") {\n      return debounceFunction(s.p.onCallback, debounce)\n    } else {\n      return debounceFunction(s.p.onCallback)\n    }\n  }, [debounce])\n\n  s.updateMeta({debounceCallback})\n\n  const onCallbackCallback = useCallback((...args) => {\n    if (!s.p.active) {\n      return\n    }\n\n    if (s.p.debounce) {\n      s.m.debounceCallback(...args)\n    } else {\n      s.p.onCallback(...args)\n    }\n  }, [])\n\n  useLayoutEffect(() => {\n    const currentConnections = connectionsRef.current\n    const nextModelsById = modelsByIdFromInput(model)\n\n    Object.keys(currentConnections).forEach((modelId) => {\n      if (!(modelId in nextModelsById)) {\n        if (onConnected) {\n          currentConnections[modelId].events.removeListener(\"connected\", onConnected)\n        }\n\n        currentConnections[modelId].unsubscribe()\n        delete currentConnections[modelId]\n      }\n    })\n\n    Object.keys(nextModelsById).forEach((modelId) => {\n      if (modelId in currentConnections) {\n        return\n      }\n\n      const eventConnection = ModelEvents.connect(nextModelsById[modelId], event, onCallbackCallback)\n      currentConnections[modelId] = eventConnection\n\n      if (onConnected) {\n        eventConnection.events.addListener(\"connected\", onConnected)\n      }\n    })\n  }, [event, modelsDependencyKey(model)])\n\n  useLayoutEffect(() => () => {\n    Object.values(connectionsRef.current).forEach((eventConnection) => {\n      if (onConnected) {\n        eventConnection.events.removeListener(\"connected\", onConnected)\n      }\n\n      eventConnection.unsubscribe()\n    })\n\n    connectionsRef.current = {}\n  }, [])\n}\n\nexport default apiMakerUseModelEvent\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-model-event.js","sourceRoot":"/src/","sources":["use-model-event.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable sort-imports */\nimport {useCallback, useLayoutEffect, useMemo, useRef} from \"react\"\nimport debounceFunction from \"debounce\"\nimport ModelEvents from \"./model-events.js\"\nimport useShape from \"./use-shape.js\"\n\n/** @typedef {string | number | boolean | null} EventArgumentPrimitive */\n/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */\n/** @typedef {{active?: boolean, debounce?: number, onConnected?: () => void}} UseModelEventProps */\n/** @typedef {import(\"./base-model.js\").default} EventModel */\n/** @typedef {EventModel & {id: () => number|string}} EventModelWithId */\n/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string, model: EventModel}} ModelEventPayload */\n/** @typedef {(payload: ModelEventPayload) => void} EventCallback */\n\n/**\n * @param {EventModel | EventModel[] | undefined | null} modelOrModels\n * @returns {EventModel[]}\n */\nconst modelsFromInput = (modelOrModels) => {\n  if (!modelOrModels) {\n    return []\n  } else if (Array.isArray(modelOrModels)) {\n    return modelOrModels.filter(Boolean)\n  } else {\n    return [modelOrModels]\n  }\n}\n\n/**\n * @param {EventModel | EventModel[] | undefined | null} modelOrModels\n * @returns {string}\n */\nconst modelsDependencyKey = (modelOrModels) => JSON.stringify(\n  modelsFromInput(modelOrModels).map((model) => /** @type {EventModelWithId} */ (model).id())\n)\n\n/**\n * @param {EventModel | EventModel[] | undefined | null} modelOrModels\n * @returns {Record<string, EventModelWithId>}\n */\nconst modelsByIdFromInput = (modelOrModels) => {\n  const modelsById = /** @type {Record<string, EventModelWithId>} */ ({})\n\n  modelsFromInput(modelOrModels).forEach((model) => {\n    const modelWithId = /** @type {EventModelWithId} */ (model)\n\n    modelsById[modelWithId.id()] = modelWithId\n  })\n\n  return modelsById\n}\n\n/**\n * @param {EventModel | EventModel[]} model\n * @param {string} event\n * @param {EventCallback} onCallback\n * @param {UseModelEventProps} [props]\n * @returns {void}\n */\n// eslint-disable-next-line max-params\nconst apiMakerUseModelEvent = (model, event, onCallback, props) => {\n  const {active = true, debounce, onConnected, ...restProps} = props || {}\n  const connectionsRef = useRef({})\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to apiMakerUseModelEvent: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape({active, debounce, model, onCallback})\n\n  const debounceCallback = useMemo(() => {\n    if (typeof debounce == \"number\") {\n      return debounceFunction(s.p.onCallback, debounce)\n    } else {\n      return debounceFunction(s.p.onCallback)\n    }\n  }, [debounce])\n\n  s.updateMeta({debounceCallback})\n\n  const onCallbackCallback = useCallback((payload) => {\n    if (!s.p.active) {\n      return\n    }\n\n    if (s.p.debounce) {\n      s.m.debounceCallback(payload)\n    } else {\n      s.p.onCallback(payload)\n    }\n  }, [])\n\n  useLayoutEffect(() => {\n    const currentConnections = connectionsRef.current\n    const nextModelsById = modelsByIdFromInput(model)\n\n    Object.keys(currentConnections).forEach((modelId) => {\n      if (!(modelId in nextModelsById)) {\n        if (onConnected) {\n          currentConnections[modelId].events.removeListener(\"connected\", onConnected)\n        }\n\n        currentConnections[modelId].unsubscribe()\n        delete currentConnections[modelId]\n      }\n    })\n\n    Object.keys(nextModelsById).forEach((modelId) => {\n      if (modelId in currentConnections) {\n        return\n      }\n\n      const eventConnection = ModelEvents.connect(nextModelsById[modelId], event, onCallbackCallback)\n      currentConnections[modelId] = eventConnection\n\n      if (onConnected) {\n        eventConnection.events.addListener(\"connected\", onConnected)\n      }\n    })\n  }, [event, modelsDependencyKey(model)])\n\n  useLayoutEffect(() => () => {\n    Object.values(connectionsRef.current).forEach((eventConnection) => {\n      if (onConnected) {\n        eventConnection.events.removeListener(\"connected\", onConnected)\n      }\n\n      eventConnection.unsubscribe()\n    })\n\n    connectionsRef.current = {}\n  }, [])\n}\n\nexport default apiMakerUseModelEvent\n"]}