@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/bootstrap/sort-link.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-check
 import * as inflection from "inflection";
-import { shapeComponent } from "set-state-compare/build/shape-component.js";
-import BaseComponent from "../base-component"; // eslint-disable-line sort-imports
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
 import Icon from "../utils/icon";
 import Link from "../link";
 import PropTypes from "prop-types";
@@ -12,7 +12,18 @@ import qs from "qs";
 import urlEncode from "../url-encode.js";
 import useQueryParams from "on-location-changed/build/use-query-params.js";
 import useSorting from "../table/use-sorting.js";
-export default memo(shapeComponent(class ApiMakerBootstrapSortLink extends BaseComponent {
+/**
+ * @typedef {object} Props
+ * @property {string} attribute
+ * @property {string} [className]
+ * @property {object} [defaultParams]
+ * @property {object} [linkComponent]
+ * @property {Function} [onChanged]
+ * @property {object} query
+ * @property {React.ReactNode} [title]
+ */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerBootstrapSortLink extends ShapeComponent {
     static propTypes = {
         attribute: PropTypes.string.isRequired,
         className: PropTypes.string,
@@ -73,4 +84,4 @@ export default memo(shapeComponent(class ApiMakerBootstrapSortLink extends BaseC
         return query.modelClass().humanAttributeName(attribute);
     }
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort-link.js","sourceRoot":"/src/","sources":["bootstrap/sort-link.jsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,UAAU,MAAM,YAAY,CAAA;AACxC,OAAO,EAAC,cAAc,EAAC,MAAM,4CAA4C,CAAA;AACzE,OAAO,aAAa,MAAM,mBAAmB,CAAA,CAAC,mCAAmC;AACjF,OAAO,IAAI,MAAM,eAAe,CAAA;AAChC,OAAO,IAAI,MAAM,SAAS,CAAA;AAC1B,OAAO,SAAS,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,IAAI,MAAM,eAAe,CAAA;AAChC,OAAO,IAAI,MAAM,iCAAiC,CAAA;AAClD,OAAO,EAAE,MAAM,IAAI,CAAA;AACnB,OAAO,SAAS,MAAM,kBAAkB,CAAA;AACxC,OAAO,cAAc,MAAM,+CAA+C,CAAA;AAC1E,OAAO,UAAU,MAAM,yBAAyB,CAAA;AAEhD,eAAe,IAAI,CAAC,cAAc,CAAC,MAAM,yBAA0B,SAAQ,aAAa;IACtF,MAAM,CAAC,SAAS,GAAG;QACjB,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,UAAU;QACtC,SAAS,EAAE,SAAS,CAAC,MAAM;QAC3B,aAAa,EAAE,SAAS,CAAC,MAAM;QAC/B,aAAa,EAAE,SAAS,CAAC,MAAM;QAC/B,SAAS,EAAE,SAAS,CAAC,IAAI;QACzB,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,UAAU;QAClC,KAAK,EAAE,SAAS,CAAC,GAAG;KACrB,CAAA;IAED,KAAK;QACH,MAAM,EAAC,SAAS,EAAE,aAAa,EAAE,KAAK,EAAC,GAAG,IAAI,CAAC,KAAK,CAAA;QACpD,MAAM,EAAC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAC,GAAG,UAAU,CAAC,EAAC,aAAa,EAAE,KAAK,EAAC,CAAC,CAAA;QAExF,IAAI,CAAC,mBAAmB,GAAG,aAAa,IAAI,SAAS,CAAA;QACrD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QAExB,IAAI,CAAC,WAAW,GAAG,cAAc,EAAE,CAAA;QACnC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,IAAI,GAAG,CAAA;QACxD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;IAC1D,CAAC;IAED,IAAI;QACF,MAAM,OAAO,GAAG,EAAC,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,EAAC,CAAA;QACpC,MAAM,EAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAC,GAAG,IAAI,CAAC,EAAE,CAAA;QAC7D,MAAM,cAAc,GAAG,EAAC,GAAG,WAAW,EAAC,CAAA;QAEvC,OAAO,CAAC,CAAC,GAAG,GAAG,SAAS,IAAI,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,CAAA;QAEhE,cAAc,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QAEnD,MAAM,SAAS,GAAG,EAAE,CAAC,SAAS,CAAC,cAAc,EAAE,EAAC,OAAO,EAAE,SAAS,EAAC,CAAC,CAAA;QACpE,MAAM,OAAO,GAAG,GAAG,QAAQ,CAAC,QAAQ,IAAI,SAAS,EAAE,CAAA;QAEnD,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,MAAM;QACJ,MAAM,EAAC,mBAAmB,EAAE,QAAQ,EAAC,GAAG,IAAI,CAAC,EAAE,CAAA;QAC/C,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,CAAA;QAC1C,MAAM,EAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,SAAS,EAAC,GAAG,IAAI,CAAC,KAAK,CAAA;QACzI,MAAM,aAAa,GAAG;YACpB,SAAS;YACT,KAAK,EAAE,SAAS;YAChB,SAAS,EAAE,+BAA+B;YAC1C,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC,QAAQ;YAC1B,GAAG,OAAO;SACX,CAAA;QACD,MAAM,WAAW,GAAG;YAClB,OAAO,EAAE,MAAM;YACf,aAAa,EAAE,KAAK;YACpB,UAAU,EAAE,QAAQ;YACpB,GAAG,KAAK;SACT,CAAA;QAED,OAAO,CACL,MAAC,aAAa,IACZ,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,KACX,SAAS,aAEb,KAAC,IAAI,OAAK,SAAS,YAChB,IAAI,CAAC,KAAK,EAAE,GACR,EACN,mBAAmB,IAAI,QAAQ,IAAI,KAAK;oBACvC,KAAC,IAAI,IAAC,IAAI,EAAC,cAAc,EAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,EAAC,UAAU,EAAE,CAAC,EAAC,CAAC,GAAI,EAE5F,mBAAmB,IAAI,QAAQ,IAAI,MAAM;oBACxC,KAAC,IAAI,IAAC,IAAI,EAAC,YAAY,EAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,EAAC,UAAU,EAAE,CAAC,EAAC,CAAC,GAAI,IAE3E,CACjB,CAAA;IACH,CAAC;IAED,aAAa,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,IAAI,IAAI,CAAA;IAEtD,KAAK;QACH,MAAM,EAAC,SAAS,EAAE,KAAK,EAAC,GAAG,IAAI,CAAC,CAAC,CAAA;QACjC,MAAM,EAAC,KAAK,EAAC,GAAG,IAAI,CAAC,KAAK,CAAA;QAE1B,IAAI,KAAK;YAAE,OAAO,KAAK,CAAA;QAEvB,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;IACzD,CAAC;CACF,CAAC,CAAC,CAAA","sourcesContent":["import * as inflection from \"inflection\"\nimport {shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport BaseComponent from \"../base-component\" // eslint-disable-line sort-imports\nimport Icon from \"../utils/icon\"\nimport Link from \"../link\"\nimport PropTypes from \"prop-types\"\nimport React from \"react\"\nimport Text from \"../utils/text\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport qs from \"qs\"\nimport urlEncode from \"../url-encode.js\"\nimport useQueryParams from \"on-location-changed/build/use-query-params.js\"\nimport useSorting from \"../table/use-sorting.js\"\n\nexport default memo(shapeComponent(class ApiMakerBootstrapSortLink extends BaseComponent {\n  static propTypes = {\n    attribute: PropTypes.string.isRequired,\n    className: PropTypes.string,\n    defaultParams: PropTypes.object,\n    linkComponent: PropTypes.object,\n    onChanged: PropTypes.func,\n    query: PropTypes.object.isRequired,\n    title: PropTypes.any\n  }\n\n  setup() {\n    const {attribute, defaultParams, query} = this.props\n    const {qParams, searchKey, sortAttribute, sortMode} = useSorting({defaultParams, query})\n\n    this.isSortedByAttribute = sortAttribute == attribute\n    this.qParams = qParams\n    this.searchKey = searchKey\n    this.sortMode = sortMode\n\n    this.queryParams = useQueryParams()\n    this.searchKey = this.p.query.queryArgs.searchKey || \"q\"\n    this.attribute = inflection.underscore(this.p.attribute)\n  }\n\n  href () {\n    const qParams = {...this.tt.qParams}\n    const {attribute, queryParams, searchKey, sortMode} = this.tt\n    const newQueryParams = {...queryParams}\n\n    qParams.s = `${attribute} ${sortMode == \"asc\" ? \"desc\" : \"asc\"}`\n\n    newQueryParams[searchKey] = JSON.stringify(qParams)\n\n    const newParams = qs.stringify(newQueryParams, {encoder: urlEncode})\n    const newPath = `${location.pathname}?${newParams}`\n\n    return newPath\n  }\n\n  render () {\n    const {isSortedByAttribute, sortMode} = this.tt\n    const LinkComponent = this.linkComponent()\n    const {attribute, className, dataSet, defaultParams, linkComponent, onChanged, query, style, textProps, title, ...restProps} = this.props\n    const actualDataSet = {\n      attribute,\n      class: className,\n      component: \"api-maker/bootstrap/sort-link\",\n      sortMode: this.tt.sortMode,\n      ...dataSet\n    }\n    const actualStyle = {\n      display: \"flex\",\n      flexDirection: \"row\",\n      alignItems: \"center\",\n      ...style\n    }\n\n    return (\n      <LinkComponent\n        dataSet={actualDataSet}\n        style={actualStyle}\n        to={this.href()}\n        {...restProps}\n      >\n        <Text {...textProps}>\n          {this.title()}\n        </Text>\n        {isSortedByAttribute && sortMode == \"asc\" &&\n          <Icon name=\"chevron-down\" size={14} style={this.cache(\"downIconStyle\", {marginLeft: 3})} />\n        }\n        {isSortedByAttribute && sortMode == \"desc\" &&\n          <Icon name=\"chevron-up\" size={14} style={this.cache(\"upIconStyle\", {marginLeft: 3})} />\n        }\n      </LinkComponent>\n    )\n  }\n\n  linkComponent = () => this.props.linkComponent || Link\n\n  title () {\n    const {attribute, query} = this.p\n    const {title} = this.props\n\n    if (title) return title\n\n    return query.modelClass().humanAttributeName(attribute)\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sort-link.js","sourceRoot":"/src/","sources":["bootstrap/sort-link.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Icon from \"../utils/icon\"\nimport Link from \"../link\"\nimport PropTypes from \"prop-types\"\nimport React from \"react\"\nimport Text from \"../utils/text\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport qs from \"qs\"\nimport urlEncode from \"../url-encode.js\"\nimport useQueryParams from \"on-location-changed/build/use-query-params.js\"\nimport useSorting from \"../table/use-sorting.js\"\n\n/**\n * @typedef {object} Props\n * @property {string} attribute\n * @property {string} [className]\n * @property {object} [defaultParams]\n * @property {object} [linkComponent]\n * @property {Function} [onChanged]\n * @property {object} query\n * @property {React.ReactNode} [title]\n */\n/** @typedef {Record<string, never>} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerBootstrapSortLink extends ShapeComponent {\n  static propTypes = {\n    attribute: PropTypes.string.isRequired,\n    className: PropTypes.string,\n    defaultParams: PropTypes.object,\n    linkComponent: PropTypes.object,\n    onChanged: PropTypes.func,\n    query: PropTypes.object.isRequired,\n    title: PropTypes.any\n  }\n\n  setup() {\n    const {attribute, defaultParams, query} = this.props\n    const {qParams, searchKey, sortAttribute, sortMode} = useSorting({defaultParams, query})\n\n    this.isSortedByAttribute = sortAttribute == attribute\n    this.qParams = qParams\n    this.searchKey = searchKey\n    this.sortMode = sortMode\n\n    this.queryParams = useQueryParams()\n    this.searchKey = this.p.query.queryArgs.searchKey || \"q\"\n    this.attribute = inflection.underscore(this.p.attribute)\n  }\n\n  href () {\n    const qParams = {...this.tt.qParams}\n    const {attribute, queryParams, searchKey, sortMode} = this.tt\n    const newQueryParams = {...queryParams}\n\n    qParams.s = `${attribute} ${sortMode == \"asc\" ? \"desc\" : \"asc\"}`\n\n    newQueryParams[searchKey] = JSON.stringify(qParams)\n\n    const newParams = qs.stringify(newQueryParams, {encoder: urlEncode})\n    const newPath = `${location.pathname}?${newParams}`\n\n    return newPath\n  }\n\n  render () {\n    const {isSortedByAttribute, sortMode} = this.tt\n    const LinkComponent = this.linkComponent()\n    const {attribute, className, dataSet, defaultParams, linkComponent, onChanged, query, style, textProps, title, ...restProps} = this.props\n    const actualDataSet = {\n      attribute,\n      class: className,\n      component: \"api-maker/bootstrap/sort-link\",\n      sortMode: this.tt.sortMode,\n      ...dataSet\n    }\n    const actualStyle = {\n      display: \"flex\",\n      flexDirection: \"row\",\n      alignItems: \"center\",\n      ...style\n    }\n\n    return (\n      <LinkComponent\n        dataSet={actualDataSet}\n        style={actualStyle}\n        to={this.href()}\n        {...restProps}\n      >\n        <Text {...textProps}>\n          {this.title()}\n        </Text>\n        {isSortedByAttribute && sortMode == \"asc\" &&\n          <Icon name=\"chevron-down\" size={14} style={this.cache(\"downIconStyle\", {marginLeft: 3})} />\n        }\n        {isSortedByAttribute && sortMode == \"desc\" &&\n          <Icon name=\"chevron-up\" size={14} style={this.cache(\"upIconStyle\", {marginLeft: 3})} />\n        }\n      </LinkComponent>\n    )\n  }\n\n  linkComponent = () => this.props.linkComponent || Link\n\n  title () {\n    const {attribute, query} = this.p\n    const {title} = this.props\n\n    if (title) return title\n\n    return query.modelClass().humanAttributeName(attribute)\n  }\n}))\n"]}

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

@@ -1,48 +1,225 @@
+/** @typedef {import("./cable-subscription.js").default} CableSubscription */
+/** @typedef {import("./base-model.js").default} BaseModel */
+/** @typedef {object | string | number | boolean | null | Array<object | string | number | boolean | null>} CableRequestValue */
+/** @typedef {Record<string, CableRequestValue>} CableRefreshArgs */
+/** @typedef {string | number | boolean} ConnectionEventValue */
+/** @typedef {string[]} ModelSubscriptionPath */
+/** @typedef {{model: BaseModel}} ModelMutationPayload */
+/** @typedef {Record<string, string | number | boolean | null | Array<string | number | boolean | null>>} CableEventArgs */
+/** @typedef {{args: CableEventArgs, eventName: string, model: BaseModel}} ModelEventPayload */
+/** @typedef {{args: CableEventArgs, eventName: string}} ModelClassEventPayload */
+/** @typedef {(payload: ModelMutationPayload | ModelEventPayload | ModelClassEventPayload) => void} ModelEventCallback */
 /** ActionCable connection pool keyed by stream identifiers. */
 export default class ApiMakerCableConnectionPool {
-    /** current. */
-    static current(): any;
+    /**
+     * Returns the shared connection pool instance.
+     * @returns {ApiMakerCableConnectionPool}
+     */
+    static current(): ApiMakerCableConnectionPool;
     /** @returns {void} */
     static resetCurrent(): void;
     cableSubscriptionPools: any[];
     connections: {};
     upcomingSubscriptionData: {};
     upcomingSubscriptions: {};
-    /** connectEventToExistingSubscription. */
+    /**
+     * Attaches a logical subscription to an already-open shared ActionCable stream when possible.
+     * @param {object} root0
+     * @param {ModelSubscriptionPath} root0.path
+     * @param {CableSubscription} root0.subscription
+     * @param {ConnectionEventValue} root0.value
+     * @returns {boolean}
+     */
     connectEventToExistingSubscription({ path, subscription, value }: {
-        path: any;
-        subscription: any;
-        value: any;
+        path: ModelSubscriptionPath;
+        subscription: CableSubscription;
+        value: ConnectionEventValue;
     }): boolean;
-    /** connectModelEvent. */
+    /**
+     * Registers one logical model subscription, reusing an existing shared connection when available.
+     * @param {object} root0
+     * @param {ModelEventCallback} root0.callback
+     * @param {ModelSubscriptionPath} root0.path
+     * @param {ConnectionEventValue} root0.value
+     * @returns {CableSubscription}
+     */
     connectModelEvent({ callback, path, value }: {
-        callback: any;
-        path: any;
-        value: any;
+        callback: ModelEventCallback;
+        path: ModelSubscriptionPath;
+        value: ConnectionEventValue;
     }): CableSubscription;
-    /** connectCreated. */
-    connectCreated: (modelName: any, callback: any) => CableSubscription;
-    /** connectEvent. */
-    connectEvent: (modelName: any, modelId: any, eventName: any, callback: any) => CableSubscription;
-    /** connectDestroyed. */
-    connectDestroyed: (modelName: any, modelId: any, callback: any) => CableSubscription;
-    /** connectModelClassEvent. */
-    connectModelClassEvent: (modelName: any, eventName: any, callback: any) => CableSubscription;
-    /** connectUpdate. */
-    connectUpdate: (modelName: any, modelId: any, callback: any) => CableSubscription;
-    /** connectUpcoming. */
+    /**
+     * Subscribes to created events for a model class.
+     * @param {string} modelName
+     * @param {(payload: ModelMutationPayload) => void} callback
+     * @returns {CableSubscription}
+     */
+    connectCreated: (modelName: string, callback: (payload: ModelMutationPayload) => void) => CableSubscription;
+    /**
+     * Subscribes to a named event for one persisted model instance.
+     * @param {string} modelName
+     * @param {string | number} modelId
+     * @param {string} eventName
+     * @param {(payload: ModelEventPayload) => void} callback
+     * @returns {CableSubscription}
+     */
+    connectEvent: (modelName: string, modelId: string | number, eventName: string, callback: (payload: ModelEventPayload) => void) => CableSubscription;
+    /**
+     * Subscribes to destroy events for one persisted model instance.
+     * @param {string} modelName
+     * @param {string | number} modelId
+     * @param {(payload: ModelMutationPayload) => void} callback
+     * @returns {CableSubscription}
+     */
+    connectDestroyed: (modelName: string, modelId: string | number, callback: (payload: ModelMutationPayload) => void) => CableSubscription;
+    /**
+     * Subscribes to one named model-class event stream.
+     * @param {string} modelName
+     * @param {string} eventName
+     * @param {(payload: ModelClassEventPayload) => void} callback
+     * @returns {CableSubscription}
+     */
+    connectModelClassEvent: (modelName: string, eventName: string, callback: (payload: ModelClassEventPayload) => void) => CableSubscription;
+    /**
+     * Subscribes to update events for one persisted model instance.
+     * @param {string} modelName
+     * @param {string | number} modelId
+     * @param {(payload: ModelMutationPayload) => void} callback
+     * @returns {CableSubscription}
+     */
+    connectUpdate: (modelName: string, modelId: string | number, callback: (payload: ModelMutationPayload) => void) => CableSubscription;
+    /** Opens one shared ActionCable subscription for all queued logical subscriptions. */
     connectUpcoming: () => void;
     /**
      * Refreshes auth across the existing subscription pools.
      *
-     * @param {Record<string, any>} args
+     * @param {CableRefreshArgs} args
      * @returns {Promise<void>}
      */
-    refreshAuthentication(args: Record<string, any>): Promise<void>;
+    refreshAuthentication(args: CableRefreshArgs): Promise<void>;
     /** @returns {void} */
     reset(): void;
     scheduleConnectUpcomingRunLast: RunLast;
 }
-import CableSubscription from "./cable-subscription.js";
+export type CableSubscription = import("./cable-subscription.js").default;
+export type BaseModel = {
+    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 CableRequestValue = object | string | number | boolean | null | Array<object | string | number | boolean | null>;
+export type CableRefreshArgs = Record<string, CableRequestValue>;
+export type ConnectionEventValue = string | number | boolean;
+export type ModelSubscriptionPath = string[];
+export type ModelMutationPayload = {
+    model: BaseModel;
+};
+export type CableEventArgs = Record<string, string | number | boolean | null | Array<string | number | boolean | null>>;
+export type ModelEventPayload = {
+    args: CableEventArgs;
+    eventName: string;
+    model: BaseModel;
+};
+export type ModelClassEventPayload = {
+    args: CableEventArgs;
+    eventName: string;
+};
+export type ModelEventCallback = (payload: ModelMutationPayload | ModelEventPayload | ModelClassEventPayload) => void;
 import RunLast from "./run-last.js";
 //# sourceMappingURL=cable-connection-pool.d.ts.map

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;;;;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"}
+{"version":3,"file":"cable-connection-pool.d.ts","sourceRoot":"/src/","sources":["cable-connection-pool.js"],"names":[],"mappings":"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"}

package/build/cable-connection-pool.js

@@ -1,15 +1,30 @@
+// @ts-check
 import { dig } from "diggerize";
-import CableSubscription from "./cable-subscription.js"; // eslint-disable-line sort-imports
+import CableSubscriptionClass from "./cable-subscription.js"; // eslint-disable-line sort-imports
 import CableSubscriptionPool from "./cable-subscription-pool.js";
 import RunLast from "./run-last.js";
 const shared = {};
+/** @typedef {import("./cable-subscription.js").default} CableSubscription */
+/** @typedef {import("./base-model.js").default} BaseModel */
+/** @typedef {object | string | number | boolean | null | Array<object | string | number | boolean | null>} CableRequestValue */
+/** @typedef {Record<string, CableRequestValue>} CableRefreshArgs */
+/** @typedef {string | number | boolean} ConnectionEventValue */
+/** @typedef {string[]} ModelSubscriptionPath */
+/** @typedef {{model: BaseModel}} ModelMutationPayload */
+/** @typedef {Record<string, string | number | boolean | null | Array<string | number | boolean | null>>} CableEventArgs */
+/** @typedef {{args: CableEventArgs, eventName: string, model: BaseModel}} ModelEventPayload */
+/** @typedef {{args: CableEventArgs, eventName: string}} ModelClassEventPayload */
+/** @typedef {(payload: ModelMutationPayload | ModelEventPayload | ModelClassEventPayload) => void} ModelEventCallback */
 /** ActionCable connection pool keyed by stream identifiers. */
 export default class ApiMakerCableConnectionPool {
     cableSubscriptionPools = [];
     connections = {};
     upcomingSubscriptionData = {};
     upcomingSubscriptions = {};
-    /** current. */
+    /**
+     * Returns the shared connection pool instance.
+     * @returns {ApiMakerCableConnectionPool}
+     */
     static current() {
         if (!shared.apiMakerCableConnectionPool)
             shared.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool();
@@ -23,7 +38,14 @@ export default class ApiMakerCableConnectionPool {
         shared.apiMakerCableConnectionPool.reset();
         delete shared.apiMakerCableConnectionPool;
     }
-    /** connectEventToExistingSubscription. */
+    /**
+     * Attaches a logical subscription to an already-open shared ActionCable stream when possible.
+     * @param {object} root0
+     * @param {ModelSubscriptionPath} root0.path
+     * @param {CableSubscription} root0.subscription
+     * @param {ConnectionEventValue} root0.value
+     * @returns {boolean}
+     */
     connectEventToExistingSubscription({ path, subscription, value }) {
         for (const cableSubscriptionPool of this.cableSubscriptionPools) {
             if (cableSubscriptionPool.isConnected()) {
@@ -47,9 +69,16 @@ export default class ApiMakerCableConnectionPool {
         }
         return false;
     }
-    /** connectModelEvent. */
+    /**
+     * Registers one logical model subscription, reusing an existing shared connection when available.
+     * @param {object} root0
+     * @param {ModelEventCallback} root0.callback
+     * @param {ModelSubscriptionPath} root0.path
+     * @param {ConnectionEventValue} root0.value
+     * @returns {CableSubscription}
+     */
     connectModelEvent({ callback, path, value }) {
-        const subscription = new CableSubscription();
+        const subscription = new CableSubscriptionClass();
         subscription.events.addListener("received", callback);
         if (this.connectEventToExistingSubscription({ path, subscription, value })) {
             // Managed to connect to existing connection
@@ -85,29 +114,60 @@ export default class ApiMakerCableConnectionPool {
             currentSubscription.push(subscription);
         }
         else {
-            if (!(value in currentSubscription)) {
-                currentSubscription[value] = [];
+            const subscriptionKey = String(value);
+            if (!(subscriptionKey in currentSubscription)) {
+                currentSubscription[subscriptionKey] = [];
             }
-            currentSubscription[value].push(subscription);
+            currentSubscription[subscriptionKey].push(subscription);
         }
         this.scheduleConnectUpcomingRunLast.queue();
         return subscription;
     }
-    /** connectCreated. */
+    /**
+     * Subscribes to created events for a model class.
+     * @param {string} modelName
+     * @param {(payload: ModelMutationPayload) => void} callback
+     * @returns {CableSubscription}
+     */
     connectCreated = (modelName, callback) => this.connectModelEvent({ callback, value: true, path: [modelName, "creates"] });
-    /** connectEvent. */
+    /**
+     * Subscribes to a named event for one persisted model instance.
+     * @param {string} modelName
+     * @param {string | number} modelId
+     * @param {string} eventName
+     * @param {(payload: ModelEventPayload) => void} callback
+     * @returns {CableSubscription}
+     */
     connectEvent = (modelName, modelId, eventName, callback) => this.connectModelEvent({
         callback,
         value: modelId,
         path: [modelName, "events", eventName]
     });
-    /** connectDestroyed. */
+    /**
+     * Subscribes to destroy events for one persisted model instance.
+     * @param {string} modelName
+     * @param {string | number} modelId
+     * @param {(payload: ModelMutationPayload) => void} callback
+     * @returns {CableSubscription}
+     */
     connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({ callback, value: modelId, path: [modelName, "destroys"] });
-    /** connectModelClassEvent. */
+    /**
+     * Subscribes to one named model-class event stream.
+     * @param {string} modelName
+     * @param {string} eventName
+     * @param {(payload: ModelClassEventPayload) => void} callback
+     * @returns {CableSubscription}
+     */
     connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({ callback, value: eventName, path: [modelName, "model_class_events"] });
-    /** connectUpdate. */
+    /**
+     * Subscribes to update events for one persisted model instance.
+     * @param {string} modelName
+     * @param {string | number} modelId
+     * @param {(payload: ModelMutationPayload) => void} callback
+     * @returns {CableSubscription}
+     */
     connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({ callback, value: modelId, path: [modelName, "updates"] });
-    /** connectUpcoming. */
+    /** Opens one shared ActionCable subscription for all queued logical subscriptions. */
     connectUpcoming = () => {
         const subscriptionData = this.upcomingSubscriptionData;
         const subscriptions = this.upcomingSubscriptions;
@@ -121,7 +181,7 @@ export default class ApiMakerCableConnectionPool {
     /**
      * Refreshes auth across the existing subscription pools.
      *
-     * @param {Record<string, any>} args
+     * @param {CableRefreshArgs} args
      * @returns {Promise<void>}
      */
     async refreshAuthentication(args) {
@@ -140,4 +200,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          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"]}
+//# 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":["// @ts-check\nimport {dig} from \"diggerize\"\nimport CableSubscriptionClass 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/** @typedef {import(\"./cable-subscription.js\").default} CableSubscription */\n/** @typedef {import(\"./base-model.js\").default} BaseModel */\n/** @typedef {object | string | number | boolean | null | Array<object | string | number | boolean | null>} CableRequestValue */\n/** @typedef {Record<string, CableRequestValue>} CableRefreshArgs */\n/** @typedef {string | number | boolean} ConnectionEventValue */\n/** @typedef {string[]} ModelSubscriptionPath */\n/** @typedef {{model: BaseModel}} ModelMutationPayload */\n/** @typedef {Record<string, string | number | boolean | null | Array<string | number | boolean | null>>} CableEventArgs */\n/** @typedef {{args: CableEventArgs, eventName: string, model: BaseModel}} ModelEventPayload */\n/** @typedef {{args: CableEventArgs, eventName: string}} ModelClassEventPayload */\n/** @typedef {(payload: ModelMutationPayload | ModelEventPayload | ModelClassEventPayload) => void} ModelEventCallback */\n\n/** ActionCable connection pool keyed by stream identifiers. */\nexport default class ApiMakerCableConnectionPool {\n  cableSubscriptionPools = []\n  connections = {}\n  upcomingSubscriptionData = {}\n  upcomingSubscriptions = {}\n\n  /**\n   * Returns the shared connection pool instance.\n   * @returns {ApiMakerCableConnectionPool}\n   */\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  /**\n   * Attaches a logical subscription to an already-open shared ActionCable stream when possible.\n   * @param {object} root0\n   * @param {ModelSubscriptionPath} root0.path\n   * @param {CableSubscription} root0.subscription\n   * @param {ConnectionEventValue} root0.value\n   * @returns {boolean}\n   */\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  /**\n   * Registers one logical model subscription, reusing an existing shared connection when available.\n   * @param {object} root0\n   * @param {ModelEventCallback} root0.callback\n   * @param {ModelSubscriptionPath} root0.path\n   * @param {ConnectionEventValue} root0.value\n   * @returns {CableSubscription}\n   */\n  connectModelEvent ({callback, path, value}) {\n    const subscription = new CableSubscriptionClass()\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      const subscriptionKey = String(value)\n\n      if (!(subscriptionKey in currentSubscription)) {\n        currentSubscription[subscriptionKey] = []\n      }\n\n      currentSubscription[subscriptionKey].push(subscription)\n    }\n\n    this.scheduleConnectUpcomingRunLast.queue()\n\n    return subscription\n  }\n\n  /**\n   * Subscribes to created events for a model class.\n   * @param {string} modelName\n   * @param {(payload: ModelMutationPayload) => void} callback\n   * @returns {CableSubscription}\n   */\n  connectCreated = (modelName, callback) => this.connectModelEvent({callback, value: true, path: [modelName, \"creates\"]})\n\n  /**\n   * Subscribes to a named event for one persisted model instance.\n   * @param {string} modelName\n   * @param {string | number} modelId\n   * @param {string} eventName\n   * @param {(payload: ModelEventPayload) => void} callback\n   * @returns {CableSubscription}\n   */\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  /**\n   * Subscribes to destroy events for one persisted model instance.\n   * @param {string} modelName\n   * @param {string | number} modelId\n   * @param {(payload: ModelMutationPayload) => void} callback\n   * @returns {CableSubscription}\n   */\n  connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"destroys\"]})\n\n  /**\n   * Subscribes to one named model-class event stream.\n   * @param {string} modelName\n   * @param {string} eventName\n   * @param {(payload: ModelClassEventPayload) => void} callback\n   * @returns {CableSubscription}\n   */\n  connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({callback, value: eventName, path: [modelName, \"model_class_events\"]})\n\n  /**\n   * Subscribes to update events for one persisted model instance.\n   * @param {string} modelName\n   * @param {string | number} modelId\n   * @param {(payload: ModelMutationPayload) => void} callback\n   * @returns {CableSubscription}\n   */\n  connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"updates\"]})\n\n  /** Opens one shared ActionCable subscription for all queued logical subscriptions. */\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 {CableRefreshArgs} 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"]}