@kaspernj/api-maker 1.0.2154 → 1.0.2155

package/build/cable-connection-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cable-connection-pool.d.ts","sourceRoot":"/src/","sources":["cable-connection-pool.js"],"names":[],"mappings":"AAOA,+DAA+D;AAC/D;IAME,eAAe;IACf,sBAIC;IAED,sBAAsB;IACtB,uBADc,IAAI,CAQjB;IApBD,8BAA2B;IAC3B,gBAAgB;IAChB,6BAA6B;IAC7B,0BAA0B;IAmB1B,0CAA0C;IAC1C;;;;gBAyBC;IAED,yBAAyB;IACzB;;;;0BAsDC;IAED,sBAAsB;IACtB,iBAAkB,cAAS,EAAE,aAAQ,uBAAkF;IAEvH,oBAAoB;IACpB,eAAgB,cAAS,EAAE,YAAO,EAAE,cAAS,EAAE,aAAQ,uBAIrD;IAEF,wBAAwB;IACxB,mBAAoB,cAAS,EAAE,YAAO,EAAE,aAAQ,uBAAsF;IAEtI,8BAA8B;IAC9B,yBAA0B,cAAS,EAAE,cAAS,EAAE,aAAQ,uBAAkG;IAE1J,qBAAqB;IACrB,gBAAiB,cAAS,EAAE,YAAO,EAAE,aAAQ,uBAAqF;IAElI,uBAAuB;IACvB,4BAaC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED,sBAAsB;IACtB,SADc,IAAI,CAYjB;IAED,wCAAkE;CACnE;8BAjL6B,yBAAyB;oBAEnC,eAAe"}
+{"version":3,"file":"cable-connection-pool.d.ts","sourceRoot":"/src/","sources":["cable-connection-pool.js"],"names":[],"mappings":"AAOA,+DAA+D;AAC/D;IAME,eAAe;IACf,sBAIC;IAED,sBAAsB;IACtB,uBADc,IAAI,CAQjB;IApBD,8BAA2B;IAC3B,gBAAgB;IAChB,6BAA6B;IAC7B,0BAA0B;IAmB1B,0CAA0C;IAC1C;;;;gBA0BC;IAED,yBAAyB;IACzB;;;;0BAsDC;IAED,sBAAsB;IACtB,iBAAkB,cAAS,EAAE,aAAQ,uBAAkF;IAEvH,oBAAoB;IACpB,eAAgB,cAAS,EAAE,YAAO,EAAE,cAAS,EAAE,aAAQ,uBAIrD;IAEF,wBAAwB;IACxB,mBAAoB,cAAS,EAAE,YAAO,EAAE,aAAQ,uBAAsF;IAEtI,8BAA8B;IAC9B,yBAA0B,cAAS,EAAE,cAAS,EAAE,aAAQ,uBAAkG;IAE1J,qBAAqB;IACrB,gBAAiB,cAAS,EAAE,YAAO,EAAE,aAAQ,uBAAqF;IAElI,uBAAuB;IACvB,4BAaC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED,sBAAsB;IACtB,SADc,IAAI,CAYjB;IAED,wCAAkE;CACnE;8BAlL6B,yBAAyB;oBAEnC,eAAe"}

package/build/cable-connection-pool.js

@@ -40,6 +40,7 @@ export default class ApiMakerCableConnectionPool {
                     }
                     existingSubscriptions.push(subscription);
                     cableSubscriptionPool.connectUnsubscriptionForSubscription(subscription);
+                    subscription.events.emit("connected");
                     return true;
                 }
             }
@@ -139,4 +140,4 @@ export default class ApiMakerCableConnectionPool {
     }
     scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cable-connection-pool.js","sourceRoot":"/src/","sources":["cable-connection-pool.js"],"names":[],"mappings":"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","sourcesContent":["import {dig} from \"diggerize\"\nimport CableSubscription from \"./cable-subscription.js\" // eslint-disable-line sort-imports\nimport CableSubscriptionPool from \"./cable-subscription-pool.js\"\nimport RunLast from \"./run-last.js\"\n\nconst shared = {}\n\n/** ActionCable connection pool keyed by stream identifiers. */\nexport default class ApiMakerCableConnectionPool {\n  cableSubscriptionPools = []\n  connections = {}\n  upcomingSubscriptionData = {}\n  upcomingSubscriptions = {}\n\n  /** current. */\n  static current () {\n    if (!shared.apiMakerCableConnectionPool) shared.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()\n\n    return shared.apiMakerCableConnectionPool\n  }\n\n  /** @returns {void} */\n  static resetCurrent () {\n    if (!shared.apiMakerCableConnectionPool) {\n      return\n    }\n\n    shared.apiMakerCableConnectionPool.reset()\n    delete shared.apiMakerCableConnectionPool\n  }\n\n  /** connectEventToExistingSubscription. */\n  connectEventToExistingSubscription ({path, subscription, value}) {\n    for (const cableSubscriptionPool of this.cableSubscriptionPools) {\n      if (cableSubscriptionPool.isConnected()) {\n        let existingSubscriptions\n\n        if (value === true) {\n          existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path)\n        } else {\n          existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path, value)\n        }\n\n        if (existingSubscriptions !== undefined) {\n          if (!Array.isArray(existingSubscriptions)) {\n            throw new Error(`existingSubscriptions wasn't an array: ${typeof existingSubscriptions} (${dig(existingSubscriptions, \"constructor\", \"name\")})`)\n          }\n\n          existingSubscriptions.push(subscription)\n          cableSubscriptionPool.connectUnsubscriptionForSubscription(subscription)\n\n          return true\n        }\n      }\n    }\n\n    return false\n  }\n\n  /** connectModelEvent. */\n  connectModelEvent ({callback, path, value}) {\n    const subscription = new CableSubscription()\n\n    subscription.events.addListener(\"received\", callback)\n\n    if (this.connectEventToExistingSubscription({path, subscription, value})) {\n      // Managed to connect to existing connection\n      return subscription\n    }\n\n    let currentSubscriptionData = this.upcomingSubscriptionData\n    let currentSubscription = this.upcomingSubscriptions\n\n    for (let i = 0; i < path.length; i++) {\n      const pathPart = path[i]\n\n      if (!(pathPart in currentSubscriptionData)) {\n        if (i == path.length - 1) {\n          currentSubscriptionData[pathPart] = []\n        } else {\n          currentSubscriptionData[pathPart] = {}\n        }\n      }\n\n      currentSubscriptionData = currentSubscriptionData[pathPart]\n\n      if (!(pathPart in currentSubscription)) {\n        if (value === true && i == path.length - 1) {\n          currentSubscription[pathPart] = []\n        } else {\n          currentSubscription[pathPart] = {}\n        }\n      }\n\n      currentSubscription = currentSubscription[pathPart]\n    }\n\n    if (!currentSubscriptionData.includes(value)) {\n      currentSubscriptionData.push(value)\n    }\n\n    if (value === true) {\n      currentSubscription.push(subscription)\n    } else {\n      if (!(value in currentSubscription)) {\n        currentSubscription[value] = []\n      }\n\n      currentSubscription[value].push(subscription)\n    }\n\n    this.scheduleConnectUpcomingRunLast.queue()\n\n    return subscription\n  }\n\n  /** connectCreated. */\n  connectCreated = (modelName, callback) => this.connectModelEvent({callback, value: true, path: [modelName, \"creates\"]})\n\n  /** connectEvent. */\n  connectEvent = (modelName, modelId, eventName, callback) => this.connectModelEvent({ // eslint-disable-line max-params\n    callback,\n    value: modelId,\n    path: [modelName, \"events\", eventName]\n  })\n\n  /** connectDestroyed. */\n  connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"destroys\"]})\n\n  /** connectModelClassEvent. */\n  connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({callback, value: eventName, path: [modelName, \"model_class_events\"]})\n\n  /** connectUpdate. */\n  connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"updates\"]})\n\n  /** connectUpcoming. */\n  connectUpcoming = () => {\n    const subscriptionData = this.upcomingSubscriptionData\n    const subscriptions = this.upcomingSubscriptions\n\n    this.upcomingSubscriptionData = {}\n    this.upcomingSubscriptions = {}\n\n    const cableSubscriptionPool = new CableSubscriptionPool()\n\n    cableSubscriptionPool.registerSubscriptions(subscriptions)\n    cableSubscriptionPool.connect(subscriptionData)\n\n    this.cableSubscriptionPools.push(cableSubscriptionPool)\n  }\n\n  /**\n   * Refreshes auth across the existing subscription pools.\n   *\n   * @param {Record<string, any>} args\n   * @returns {Promise<void>}\n   */\n  async refreshAuthentication (args) {\n    await Promise.all(\n      this.cableSubscriptionPools.map((cableSubscriptionPool) => cableSubscriptionPool.refreshAuthentication(args))\n    )\n  }\n\n  /** @returns {void} */\n  reset () {\n    this.scheduleConnectUpcomingRunLast.clearTimeout()\n\n    this.cableSubscriptionPools.forEach((cableSubscriptionPool) => {\n      cableSubscriptionPool.reset()\n    })\n\n    this.cableSubscriptionPools = []\n    this.connections = {}\n    this.upcomingSubscriptionData = {}\n    this.upcomingSubscriptions = {}\n  }\n\n  scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cable-connection-pool.js","sourceRoot":"/src/","sources":["cable-connection-pool.js"],"names":[],"mappings":"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","sourcesContent":["import {dig} from \"diggerize\"\nimport CableSubscription from \"./cable-subscription.js\" // eslint-disable-line sort-imports\nimport CableSubscriptionPool from \"./cable-subscription-pool.js\"\nimport RunLast from \"./run-last.js\"\n\nconst shared = {}\n\n/** ActionCable connection pool keyed by stream identifiers. */\nexport default class ApiMakerCableConnectionPool {\n  cableSubscriptionPools = []\n  connections = {}\n  upcomingSubscriptionData = {}\n  upcomingSubscriptions = {}\n\n  /** current. */\n  static current () {\n    if (!shared.apiMakerCableConnectionPool) shared.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()\n\n    return shared.apiMakerCableConnectionPool\n  }\n\n  /** @returns {void} */\n  static resetCurrent () {\n    if (!shared.apiMakerCableConnectionPool) {\n      return\n    }\n\n    shared.apiMakerCableConnectionPool.reset()\n    delete shared.apiMakerCableConnectionPool\n  }\n\n  /** connectEventToExistingSubscription. */\n  connectEventToExistingSubscription ({path, subscription, value}) {\n    for (const cableSubscriptionPool of this.cableSubscriptionPools) {\n      if (cableSubscriptionPool.isConnected()) {\n        let existingSubscriptions\n\n        if (value === true) {\n          existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path)\n        } else {\n          existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path, value)\n        }\n\n        if (existingSubscriptions !== undefined) {\n          if (!Array.isArray(existingSubscriptions)) {\n            throw new Error(`existingSubscriptions wasn't an array: ${typeof existingSubscriptions} (${dig(existingSubscriptions, \"constructor\", \"name\")})`)\n          }\n\n          existingSubscriptions.push(subscription)\n          cableSubscriptionPool.connectUnsubscriptionForSubscription(subscription)\n          subscription.events.emit(\"connected\")\n\n          return true\n        }\n      }\n    }\n\n    return false\n  }\n\n  /** connectModelEvent. */\n  connectModelEvent ({callback, path, value}) {\n    const subscription = new CableSubscription()\n\n    subscription.events.addListener(\"received\", callback)\n\n    if (this.connectEventToExistingSubscription({path, subscription, value})) {\n      // Managed to connect to existing connection\n      return subscription\n    }\n\n    let currentSubscriptionData = this.upcomingSubscriptionData\n    let currentSubscription = this.upcomingSubscriptions\n\n    for (let i = 0; i < path.length; i++) {\n      const pathPart = path[i]\n\n      if (!(pathPart in currentSubscriptionData)) {\n        if (i == path.length - 1) {\n          currentSubscriptionData[pathPart] = []\n        } else {\n          currentSubscriptionData[pathPart] = {}\n        }\n      }\n\n      currentSubscriptionData = currentSubscriptionData[pathPart]\n\n      if (!(pathPart in currentSubscription)) {\n        if (value === true && i == path.length - 1) {\n          currentSubscription[pathPart] = []\n        } else {\n          currentSubscription[pathPart] = {}\n        }\n      }\n\n      currentSubscription = currentSubscription[pathPart]\n    }\n\n    if (!currentSubscriptionData.includes(value)) {\n      currentSubscriptionData.push(value)\n    }\n\n    if (value === true) {\n      currentSubscription.push(subscription)\n    } else {\n      if (!(value in currentSubscription)) {\n        currentSubscription[value] = []\n      }\n\n      currentSubscription[value].push(subscription)\n    }\n\n    this.scheduleConnectUpcomingRunLast.queue()\n\n    return subscription\n  }\n\n  /** connectCreated. */\n  connectCreated = (modelName, callback) => this.connectModelEvent({callback, value: true, path: [modelName, \"creates\"]})\n\n  /** connectEvent. */\n  connectEvent = (modelName, modelId, eventName, callback) => this.connectModelEvent({ // eslint-disable-line max-params\n    callback,\n    value: modelId,\n    path: [modelName, \"events\", eventName]\n  })\n\n  /** connectDestroyed. */\n  connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"destroys\"]})\n\n  /** connectModelClassEvent. */\n  connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({callback, value: eventName, path: [modelName, \"model_class_events\"]})\n\n  /** connectUpdate. */\n  connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"updates\"]})\n\n  /** connectUpcoming. */\n  connectUpcoming = () => {\n    const subscriptionData = this.upcomingSubscriptionData\n    const subscriptions = this.upcomingSubscriptions\n\n    this.upcomingSubscriptionData = {}\n    this.upcomingSubscriptions = {}\n\n    const cableSubscriptionPool = new CableSubscriptionPool()\n\n    cableSubscriptionPool.registerSubscriptions(subscriptions)\n    cableSubscriptionPool.connect(subscriptionData)\n\n    this.cableSubscriptionPools.push(cableSubscriptionPool)\n  }\n\n  /**\n   * Refreshes auth across the existing subscription pools.\n   *\n   * @param {Record<string, any>} args\n   * @returns {Promise<void>}\n   */\n  async refreshAuthentication (args) {\n    await Promise.all(\n      this.cableSubscriptionPools.map((cableSubscriptionPool) => cableSubscriptionPool.refreshAuthentication(args))\n    )\n  }\n\n  /** @returns {void} */\n  reset () {\n    this.scheduleConnectUpcomingRunLast.clearTimeout()\n\n    this.cableSubscriptionPools.forEach((cableSubscriptionPool) => {\n      cableSubscriptionPool.reset()\n    })\n\n    this.cableSubscriptionPools = []\n    this.connections = {}\n    this.upcomingSubscriptionData = {}\n    this.upcomingSubscriptions = {}\n  }\n\n  scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming)\n}\n"]}

package/build/use-model.d.ts

@@ -2,7 +2,9 @@ export default useModel;
 export type useModelArgs = {
     callback?: (arg: object) => Function;
     args?: (arg: object) => object;
-    loadByQueryParam?: () => number | string;
+    loadByQueryParam?: (args: {
+        queryParams: Record<string, any> | undefined;
+    }) => number | string;
     cacheArgs?: any[];
     match?: {
         params: object;
@@ -123,24 +125,126 @@ export type useModelArgs = {
     }) => void;
     query?: import("./collection.js").default<any>;
 };
-/**
- * @typedef {object} useModelArgs
- * @property {(arg: object) => Function} [callback]
- * @property {(arg: object) => object} [args]
- * @property {() => number|string} [loadByQueryParam]
- * @property {any[]} [cacheArgs]
- * @property {{params: object}} [match]
- * @property {(ctx: { model: import("./base-model.js").default }) => void} [onDestroyed]
- * @property {import("./collection.js").default} [query]
- */
 /**
  * @param {Function|object} modelClassArg
  * @param {object | ((args: {modelClass: typeof import("./base-model.js").default}) => useModelArgs)} [argsArg]
+ * @returns {Record<string, any>}
  */
 /** useModel. */
 declare function useModel(modelClassArg: any, argsArg?: {}): {
-    model: any;
-    modelId: any;
-    notFound: any;
+    model: {
+        changes: {};
+        newRecord: boolean;
+        relationshipsCache: {};
+        relationships: {};
+        abilities: Record<string, any>;
+        modelData: {};
+        assignAttributes(newAttributes: Record<string, any>): void;
+        attributes(): Record<string, any>;
+        can(givenAbilityName: string): boolean;
+        clone(): /*elided*/ any;
+        cacheKey(): number | string;
+        localCacheKey(): string;
+        fullCacheKey(): string;
+        create(attributes?: Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: any;
+        }>;
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        getAttributes(): Record<string, any>;
+        handleResponseError(response: object): never;
+        identifierKey(): number | string;
+        _identifierKey: string | number;
+        isAssociationLoaded(associationName: string): boolean;
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        isAssociationPresent(associationName: string): boolean;
+        ensureAssociationLoaded(associationName: string): Promise<any>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+        isAttributeChanged(attributeName: string): boolean;
+        isChanged(): boolean;
+        isNewRecord(): boolean;
+        isPersisted(): boolean;
+        savedChangeToAttribute(attributeName: string): boolean;
+        setNewModel(model: /*elided*/ any): void;
+        setNewModelData(model: /*elided*/ any): void;
+        previousModelData: any;
+        _isDateChanged(oldValue: any, newValue: any): boolean | void;
+        _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+        _isStringChanged(oldValue: any, newValue: any): boolean | void;
+        modelClassData(): ModelClassDataType;
+        reload(): Promise<void>;
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        saveRaw(rawData: any, options?: {}): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        _refreshModelFromResponse(response: object): void;
+        _refreshModelDataFromResponse(response: object): void;
+        updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: object;
+            model: /*elided*/ any;
+        }>;
+        isValid(): never;
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: Record<string, any>;
+        }>;
+        modelClass(): Record<string, any>;
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        markForDestruction(): void;
+        _markedForDestruction: boolean;
+        markedForDestruction(): boolean;
+        uniqueKey(): number;
+        uniqueKeyValue: number;
+        _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+        readAttribute(attributeName: string): any;
+        readAttributeUnderscore(attributeName: string): any;
+        isAttributeLoaded(attributeName: any): boolean;
+        _isPresent(value: any): boolean;
+        _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+        _readBelongsToReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+        _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+        _readHasOneReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        _readModelDataFromArgs(args?: {
+            data?: {
+                b?: Record<string, any>;
+                a?: Record<string, any>;
+                r?: any;
+            };
+            collection?: import("./collection.js").default<any>;
+        }): void;
+        collection: import("./collection.js").default<any>;
+        preloadedRelationships: any;
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        primaryKey(): number | string;
+    };
+    modelId: string | number;
+    notFound: boolean;
 };
 //# sourceMappingURL=use-model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"use-model.d.ts","sourceRoot":"/src/","sources":["use-model.js"],"names":[],"mappings":";;eAWc,CAAC,GAAG,EAAE,MAAM,aAAa;WACzB,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM;uBACvB,MAAM,MAAM,GAAC,MAAM;gBACnB,GAAG,EAAE;YACL;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;kBAChB,CAAC,GAAG,EAAE;QAAE,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsQ69e,CAAC;;;;;;;;wBAA2iB,CAAC;;;;;iCAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAtQnokB,CAAA;KAAE,KAAK,IAAI;;;AAPzE;;;;;;;;;GASG;AAEH;;;GAGG;AACH,gBAAgB;AAEhB;;;;EAyPC"}
+{"version":3,"file":"use-model.d.ts","sourceRoot":"/src/","sources":["use-model.js"],"names":[],"mappings":";;eAWc,CAAC,GAAG,EAAE,MAAM,aAAa;WACzB,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM;uBACvB,CAAC,IAAI,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA;KAAC,KAAK,MAAM,GAAC,MAAM;gBACvE,GAAG,EAAE;YACL;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;kBAChB,CAAC,GAAG,EAAE;QAAE,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6Y8xX,CAAC;;;;;;;;wBAA2iB,CAAC;;;;;iCAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA7Yp8c,CAAA;KAAE,KAAK,IAAI;;;AAmXzE;;;;GAIG;AACH,gBAAgB;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAoB2zX,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAHjgd"}

package/build/use-model.js

@@ -1,228 +1,342 @@
 /* eslint-disable sort-imports */
-import { useCallback, useEffect, useRef } from "react";
+import { ShapeHook, useShapeHook } from "set-state-compare";
+import { useEffect } from "react";
 import Devise from "./devise.js";
 import * as inflection from "inflection";
 import ModelEvents from "./model-events.js";
 import useQueryParams from "on-location-changed/build/use-query-params.js";
-import useShape from "./use-shape.js";
 import useUpdatedEvent from "./use-updated-event.js";
 /**
  * @typedef {object} useModelArgs
  * @property {(arg: object) => Function} [callback]
  * @property {(arg: object) => object} [args]
- * @property {() => number|string} [loadByQueryParam]
+ * @property {(args: {queryParams: Record<string, any> | undefined}) => number|string} [loadByQueryParam]
  * @property {any[]} [cacheArgs]
  * @property {{params: object}} [match]
  * @property {(ctx: { model: import("./base-model.js").default }) => void} [onDestroyed]
  * @property {import("./collection.js").default} [query]
  */
-/**
- * @param {Function|object} modelClassArg
- * @param {object | ((args: {modelClass: typeof import("./base-model.js").default}) => useModelArgs)} [argsArg]
- */
-/** useModel. */
-// eslint-disable-next-line complexity
-const useModel = (modelClassArg, argsArg = {}) => {
-    const queryParams = useQueryParams();
-    const loadModelGenerationRef = useRef(0);
-    let args, modelClass;
-    if (typeof argsArg == "function") {
-        args = argsArg({ modelClass });
-    }
-    else {
-        args = argsArg;
-    }
-    const s = useShape(args);
-    s.useStates({
-        model: undefined,
-        notFound: undefined
-    });
-    if ("active" in s.props && !s.props.active) {
-        s.meta.active = false;
-    }
-    else {
-        s.meta.active = true;
-    }
-    if (typeof modelClassArg == "object") {
-        modelClass = modelClassArg.callback({ queryParams });
-    }
-    else {
-        modelClass = modelClassArg;
-    }
-    const paramsVariableName = `${modelClass.modelName().paramKey()}_id`;
-    let modelId;
-    if (args.loadByQueryParam) {
-        modelId = args.loadByQueryParam({ queryParams });
-    }
-    else if (!args.query) {
-        if (!args.match)
+/** Hook state container for useModel. */
+class UseModelShapeHook extends ShapeHook {
+    updatedConnectionFallbackTimeoutId = undefined;
+    /** Constructor. */
+    constructor(props) {
+        super(props);
+        this.initialLoadTriggered = false;
+        this.loadModelGeneration = 0;
+        this.newIfNoIdDefaultsResult = null;
+        this.queryParams = undefined;
+        this.updatedConnectionReady = false;
+    }
+    /** @returns {boolean} */
+    active() {
+        return !("active" in this.args()) || Boolean(this.args().active);
+    }
+    /** @returns {useModelArgs & Record<string, any>} */
+    args() {
+        if (typeof this.p.argsArg == "function") {
+            return this.p.argsArg({ modelClass: this.modelClass() });
+        }
+        return this.p.argsArg || {};
+    }
+    /** @returns {typeof import("./base-model.js").default} */
+    modelClass() {
+        if (typeof this.p.modelClassArg == "object") {
+            return this.p.modelClassArg.callback({ queryParams: this.queryParams });
+        }
+        return this.p.modelClassArg;
+    }
+    /** @returns {string} */
+    paramsVariableName() {
+        return `${this.modelClass().modelName()
+            .paramKey()}_id`;
+    }
+    /** @returns {number | string | undefined} */
+    modelId() {
+        if (this.args().loadByQueryParam) {
+            return this.args().loadByQueryParam({ queryParams: this.queryParams });
+        }
+        else if (this.args().query) {
+            return undefined;
+        }
+        else if (!this.args().match) {
             throw new Error("Both 'loadByQueryParam' and 'match' wasn't given");
-        modelId = args.match.params[paramsVariableName] || args.match.params.id;
+        }
+        return this.args().match.params[this.paramsVariableName()] || this.args().match.params.id;
+    }
+    /** @returns {string} */
+    modelVariableName() {
+        return inflection.camelize(this.modelClass().modelClassData().name, true);
+    }
+    /** @returns {any[]} */
+    cacheArgs() {
+        return [this.modelId()].concat(this.args().cacheArgs || [], this.queryParams);
+    }
+    /** @returns {boolean} */
+    shouldWaitForUpdatedConnection() {
+        return Boolean(this.args().eventUpdated && this.modelId() && !this.s.model);
+    }
+    /** @returns {object} */
+    newModelDataFromParams() {
+        return this.queryParams?.[this.modelClass().modelName()
+            .paramKey()] || {};
     }
-    const modelVariableName = inflection.camelize(modelClass.modelClassData().name, true);
-    const cacheArgs = [modelId];
-    const loadExistingModel = useCallback(async (loadModelGeneration) => {
+    /** @returns {boolean} */
+    hasAsyncDefaults() {
+        return Boolean(this.newIfNoIdDefaultsResult && typeof this.newIfNoIdDefaultsResult.then == "function");
+    }
+    /** @returns {object | null} */
+    syncDefaultsForNewModel() {
+        if (!this.args().newIfNoId?.defaults) {
+            return {};
+        }
+        else if (this.hasAsyncDefaults()) {
+            return null;
+        }
+        if (this.newIfNoIdDefaultsResult === null) {
+            const defaultsResult = this.args().newIfNoId.defaults();
+            if (defaultsResult && typeof defaultsResult.then == "function") {
+                this.newIfNoIdDefaultsResult = defaultsResult.catch((error) => {
+                    throw error;
+                });
+                return null;
+            }
+            this.newIfNoIdDefaultsResult = defaultsResult;
+        }
+        return this.newIfNoIdDefaultsResult || {};
+    }
+    /** @returns {import("./base-model.js").default | undefined} */
+    syncNewModel() {
+        if (!this.active() || !this.args().newIfNoId || this.modelId()) {
+            return undefined;
+        }
+        const defaults = this.syncDefaultsForNewModel();
+        if (defaults === null) {
+            return undefined;
+        }
+        return new (this.modelClass())({
+            isNewRecord: true,
+            data: { a: Object.assign(defaults, this.args().newAttributes, this.newModelDataFromParams()) }
+        });
+    }
+    /** @returns {import("./base-model.js").default | undefined} */
+    subscriptionModel() {
+        if (!this.args().eventUpdated) {
+            return undefined;
+        }
+        else if (this.s.model) {
+            return this.s.model;
+        }
+        else if (!this.modelId()) {
+            return undefined;
+        }
+        return new (this.modelClass())({
+            data: { a: { [this.modelClass().primaryKey()]: this.modelId() } }
+        });
+    }
+    /** @param {number} loadModelGeneration */
+    loadExistingModel = async (loadModelGeneration) => {
         let query;
-        if (s.m.modelId) {
-            query = modelClass.ransack({ id_eq: s.m.modelId });
+        if (this.modelId()) {
+            query = this.modelClass().ransack({ id_eq: this.modelId() });
         }
-        else if (s.m.args.query) {
-            query = s.m.args.query.clone();
+        else if (this.args().query) {
+            query = this.args().query.clone();
         }
         else {
-            throw new Error(`No model ID was given: ${s.m.modelId} by '${paramsVariableName}' in query params: ${Object.keys(s.props.match.params).join(", ")}`);
-        }
-        if (s.props.abilities)
-            query.abilities(s.p.abilities);
-        if (s.props.preload)
-            query.preload(s.p.preload);
-        if (s.props.select)
-            query.select(s.p.select);
+            const matchParams = this.args().match?.params || {};
+            throw new Error(`No model ID was given: ${this.modelId()} by '${this.paramsVariableName()}' in query params: ${Object.keys(matchParams).join(", ")}`);
+        }
+        if (this.args().abilities)
+            query.abilities(this.args().abilities);
+        if (this.args().preload)
+            query.preload(this.args().preload);
+        if (this.args().select)
+            query.select(this.args().select);
         const model = await query.first();
-        if (loadModelGeneration != loadModelGenerationRef.current)
+        if (loadModelGeneration != this.loadModelGeneration)
             return;
-        if (s.s.model &&
+        if (this.s.model &&
             model &&
-            !s.s.notFound &&
-            s.s.model.fullCacheKey() == model.fullCacheKey()) {
+            !this.s.notFound &&
+            this.s.model.fullCacheKey() == model.fullCacheKey()) {
             return;
         }
-        else if (!s.s.model && !model && s.s.notFound) {
+        else if (!this.s.model && !model && this.s.notFound) {
             return;
         }
-        s.set({ model, notFound: !model });
-    }, []);
-    const loadNewModel = useCallback(async (loadModelGeneration) => {
-        const ModelClass = modelClass;
-        const paramKey = ModelClass.modelName().paramKey();
-        const modelDataFromParams = s.m.queryParams?.[paramKey] || {};
+        this.setState({ model, notFound: !model });
+    };
+    /** @param {number} loadModelGeneration */
+    loadNewModel = async (loadModelGeneration) => {
         let defaults = {};
-        if (s.props.newIfNoId?.defaults) {
-            let defaultsResult = s.m.newIfNoIdDefaultsResult;
+        if (this.args().newIfNoId?.defaults) {
+            let defaultsResult = this.newIfNoIdDefaultsResult;
             if (defaultsResult === null) {
-                defaultsResult = s.props.newIfNoId.defaults();
+                defaultsResult = this.args().newIfNoId.defaults();
             }
-            s.meta.newIfNoIdDefaultsResult = null;
+            this.newIfNoIdDefaultsResult = null;
             defaults = await defaultsResult;
         }
-        const modelData = Object.assign(defaults, s.props.newAttributes, modelDataFromParams);
-        const model = new ModelClass({
+        const model = new (this.modelClass())({
             isNewRecord: true,
-            data: { a: modelData }
+            data: { a: Object.assign(defaults, this.args().newAttributes, this.newModelDataFromParams()) }
         });
-        if (loadModelGeneration != loadModelGenerationRef.current)
+        if (loadModelGeneration != this.loadModelGeneration)
             return;
-        s.set({ model });
-    }, []);
-    const loadModel = useCallback(async () => {
+        this.setState({ model, notFound: false });
+    };
+    /** @returns {Promise<void>} */
+    loadModel = async () => {
         // Only the newest model request may update state after route or auth changes.
-        const loadModelGeneration = loadModelGenerationRef.current + 1;
-        loadModelGenerationRef.current = loadModelGeneration;
-        if (!s.m.active) {
-            // Not active - don't do anything
-        }
-        else if (s.props.newIfNoId && !s.m.modelId) {
-            return await loadNewModel(loadModelGeneration);
-        }
-        else if (!s.props.optional || s.m.modelId || s.m.args.query) {
-            return await loadExistingModel(loadModelGeneration);
-        }
-    }, []);
-    const onDestroyed = useCallback(({ model }) => {
-        const forwardArgs = { model };
-        forwardArgs[s.m.modelVariableName] = model;
-        s.p.onDestroyed(forwardArgs);
-    }, []);
-    const onSignedIn = useCallback(() => {
-        loadModel();
-    }, []);
-    const onSignedOut = useCallback(() => {
-        loadModel();
-    }, []);
-    if (args.cacheArgs) {
-        cacheArgs.push(...args.cacheArgs);
-    }
-    cacheArgs.push(queryParams);
-    s.updateMeta({ args, modelId, modelVariableName, queryParams });
-    if (s.meta.syncNewModel == undefined)
-        s.meta.syncNewModel = false;
-    if (s.meta.newIfNoIdDefaultsResult == undefined)
-        s.meta.newIfNoIdDefaultsResult = null;
-    if (s.m.active && s.props.newIfNoId && !s.m.modelId && !s.s.model && !s.m.syncNewModel) {
-        if (s.props.newIfNoId?.defaults && s.m.newIfNoIdDefaultsResult === null) {
-            const defaultsResult = s.props.newIfNoId.defaults();
-            if (defaultsResult && typeof defaultsResult.then == "function") {
-                s.meta.newIfNoIdDefaultsResult = defaultsResult.catch((error) => {
-                    throw error;
-                });
-            }
-            else {
-                s.meta.newIfNoIdDefaultsResult = defaultsResult;
+        const loadModelGeneration = this.loadModelGeneration + 1;
+        this.initialLoadTriggered = true;
+        this.loadModelGeneration = loadModelGeneration;
+        if (this.active() && this.args().newIfNoId && !this.modelId()) {
+            await this.loadNewModel(loadModelGeneration);
+        }
+        else if (this.active() && (!this.args().optional || this.modelId() || this.args().query)) {
+            await this.loadExistingModel(loadModelGeneration);
+        }
+    };
+    /** @returns {void} */
+    clearUpdatedConnectionFallbackTimeout() {
+        if (this.updatedConnectionFallbackTimeoutId) {
+            clearTimeout(this.updatedConnectionFallbackTimeoutId);
+            this.updatedConnectionFallbackTimeoutId = undefined;
+        }
+    }
+    /** @returns {void} */
+    ensureInitialLoadFallback() {
+        if (!this.shouldWaitForUpdatedConnection() || this.initialLoadTriggered) {
+            return;
+        }
+        this.clearUpdatedConnectionFallbackTimeout();
+        this.updatedConnectionFallbackTimeoutId = setTimeout(() => {
+            if (!this.updatedConnectionReady && !this.initialLoadTriggered) {
+                this.loadModel();
             }
+        }, 1000);
+    }
+    /** @param {{model: import("./base-model.js").default}} args */
+    onDestroyed = (args) => {
+        const forwardArgs = { model: args.model };
+        forwardArgs[this.modelVariableName()] = args.model;
+        this.args().onDestroyed(forwardArgs);
+    };
+    /** @returns {void} */
+    onSignedIn = () => {
+        this.loadModel();
+    };
+    /** @returns {void} */
+    onSignedOut = () => {
+        this.loadModel();
+    };
+    /** @returns {void} */
+    onUpdatedEventConnected = () => {
+        this.updatedConnectionReady = true;
+        this.clearUpdatedConnectionFallbackTimeout();
+        if (this.shouldWaitForUpdatedConnection() && !this.initialLoadTriggered) {
+            this.loadModel();
+        }
+    };
+    /** @returns {import("./base-model.js").default | undefined} */
+    visibleModel() {
+        let model = this.s.model;
+        if (!model) {
+            model = this.syncNewModel();
         }
-        if (!(s.m.newIfNoIdDefaultsResult && typeof s.m.newIfNoIdDefaultsResult.then == "function")) {
-            const ModelClass = modelClass;
-            const paramKey = ModelClass.modelName().paramKey();
-            const modelDataFromParams = s.m.queryParams?.[paramKey] || {};
-            const modelData = Object.assign(s.m.newIfNoIdDefaultsResult || {}, s.props.newAttributes, modelDataFromParams);
-            const model = new ModelClass({
-                isNewRecord: true,
-                data: { a: modelData }
-            });
-            s.meta.syncNewModel = model;
-            s.set({ model });
-        }
-    }
-    // Start async model loading after mount so ShapeHook state updates do not race the mount lifecycle.
-    useEffect(() => { loadModel(); }, cacheArgs);
-    useEffect(() => () => {
-        loadModelGenerationRef.current += 1;
-    }, []);
-    useEffect(() => {
-        let reloadModelCallback;
-        if (args.events) {
-            reloadModelCallback = args.events.addListener("reloadModel", loadModel);
-        }
-        return () => {
-            if (reloadModelCallback) {
-                args.events.removeListener("reloadModel", loadModel);
+        if (!this.active()) {
+            return undefined;
+        }
+        else if (this.modelId() && model && model.id() != this.modelId()) {
+            return undefined;
+        }
+        else if (!this.modelId() && !this.args().query && !this.args().newIfNoId) {
+            return undefined;
+        }
+        return model;
+    }
+    /** @returns {boolean | undefined} */
+    visibleNotFound() {
+        if (!this.active()) {
+            return undefined;
+        }
+        else if (this.modelId() && this.visibleModel() === undefined) {
+            return undefined;
+        }
+        else if (!this.modelId() && !this.args().query && !this.args().newIfNoId) {
+            return undefined;
+        }
+        return this.s.notFound;
+    }
+    /** @returns {void} */
+    setup() {
+        this.useStates({
+            model: undefined,
+            notFound: undefined
+        });
+        this.setInstance({ queryParams: useQueryParams() });
+        useEffect(() => {
+            if (this.s.model === undefined) {
+                const syncNewModel = this.syncNewModel();
+                if (syncNewModel) {
+                    this.setState({ model: syncNewModel, notFound: false });
+                }
+            }
+            if (this.shouldWaitForUpdatedConnection()) {
+                this.ensureInitialLoadFallback();
             }
-        };
-    }, [args.events]);
-    useUpdatedEvent(args.eventUpdated ? s.s.model : undefined, loadModel, {
-        onConnected: loadModel
-    });
-    useEffect(() => {
-        Devise.events().addListener("onDeviseSignIn", onSignedIn);
-        Devise.events().addListener("onDeviseSignOut", onSignedOut);
-        return () => {
-            Devise.events().removeListener("onDeviseSignIn", onSignedIn);
-            Devise.events().removeListener("onDeviseSignOut", onSignedOut);
-        };
-    });
-    useEffect(() => {
-        let connectDestroyed;
-        if (s.s.model && args.onDestroyed) {
-            connectDestroyed = ModelEvents.connectDestroyed(s.s.model, onDestroyed);
-        }
-        return () => {
-            connectDestroyed?.unsubscribe();
-        };
-    }, [args.onDestroyed, s.s.model?.id()]);
-    let model = s.s.model;
-    let notFound = s.s.notFound;
-    if (!s.m.active) {
-        model = undefined;
-        notFound = undefined;
-    }
-    else if (modelId && model && model.id() != modelId) {
-        model = undefined;
-        notFound = undefined;
-    }
-    else if (!modelId && !args.query && !s.props.newIfNoId) {
-        model = undefined;
-        notFound = undefined;
+            else {
+                this.loadModel();
+            }
+        }, this.cacheArgs());
+        // Invalidate in-flight async responses so stale loads cannot write after unmount.
+        useEffect(() => () => {
+            this.clearUpdatedConnectionFallbackTimeout();
+            this.loadModelGeneration += 1;
+        }, []);
+        useEffect(() => {
+            if (!this.args().events)
+                return;
+            this.args().events.addListener("reloadModel", this.loadModel);
+            return () => {
+                this.args().events.removeListener("reloadModel", this.loadModel);
+            };
+        }, [this.args().events]);
+        useUpdatedEvent(this.subscriptionModel(), this.loadModel, {
+            onConnected: this.onUpdatedEventConnected
+        });
+        useEffect(() => {
+            Devise.events().addListener("onDeviseSignIn", this.onSignedIn);
+            Devise.events().addListener("onDeviseSignOut", this.onSignedOut);
+            return () => {
+                Devise.events().removeListener("onDeviseSignIn", this.onSignedIn);
+                Devise.events().removeListener("onDeviseSignOut", this.onSignedOut);
+            };
+        });
+        useEffect(() => {
+            if (!this.s.model || !this.args().onDestroyed)
+                return;
+            const connectDestroyed = ModelEvents.connectDestroyed(this.s.model, this.onDestroyed);
+            return () => {
+                connectDestroyed.unsubscribe();
+            };
+        }, [this.args().onDestroyed, this.s.model ? this.s.model.id() : undefined]);
     }
+}
+/**
+ * @param {Function|object} modelClassArg
+ * @param {object | ((args: {modelClass: typeof import("./base-model.js").default}) => useModelArgs)} [argsArg]
+ * @returns {Record<string, any>}
+ */
+/** useModel. */
+const useModel = (modelClassArg, argsArg = {}) => {
+    const shapeHook = useShapeHook(UseModelShapeHook, { argsArg, modelClassArg });
+    const model = shapeHook.visibleModel();
+    const modelId = shapeHook.modelId();
+    const notFound = shapeHook.visibleNotFound();
+    const modelVariableName = shapeHook.modelVariableName();
     const result = {
         model,
         modelId,
@@ -234,4 +348,4 @@ const useModel = (modelClassArg, argsArg = {}) => {
     return result;
 };
 export default useModel;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-model.js","sourceRoot":"/src/","sources":["use-model.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable sort-imports */\nimport {useCallback, useEffect, useRef} from \"react\"\nimport Devise from \"./devise.js\"\nimport * as inflection from \"inflection\"\nimport ModelEvents from \"./model-events.js\"\nimport useQueryParams from \"on-location-changed/build/use-query-params.js\"\nimport useShape from \"./use-shape.js\"\nimport useUpdatedEvent from \"./use-updated-event.js\"\n\n/**\n * @typedef {object} useModelArgs\n * @property {(arg: object) => Function} [callback]\n * @property {(arg: object) => object} [args]\n * @property {() => number|string} [loadByQueryParam]\n * @property {any[]} [cacheArgs]\n * @property {{params: object}} [match]\n * @property {(ctx: { model: import(\"./base-model.js\").default }) => void} [onDestroyed]\n * @property {import(\"./collection.js\").default} [query]\n */\n\n/**\n * @param {Function|object} modelClassArg\n * @param {object | ((args: {modelClass: typeof import(\"./base-model.js\").default}) => useModelArgs)} [argsArg]\n */\n/** useModel. */\n// eslint-disable-next-line complexity\nconst useModel = (modelClassArg, argsArg = {}) => {\n  const queryParams = useQueryParams()\n  const loadModelGenerationRef = useRef(0)\n  let args, modelClass\n\n  if (typeof argsArg == \"function\") {\n    args = argsArg({modelClass})\n  } else {\n    args = argsArg\n  }\n\n  const s = useShape(args)\n\n  s.useStates({\n    model: undefined,\n    notFound: undefined\n  })\n\n  if (\"active\" in s.props && !s.props.active) {\n    s.meta.active = false\n  } else {\n    s.meta.active = true\n  }\n\n  if (typeof modelClassArg == \"object\") {\n    modelClass = modelClassArg.callback({queryParams})\n  } else {\n    modelClass = modelClassArg\n  }\n\n  const paramsVariableName = `${modelClass.modelName().paramKey()}_id`\n  let modelId\n\n  if (args.loadByQueryParam) {\n    modelId = args.loadByQueryParam({queryParams})\n  } else if (!args.query) {\n    if (!args.match) throw new Error(\"Both 'loadByQueryParam' and 'match' wasn't given\")\n\n    modelId = args.match.params[paramsVariableName] || args.match.params.id\n  }\n\n  const modelVariableName = inflection.camelize(modelClass.modelClassData().name, true)\n  const cacheArgs = [modelId]\n\n  const loadExistingModel = useCallback(async (loadModelGeneration) => {\n    let query\n\n    if (s.m.modelId) {\n      query = modelClass.ransack({id_eq: s.m.modelId})\n    } else if (s.m.args.query) {\n      query = s.m.args.query.clone()\n    } else {\n      throw new Error(`No model ID was given: ${s.m.modelId} by '${paramsVariableName}' in query params: ${Object.keys(s.props.match.params).join(\", \")}`)\n    }\n\n    if (s.props.abilities) query.abilities(s.p.abilities)\n    if (s.props.preload) query.preload(s.p.preload)\n    if (s.props.select) query.select(s.p.select)\n\n    const model = await query.first()\n\n    if (loadModelGeneration != loadModelGenerationRef.current) return\n\n    if (\n      s.s.model &&\n      model &&\n      !s.s.notFound &&\n      s.s.model.fullCacheKey() == model.fullCacheKey()\n    ) {\n      return\n    } else if (!s.s.model && !model && s.s.notFound) {\n      return\n    }\n\n    s.set({model, notFound: !model})\n  }, [])\n\n  const loadNewModel = useCallback(async (loadModelGeneration) => {\n    const ModelClass = modelClass\n    const paramKey = ModelClass.modelName().paramKey()\n    const modelDataFromParams = s.m.queryParams?.[paramKey] || {}\n\n    let defaults = {}\n\n    if (s.props.newIfNoId?.defaults) {\n      let defaultsResult = s.m.newIfNoIdDefaultsResult\n\n      if (defaultsResult === null) {\n        defaultsResult = s.props.newIfNoId.defaults()\n      }\n\n      s.meta.newIfNoIdDefaultsResult = null\n      defaults = await defaultsResult\n    }\n\n    const modelData = Object.assign(defaults, s.props.newAttributes, modelDataFromParams)\n    const model = new ModelClass({\n      isNewRecord: true,\n      data: {a: modelData}\n    })\n\n    if (loadModelGeneration != loadModelGenerationRef.current) return\n\n    s.set({model})\n  }, [])\n\n  const loadModel = useCallback(async () => {\n    // Only the newest model request may update state after route or auth changes.\n    const loadModelGeneration = loadModelGenerationRef.current + 1\n\n    loadModelGenerationRef.current = loadModelGeneration\n    if (!s.m.active) {\n      // Not active - don't do anything\n    } else if (s.props.newIfNoId && !s.m.modelId) {\n      return await loadNewModel(loadModelGeneration)\n    } else if (!s.props.optional || s.m.modelId || s.m.args.query) {\n      return await loadExistingModel(loadModelGeneration)\n    }\n  }, [])\n\n  const onDestroyed = useCallback(({model}) => {\n    const forwardArgs = {model}\n\n    forwardArgs[s.m.modelVariableName] = model\n\n    s.p.onDestroyed(forwardArgs)\n  }, [])\n\n  const onSignedIn = useCallback(() => {\n    loadModel()\n  }, [])\n\n  const onSignedOut = useCallback(() => {\n    loadModel()\n  }, [])\n\n  if (args.cacheArgs) {\n    cacheArgs.push(...args.cacheArgs)\n  }\n\n  cacheArgs.push(queryParams)\n\n  s.updateMeta({args, modelId, modelVariableName, queryParams})\n  if (s.meta.syncNewModel == undefined) s.meta.syncNewModel = false\n  if (s.meta.newIfNoIdDefaultsResult == undefined) s.meta.newIfNoIdDefaultsResult = null\n\n  if (s.m.active && s.props.newIfNoId && !s.m.modelId && !s.s.model && !s.m.syncNewModel) {\n    if (s.props.newIfNoId?.defaults && s.m.newIfNoIdDefaultsResult === null) {\n      const defaultsResult = s.props.newIfNoId.defaults()\n\n      if (defaultsResult && typeof defaultsResult.then == \"function\") {\n        s.meta.newIfNoIdDefaultsResult = defaultsResult.catch((error) => {\n          throw error\n        })\n      } else {\n        s.meta.newIfNoIdDefaultsResult = defaultsResult\n      }\n    }\n\n    if (!(s.m.newIfNoIdDefaultsResult && typeof s.m.newIfNoIdDefaultsResult.then == \"function\")) {\n      const ModelClass = modelClass\n      const paramKey = ModelClass.modelName().paramKey()\n      const modelDataFromParams = s.m.queryParams?.[paramKey] || {}\n      const modelData = Object.assign(s.m.newIfNoIdDefaultsResult || {}, s.props.newAttributes, modelDataFromParams)\n      const model = new ModelClass({\n        isNewRecord: true,\n        data: {a: modelData}\n      })\n\n      s.meta.syncNewModel = model\n      s.set({model})\n    }\n  }\n\n  // Start async model loading after mount so ShapeHook state updates do not race the mount lifecycle.\n  useEffect(\n    () => { loadModel() },\n    cacheArgs\n  )\n\n  useEffect(() => () => {\n    loadModelGenerationRef.current += 1\n  }, [])\n\n  useEffect(() => {\n    let reloadModelCallback\n\n    if (args.events) {\n      reloadModelCallback = args.events.addListener(\"reloadModel\", loadModel)\n    }\n\n    return () => {\n      if (reloadModelCallback) {\n        args.events.removeListener(\"reloadModel\", loadModel)\n      }\n    }\n  }, [args.events])\n\n  useUpdatedEvent(args.eventUpdated ? s.s.model : undefined, loadModel, {\n    onConnected: loadModel\n  })\n\n  useEffect(() => {\n    Devise.events().addListener(\"onDeviseSignIn\", onSignedIn)\n    Devise.events().addListener(\"onDeviseSignOut\", onSignedOut)\n\n    return () => {\n      Devise.events().removeListener(\"onDeviseSignIn\", onSignedIn)\n      Devise.events().removeListener(\"onDeviseSignOut\", onSignedOut)\n    }\n  })\n\n  useEffect(() => {\n    let connectDestroyed\n\n    if (s.s.model && args.onDestroyed) {\n      connectDestroyed = ModelEvents.connectDestroyed(s.s.model, onDestroyed)\n    }\n\n    return () => {\n      connectDestroyed?.unsubscribe()\n    }\n  }, [args.onDestroyed, s.s.model?.id()])\n\n  let model = s.s.model\n  let notFound = s.s.notFound\n\n  if (!s.m.active) {\n    model = undefined\n    notFound = undefined\n  } else if (modelId && model && model.id() != modelId) {\n    model = undefined\n    notFound = undefined\n  } else if (!modelId && !args.query && !s.props.newIfNoId) {\n    model = undefined\n    notFound = undefined\n  }\n\n  const result = {\n    model,\n    modelId,\n    notFound\n  }\n\n  result[modelVariableName] = model\n  result[`${modelVariableName}Id`] = modelId\n  result[`${modelVariableName}NotFound`] = notFound\n\n  return result\n}\n\nexport default useModel\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-model.js","sourceRoot":"/src/","sources":["use-model.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable sort-imports */\nimport {ShapeHook, useShapeHook} from \"set-state-compare\"\nimport {useEffect} from \"react\"\nimport Devise from \"./devise.js\"\nimport * as inflection from \"inflection\"\nimport ModelEvents from \"./model-events.js\"\nimport useQueryParams from \"on-location-changed/build/use-query-params.js\"\nimport useUpdatedEvent from \"./use-updated-event.js\"\n\n/**\n * @typedef {object} useModelArgs\n * @property {(arg: object) => Function} [callback]\n * @property {(arg: object) => object} [args]\n * @property {(args: {queryParams: Record<string, any> | undefined}) => number|string} [loadByQueryParam]\n * @property {any[]} [cacheArgs]\n * @property {{params: object}} [match]\n * @property {(ctx: { model: import(\"./base-model.js\").default }) => void} [onDestroyed]\n * @property {import(\"./collection.js\").default} [query]\n */\n\n/** Hook state container for useModel. */\nclass UseModelShapeHook extends ShapeHook {\n  updatedConnectionFallbackTimeoutId = undefined\n\n  /** Constructor. */\n  constructor(props) {\n    super(props)\n    this.initialLoadTriggered = false\n    this.loadModelGeneration = 0\n    this.newIfNoIdDefaultsResult = null\n    this.queryParams = undefined\n    this.updatedConnectionReady = false\n  }\n\n  /** @returns {boolean} */\n  active() {\n    return !(\"active\" in this.args()) || Boolean(this.args().active)\n  }\n\n  /** @returns {useModelArgs & Record<string, any>} */\n  args() {\n    if (typeof this.p.argsArg == \"function\") {\n      return this.p.argsArg({modelClass: this.modelClass()})\n    }\n\n    return this.p.argsArg || {}\n  }\n\n  /** @returns {typeof import(\"./base-model.js\").default} */\n  modelClass() {\n    if (typeof this.p.modelClassArg == \"object\") {\n      return this.p.modelClassArg.callback({queryParams: this.queryParams})\n    }\n\n    return this.p.modelClassArg\n  }\n\n  /** @returns {string} */\n  paramsVariableName() {\n    return `${this.modelClass().modelName()\n      .paramKey()}_id`\n  }\n\n  /** @returns {number | string | undefined} */\n  modelId() {\n    if (this.args().loadByQueryParam) {\n      return this.args().loadByQueryParam({queryParams: this.queryParams})\n    } else if (this.args().query) {\n      return undefined\n    } else if (!this.args().match) {\n      throw new Error(\"Both 'loadByQueryParam' and 'match' wasn't given\")\n    }\n\n    return this.args().match.params[this.paramsVariableName()] || this.args().match.params.id\n  }\n\n  /** @returns {string} */\n  modelVariableName() {\n    return inflection.camelize(this.modelClass().modelClassData().name, true)\n  }\n\n  /** @returns {any[]} */\n  cacheArgs() {\n    return [this.modelId()].concat(this.args().cacheArgs || [], this.queryParams)\n  }\n\n  /** @returns {boolean} */\n  shouldWaitForUpdatedConnection() {\n    return Boolean(this.args().eventUpdated && this.modelId() && !this.s.model)\n  }\n\n  /** @returns {object} */\n  newModelDataFromParams() {\n    return this.queryParams?.[this.modelClass().modelName()\n      .paramKey()] || {}\n  }\n\n  /** @returns {boolean} */\n  hasAsyncDefaults() {\n    return Boolean(this.newIfNoIdDefaultsResult && typeof this.newIfNoIdDefaultsResult.then == \"function\")\n  }\n\n  /** @returns {object | null} */\n  syncDefaultsForNewModel() {\n    if (!this.args().newIfNoId?.defaults) {\n      return {}\n    } else if (this.hasAsyncDefaults()) {\n      return null\n    }\n\n    if (this.newIfNoIdDefaultsResult === null) {\n      const defaultsResult = this.args().newIfNoId.defaults()\n\n      if (defaultsResult && typeof defaultsResult.then == \"function\") {\n        this.newIfNoIdDefaultsResult = defaultsResult.catch((error) => {\n          throw error\n        })\n\n        return null\n      }\n\n      this.newIfNoIdDefaultsResult = defaultsResult\n    }\n\n    return this.newIfNoIdDefaultsResult || {}\n  }\n\n  /** @returns {import(\"./base-model.js\").default | undefined} */\n  syncNewModel() {\n    if (!this.active() || !this.args().newIfNoId || this.modelId()) {\n      return undefined\n    }\n\n    const defaults = this.syncDefaultsForNewModel()\n\n    if (defaults === null) {\n      return undefined\n    }\n\n    return new (this.modelClass())({\n      isNewRecord: true,\n      data: {a: Object.assign(defaults, this.args().newAttributes, this.newModelDataFromParams())}\n    })\n  }\n\n  /** @returns {import(\"./base-model.js\").default | undefined} */\n  subscriptionModel() {\n    if (!this.args().eventUpdated) {\n      return undefined\n    } else if (this.s.model) {\n      return this.s.model\n    } else if (!this.modelId()) {\n      return undefined\n    }\n\n    return new (this.modelClass())({\n      data: {a: {[this.modelClass().primaryKey()]: this.modelId()}}\n    })\n  }\n\n  /** @param {number} loadModelGeneration */\n  loadExistingModel = async (loadModelGeneration) => {\n    let query\n\n    if (this.modelId()) {\n      query = this.modelClass().ransack({id_eq: this.modelId()})\n    } else if (this.args().query) {\n      query = this.args().query.clone()\n    } else {\n      const matchParams = this.args().match?.params || {}\n\n      throw new Error(`No model ID was given: ${this.modelId()} by '${this.paramsVariableName()}' in query params: ${Object.keys(matchParams).join(\", \")}`)\n    }\n\n    if (this.args().abilities) query.abilities(this.args().abilities)\n    if (this.args().preload) query.preload(this.args().preload)\n    if (this.args().select) query.select(this.args().select)\n\n    const model = await query.first()\n\n    if (loadModelGeneration != this.loadModelGeneration) return\n\n    if (\n      this.s.model &&\n      model &&\n      !this.s.notFound &&\n      this.s.model.fullCacheKey() == model.fullCacheKey()\n    ) {\n      return\n    } else if (!this.s.model && !model && this.s.notFound) {\n      return\n    }\n\n    this.setState({model, notFound: !model})\n  }\n\n  /** @param {number} loadModelGeneration */\n  loadNewModel = async (loadModelGeneration) => {\n    let defaults = {}\n\n    if (this.args().newIfNoId?.defaults) {\n      let defaultsResult = this.newIfNoIdDefaultsResult\n\n      if (defaultsResult === null) {\n        defaultsResult = this.args().newIfNoId.defaults()\n      }\n\n      this.newIfNoIdDefaultsResult = null\n      defaults = await defaultsResult\n    }\n\n    const model = new (this.modelClass())({\n      isNewRecord: true,\n      data: {a: Object.assign(defaults, this.args().newAttributes, this.newModelDataFromParams())}\n    })\n\n    if (loadModelGeneration != this.loadModelGeneration) return\n\n    this.setState({model, notFound: false})\n  }\n\n  /** @returns {Promise<void>} */\n  loadModel = async () => {\n    // Only the newest model request may update state after route or auth changes.\n    const loadModelGeneration = this.loadModelGeneration + 1\n\n    this.initialLoadTriggered = true\n    this.loadModelGeneration = loadModelGeneration\n    if (this.active() && this.args().newIfNoId && !this.modelId()) {\n      await this.loadNewModel(loadModelGeneration)\n    } else if (this.active() && (!this.args().optional || this.modelId() || this.args().query)) {\n      await this.loadExistingModel(loadModelGeneration)\n    }\n  }\n\n  /** @returns {void} */\n  clearUpdatedConnectionFallbackTimeout() {\n    if (this.updatedConnectionFallbackTimeoutId) {\n      clearTimeout(this.updatedConnectionFallbackTimeoutId)\n      this.updatedConnectionFallbackTimeoutId = undefined\n    }\n  }\n\n  /** @returns {void} */\n  ensureInitialLoadFallback() {\n    if (!this.shouldWaitForUpdatedConnection() || this.initialLoadTriggered) {\n      return\n    }\n\n    this.clearUpdatedConnectionFallbackTimeout()\n    this.updatedConnectionFallbackTimeoutId = setTimeout(() => {\n      if (!this.updatedConnectionReady && !this.initialLoadTriggered) {\n        this.loadModel()\n      }\n    }, 1000)\n  }\n\n  /** @param {{model: import(\"./base-model.js\").default}} args */\n  onDestroyed = (args) => {\n    const forwardArgs = {model: args.model}\n\n    forwardArgs[this.modelVariableName()] = args.model\n\n    this.args().onDestroyed(forwardArgs)\n  }\n\n  /** @returns {void} */\n  onSignedIn = () => {\n    this.loadModel()\n  }\n\n  /** @returns {void} */\n  onSignedOut = () => {\n    this.loadModel()\n  }\n\n  /** @returns {void} */\n  onUpdatedEventConnected = () => {\n    this.updatedConnectionReady = true\n    this.clearUpdatedConnectionFallbackTimeout()\n\n    if (this.shouldWaitForUpdatedConnection() && !this.initialLoadTriggered) {\n      this.loadModel()\n    }\n  }\n\n  /** @returns {import(\"./base-model.js\").default | undefined} */\n  visibleModel() {\n    let model = this.s.model\n\n    if (!model) {\n      model = this.syncNewModel()\n    }\n\n    if (!this.active()) {\n      return undefined\n    } else if (this.modelId() && model && model.id() != this.modelId()) {\n      return undefined\n    } else if (!this.modelId() && !this.args().query && !this.args().newIfNoId) {\n      return undefined\n    }\n\n    return model\n  }\n\n  /** @returns {boolean | undefined} */\n  visibleNotFound() {\n    if (!this.active()) {\n      return undefined\n    } else if (this.modelId() && this.visibleModel() === undefined) {\n      return undefined\n    } else if (!this.modelId() && !this.args().query && !this.args().newIfNoId) {\n      return undefined\n    }\n\n    return this.s.notFound\n  }\n\n  /** @returns {void} */\n  setup() {\n    this.useStates({\n      model: undefined,\n      notFound: undefined\n    })\n    this.setInstance({queryParams: useQueryParams()})\n\n    useEffect(\n      () => {\n        if (this.s.model === undefined) {\n          const syncNewModel = this.syncNewModel()\n\n          if (syncNewModel) {\n            this.setState({model: syncNewModel, notFound: false})\n          }\n        }\n\n        if (this.shouldWaitForUpdatedConnection()) {\n          this.ensureInitialLoadFallback()\n        } else {\n          this.loadModel()\n        }\n      },\n      this.cacheArgs()\n    )\n\n    // Invalidate in-flight async responses so stale loads cannot write after unmount.\n    useEffect(() => () => {\n      this.clearUpdatedConnectionFallbackTimeout()\n      this.loadModelGeneration += 1\n    }, [])\n\n    useEffect(() => {\n      if (!this.args().events) return\n\n      this.args().events.addListener(\"reloadModel\", this.loadModel)\n\n      return () => {\n        this.args().events.removeListener(\"reloadModel\", this.loadModel)\n      }\n    }, [this.args().events])\n\n    useUpdatedEvent(this.subscriptionModel(), this.loadModel, {\n      onConnected: this.onUpdatedEventConnected\n    })\n\n    useEffect(() => {\n      Devise.events().addListener(\"onDeviseSignIn\", this.onSignedIn)\n      Devise.events().addListener(\"onDeviseSignOut\", this.onSignedOut)\n\n      return () => {\n        Devise.events().removeListener(\"onDeviseSignIn\", this.onSignedIn)\n        Devise.events().removeListener(\"onDeviseSignOut\", this.onSignedOut)\n      }\n    })\n\n    useEffect(() => {\n      if (!this.s.model || !this.args().onDestroyed) return\n\n      const connectDestroyed = ModelEvents.connectDestroyed(this.s.model, this.onDestroyed)\n\n      return () => {\n        connectDestroyed.unsubscribe()\n      }\n    }, [this.args().onDestroyed, this.s.model ? this.s.model.id() : undefined])\n  }\n}\n\n/**\n * @param {Function|object} modelClassArg\n * @param {object | ((args: {modelClass: typeof import(\"./base-model.js\").default}) => useModelArgs)} [argsArg]\n * @returns {Record<string, any>}\n */\n/** useModel. */\nconst useModel = (modelClassArg, argsArg = {}) => {\n  const shapeHook = useShapeHook(UseModelShapeHook, {argsArg, modelClassArg})\n  const model = shapeHook.visibleModel()\n  const modelId = shapeHook.modelId()\n  const notFound = shapeHook.visibleNotFound()\n  const modelVariableName = shapeHook.modelVariableName()\n  const result = {\n    model,\n    modelId,\n    notFound\n  }\n\n  result[modelVariableName] = model\n  result[`${modelVariableName}Id`] = modelId\n  result[`${modelVariableName}NotFound`] = notFound\n\n  return result\n}\n\nexport default useModel\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kaspernj/api-maker",
   "type": "module",
-  "version": "1.0.2154",
+  "version": "1.0.2155",
   "description": "My new module",
   "files": [
     "build/**"