@kaspernj/api-maker 1.0.2160 → 1.0.2161

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

@@ -1,32 +1,61 @@
+/** @typedef {import("./base-model.js").default} BaseModel */
+/** @typedef {import("./cable-subscription.js").default} CableSubscription */
+/** @typedef {string | number | boolean | null} EventArgumentPrimitive */
+/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */
+/** @typedef {Record<string, EventArgumentValue>} SubscriptionRefreshArgs */
+/** @typedef {{channel: string, global: object, subscription_data: object}} CableSubscriptionCreateArgs */
+/** @typedef {{model: BaseModel}} ModelMutationPayload */
+/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string, model: BaseModel}} ModelEventPayload */
+/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string}} ModelClassEventPayload */
+/**
+ * @typedef {object} SubscriptionIterationArgs
+ * @property {string} [eventName]
+ * @property {"creates"|"destroys"|"updates"|"model_class_events"} mode
+ * @property {string} [modelId]
+ * @property {string} modelName
+ * @property {CableSubscription} subscription
+ */
 /** Subscription pool for sharing channel subscriptions. */
 export default class ApiMakerCableSubscriptionPool {
     activeSubscriptions: number;
     authRefreshCallbacks: {};
     connected: boolean;
     skipDisconnectHandling: boolean;
-    /** connect. */
-    connect(subscriptionData: any): void;
-    subscription: any;
+    /**
+     * Opens the shared ActionCable subscription for the given subscription tree.
+     * @param {object} subscriptionData
+     * @returns {void}
+     */
+    connect(subscriptionData: object): void;
+    subscription: import("./channels-consumer.js").ActionCableSubscription;
     /**
      * Refreshes auth for the existing subscription without recreating the pool.
      *
-     * @param {Record<string, any>} args
+     * @param {SubscriptionRefreshArgs} args
      * @returns {Promise<void>}
      */
-    refreshAuthentication(args: Record<string, any>): Promise<void>;
-    /** forEachSubscription. */
-    forEachSubscription(callback: any): void;
-    /** isConnected. */
-    isConnected: () => any;
-    /** onConnected. */
+    refreshAuthentication(args: SubscriptionRefreshArgs): Promise<void>;
+    /**
+     * Iterates over every tracked subscription with its stream metadata.
+     * @param {(args: SubscriptionIterationArgs) => void} callback
+     * @returns {void}
+    */
+    forEachSubscription(callback: (args: SubscriptionIterationArgs) => void): void;
+    /** @returns {boolean} */
+    isConnected: () => boolean;
+    /** Marks the pool connected and notifies each subscriber once the stream is ready. */
     onConnected: () => void;
-    /** onDisconnected. */
+    /** Marks the pool disconnected and fails pending auth refreshes unless teardown is intentional. */
     onDisconnected: () => void;
-    /** onReceived. */
-    onReceived: (rawData: any) => void;
-    /** onSubscribed. */
+    /**
+     * Routes one ActionCable payload to the matching logical subscriptions.
+     * @param {object} rawData
+     * @returns {void}
+     */
+    onReceived: (rawData: object) => void;
+    /** Logs when ActionCable confirms the shared subscription. */
     onSubscribed: () => void;
-    /** onRejected. */
+    /** Marks the pool disconnected when ActionCable rejects the shared subscription. */
     onRejected: () => void;
     /** @returns {void} */
     clearAuthRefreshCallbacks(): void;
@@ -37,14 +66,151 @@ export default class ApiMakerCableSubscriptionPool {
      * @returns {void}
      */
     rejectAuthRefresh(error: Error): void;
-    /** onUnsubscribe. */
+    /** Releases one tracked logical subscription and tears down the shared stream when the pool becomes empty. */
     onUnsubscribe(): void;
-    /** registerSubscriptions. */
-    registerSubscriptions(subscriptions: any): void;
+    /**
+     * Registers the logical subscriptions served by this shared ActionCable stream.
+     * @param {object} subscriptions
+     * @returns {void}
+     */
+    registerSubscriptions(subscriptions: object): void;
     subscriptions: any;
-    /** connectUnsubscriptionForSubscription. */
-    connectUnsubscriptionForSubscription(subscription: any): void;
+    /**
+     * Hooks pool bookkeeping up to a child subscription's unsubscribe event.
+     * @param {CableSubscription} subscription
+     * @returns {void}
+     */
+    connectUnsubscriptionForSubscription(subscription: CableSubscription): void;
     /** @returns {void} */
     reset(): void;
 }
+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 CableSubscription = import("./cable-subscription.js").default;
+export type EventArgumentPrimitive = string | number | boolean | null;
+export type EventArgumentValue = EventArgumentPrimitive | EventArgumentPrimitive[];
+export type SubscriptionRefreshArgs = Record<string, EventArgumentValue>;
+export type CableSubscriptionCreateArgs = {
+    channel: string;
+    global: object;
+    subscription_data: object;
+};
+export type ModelMutationPayload = {
+    model: BaseModel;
+};
+export type ModelEventPayload = {
+    args: Record<string, EventArgumentValue>;
+    eventName: string;
+    model: BaseModel;
+};
+export type ModelClassEventPayload = {
+    args: Record<string, EventArgumentValue>;
+    eventName: string;
+};
+export type SubscriptionIterationArgs = {
+    eventName?: string;
+    mode: "creates" | "destroys" | "updates" | "model_class_events";
+    modelId?: string;
+    modelName: string;
+    subscription: CableSubscription;
+};
 //# sourceMappingURL=cable-subscription-pool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cable-subscription-pool.d.ts","sourceRoot":"/src/","sources":["cable-subscription-pool.js"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D;IAGI,4BAA4B;IAC5B,yBAA8B;IAC9B,mBAAsB;IACtB,gCAAmC;IAGrC,eAAe;IACf,qCAoBC;IAfC,kBAaC;IAIH;;;;;OAKG;IACH,4BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED,2BAA2B;IAC3B,yCAyCC;IAED,mBAAmB;IACnB,uBAA2C;IAE3C,mBAAmB;IACnB,wBAMC;IAED,sBAAsB;IACtB,2BAQC;IAED,kBAAkB;IAClB,aAAc,YAAO,UAqDpB;IAED,oBAAoB;IACpB,yBAEC;IAED,kBAAkB;IAClB,uBAQC;IAED,sBAAsB;IACtB,6BADc,IAAI,CAOjB;IAED,sBAAsB;IACtB,sBADc,IAAI,CAIjB;IAED;;;OAGG;IACH,yBAHW,KAAK,GACH,IAAI,CAKhB;IAED,qBAAqB;IACrB,sBAcC;IAED,6BAA6B;IAC7B,gDA+BC;IA9BC,mBAAkC;IAgCpC,4CAA4C;IAC5C,8DAWC;IAED,sBAAsB;IACtB,SADc,IAAI,CAajB;CACF"}
+{"version":3,"file":"cable-subscription-pool.d.ts","sourceRoot":"/src/","sources":["cable-subscription-pool.js"],"names":[],"mappings":"AAWA,6DAA6D;AAC7D,6EAA6E;AAC7E,yEAAyE;AACzE,sFAAsF;AACtF,4EAA4E;AAC5E,0GAA0G;AAC1G,yDAAyD;AACzD,mHAAmH;AACnH,sGAAsG;AACtG;;;;;;;GAOG;AAEH,2DAA2D;AAC3D;IAGI,4BAA4B;IAC5B,yBAA8B;IAC9B,mBAAsB;IACtB,gCAAmC;IAGrC;;;;OAIG;IACH,0BAHW,MAAM,GACJ,IAAI,CAsBhB;IAfC,uEAaC;IAIH;;;;;OAKG;IACH,4BAHW,uBAAuB,GACrB,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;MAIE;IACF,8BAHW,CAAC,IAAI,EAAE,yBAAyB,KAAK,IAAI,GACvC,IAAI,CA2ChB;IAED,yBAAyB;IACzB,mBADc,OAAO,CACsB;IAE3C,sFAAsF;IACtF,wBAMC;IAED,mGAAmG;IACnG,2BAQC;IAED;;;;OAIG;IACH,aAAc,SAHH,MAGU,KAFR,IAAI,CAuDhB;IAED,8DAA8D;IAC9D,yBAEC;IAED,oFAAoF;IACpF,uBAQC;IAED,sBAAsB;IACtB,6BADc,IAAI,CAOjB;IAED,sBAAsB;IACtB,sBADc,IAAI,CAIjB;IAED;;;OAGG;IACH,yBAHW,KAAK,GACH,IAAI,CAKhB;IAED,8GAA8G;IAC9G,sBAcC;IAED;;;;OAIG;IACH,qCAHW,MAAM,GACJ,IAAI,CAiChB;IA9BC,mBAAkC;IAgCpC;;;;OAIG;IACH,mDAHW,iBAAiB,GACf,IAAI,CAahB;IAED,sBAAsB;IACtB,SADc,IAAI,CAajB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAC60iB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCArVx6oB,OAAO,yBAAyB,EAAE,OAAO;qCACzC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI;iCAChC,sBAAsB,GAAG,sBAAsB,EAAE;sCACjD,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;0CAClC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAC;mCAC5D;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC;gCAClB;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC;qCAC/E;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;;gBAG7D,MAAM;UACN,SAAS,GAAC,UAAU,GAAC,SAAS,GAAC,oBAAoB;cACnD,MAAM;eACN,MAAM;kBACN,iBAAiB"}

package/build/cable-subscription-pool.js

@@ -1,3 +1,4 @@
+// @ts-check
 import * as inflection from "inflection";
 import { digg } from "diggerize";
 import CommandsPool from "./commands-pool.js"; // eslint-disable-line sort-imports
@@ -6,24 +7,46 @@ import getChannelsConsumer from "./channels-consumer.js";
 import Logger from "./logger.js"; // eslint-disable-line sort-imports
 const logger = new Logger({ name: "ApiMaker / CableSubscriptionPool" });
 const AUTH_REFRESH_TIMEOUT_MS = 5000;
+/** @typedef {import("./base-model.js").default} BaseModel */
+/** @typedef {import("./cable-subscription.js").default} CableSubscription */
+/** @typedef {string | number | boolean | null} EventArgumentPrimitive */
+/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */
+/** @typedef {Record<string, EventArgumentValue>} SubscriptionRefreshArgs */
+/** @typedef {{channel: string, global: object, subscription_data: object}} CableSubscriptionCreateArgs */
+/** @typedef {{model: BaseModel}} ModelMutationPayload */
+/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string, model: BaseModel}} ModelEventPayload */
+/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string}} ModelClassEventPayload */
+/**
+ * @typedef {object} SubscriptionIterationArgs
+ * @property {string} [eventName]
+ * @property {"creates"|"destroys"|"updates"|"model_class_events"} mode
+ * @property {string} [modelId]
+ * @property {string} modelName
+ * @property {CableSubscription} subscription
+ */
 /** Subscription pool for sharing channel subscriptions. */
 export default class ApiMakerCableSubscriptionPool {
-    /** Constructor. */
+    /** Initializes bookkeeping for one shared ActionCable subscription pool. */
     constructor() {
         this.activeSubscriptions = 0;
         this.authRefreshCallbacks = {};
         this.connected = false;
         this.skipDisconnectHandling = false;
     }
-    /** connect. */
+    /**
+     * Opens the shared ActionCable subscription for the given subscription tree.
+     * @param {object} subscriptionData
+     * @returns {void}
+     */
     connect(subscriptionData) {
         const globalData = CommandsPool.current().globalRequestData;
         logger.debug(() => ["Creating subscription", { subscriptionData }]);
-        this.subscription = getChannelsConsumer().subscriptions.create({
+        this.subscription = getChannelsConsumer().subscriptions.create(
+        /** @type {CableSubscriptionCreateArgs} */ ({
             channel: "ApiMaker::SubscriptionsChannel",
             global: globalData,
             subscription_data: subscriptionData
-        }, {
+        }), {
             connected: this.onConnected,
             disconnected: this.onDisconnected,
             received: this.onReceived,
@@ -35,7 +58,7 @@ export default class ApiMakerCableSubscriptionPool {
     /**
      * Refreshes auth for the existing subscription without recreating the pool.
      *
-     * @param {Record<string, any>} args
+     * @param {SubscriptionRefreshArgs} args
      * @returns {Promise<void>}
      */
     refreshAuthentication(args) {
@@ -55,9 +78,13 @@ export default class ApiMakerCableSubscriptionPool {
         this.subscription.perform("refresh_auth", args);
         return this.authRefreshCallbacks.promise;
     }
-    /** forEachSubscription. */
+    /**
+     * Iterates over every tracked subscription with its stream metadata.
+     * @param {(args: SubscriptionIterationArgs) => void} callback
+     * @returns {void}
+    */
     forEachSubscription(callback) {
-        const modelIdModes = ["destroys", "updates"];
+        const modelIdModes = /** @type {Array<"destroys"|"updates">} */ (["destroys", "updates"]);
         const subscriptions = digg(this, "subscriptions");
         for (const modelName in subscriptions) {
             for (const modelIdMode of modelIdModes) {
@@ -94,16 +121,16 @@ export default class ApiMakerCableSubscriptionPool {
             }
         }
     }
-    /** isConnected. */
+    /** @returns {boolean} */
     isConnected = () => digg(this, "connected");
-    /** onConnected. */
+    /** Marks the pool connected and notifies each subscriber once the stream is ready. */
     onConnected = () => {
         this.connected = true;
         this.forEachSubscription(({ subscription }) => {
             subscription.events.emit("connected");
         });
     };
-    /** onDisconnected. */
+    /** Marks the pool disconnected and fails pending auth refreshes unless teardown is intentional. */
     onDisconnected = () => {
         this.connected = false;
         if (this.skipDisconnectHandling) {
@@ -111,7 +138,11 @@ export default class ApiMakerCableSubscriptionPool {
         }
         this.rejectAuthRefresh(new Error("Subscription auth refresh was interrupted by a disconnect"));
     };
-    /** onReceived. */
+    /**
+     * Routes one ActionCable payload to the matching logical subscriptions.
+     * @param {object} rawData
+     * @returns {void}
+     */
     onReceived = (rawData) => {
         if (rawData.type == "api_maker_subscription_auth_refreshed") {
             this.resolveAuthRefresh();
@@ -134,41 +165,41 @@ export default class ApiMakerCableSubscriptionPool {
         }
         if (type == "u") {
             for (const subscription of subscriptions[modelName].updates[modelId]) {
-                subscription.events.emit("received", { model });
+                subscription.events.emit("received", /** @type {ModelMutationPayload} */ ({ model }));
             }
         }
         else if (type == "c") {
             for (const subscription of subscriptions[modelName].creates) {
-                subscription.events.emit("received", { model });
+                subscription.events.emit("received", /** @type {ModelMutationPayload} */ ({ model }));
             }
         }
         else if (type == "d") {
             const destroySubscriptions = digg(subscriptions, modelName, "destroys", modelId);
             for (const subscription of destroySubscriptions) {
-                subscription.events.emit("received", { model });
+                subscription.events.emit("received", /** @type {ModelMutationPayload} */ ({ model }));
             }
         }
         else if (type == "e") {
             const eventSubscriptions = digg(subscriptions, modelName, "events", eventName, modelId);
             for (const subscription of eventSubscriptions) {
-                subscription.events.emit("received", { args, eventName, model });
+                subscription.events.emit("received", /** @type {ModelEventPayload} */ ({ args, eventName, model }));
             }
         }
         else if (type == "mce") {
             const modelClassEventSubscriptions = digg(subscriptions, modelName, "model_class_events", eventName);
             for (const subscription of modelClassEventSubscriptions) {
-                subscription.events.emit("received", { args, eventName });
+                subscription.events.emit("received", /** @type {ModelClassEventPayload} */ ({ args, eventName }));
             }
         }
         else {
             throw new Error(`Unknown type: ${data.type}`);
         }
     };
-    /** onSubscribed. */
+    /** Logs when ActionCable confirms the shared subscription. */
     onSubscribed = () => {
         logger.debug("onSubscribed");
     };
-    /** onRejected. */
+    /** Marks the pool disconnected when ActionCable rejects the shared subscription. */
     onRejected = () => {
         this.connected = false;
         if (this.skipDisconnectHandling) {
@@ -196,7 +227,7 @@ export default class ApiMakerCableSubscriptionPool {
         this.authRefreshCallbacks.reject?.(error);
         this.clearAuthRefreshCallbacks();
     }
-    /** onUnsubscribe. */
+    /** Releases one tracked logical subscription and tears down the shared stream when the pool becomes empty. */
     onUnsubscribe() {
         if (this.skipDisconnectHandling) {
             return;
@@ -210,7 +241,11 @@ export default class ApiMakerCableSubscriptionPool {
             this.connected = false;
         }
     }
-    /** registerSubscriptions. */
+    /**
+     * Registers the logical subscriptions served by this shared ActionCable stream.
+     * @param {object} subscriptions
+     * @returns {void}
+     */
     registerSubscriptions(subscriptions) {
         this.subscriptions = subscriptions;
         logger.debug(() => ["registerSubscriptions", { subscriptions }]);
@@ -239,7 +274,11 @@ export default class ApiMakerCableSubscriptionPool {
             }
         }
     }
-    /** connectUnsubscriptionForSubscription. */
+    /**
+     * Hooks pool bookkeeping up to a child subscription's unsubscribe event.
+     * @param {CableSubscription} subscription
+     * @returns {void}
+     */
     connectUnsubscriptionForSubscription(subscription) {
         logger.debug(() => ["Connecting to unsubscribe on subscription", { subscription }]);
         this.activeSubscriptions += 1;
@@ -262,4 +301,4 @@ export default class ApiMakerCableSubscriptionPool {
         this.activeSubscriptions = 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cable-subscription-pool.js","sourceRoot":"/src/","sources":["cable-subscription-pool.js"],"names":[],"mappings":"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","sourcesContent":["import * as inflection from \"inflection\"\nimport {digg} from \"diggerize\"\nimport CommandsPool from \"./commands-pool.js\" // eslint-disable-line sort-imports\nimport Deserializer from \"./deserializer.js\"\nimport getChannelsConsumer from \"./channels-consumer.js\"\nimport Logger from \"./logger.js\" // eslint-disable-line sort-imports\n\nconst logger = new Logger({name: \"ApiMaker / CableSubscriptionPool\"})\nconst AUTH_REFRESH_TIMEOUT_MS = 5000\n\n/** Subscription pool for sharing channel subscriptions. */\nexport default class ApiMakerCableSubscriptionPool {\n  /** Constructor. */\n  constructor () {\n    this.activeSubscriptions = 0\n    this.authRefreshCallbacks = {}\n    this.connected = false\n    this.skipDisconnectHandling = false\n  }\n\n  /** connect. */\n  connect (subscriptionData) {\n    const globalData = CommandsPool.current().globalRequestData\n\n    logger.debug(() => [\"Creating subscription\", {subscriptionData}])\n\n    this.subscription = getChannelsConsumer().subscriptions.create(\n      {\n        channel: \"ApiMaker::SubscriptionsChannel\",\n        global: globalData,\n        subscription_data: subscriptionData\n      },\n      {\n        connected: this.onConnected,\n        disconnected: this.onDisconnected,\n        received: this.onReceived,\n        rejected: this.onRejected,\n        subscribed: this.onSubscribed\n      }\n    )\n    this.connected = true\n  }\n\n  /**\n   * Refreshes auth for the existing subscription without recreating the pool.\n   *\n   * @param {Record<string, any>} args\n   * @returns {Promise<void>}\n   */\n  refreshAuthentication (args) {\n    if (!this.connected || !this.subscription) {\n      return Promise.resolve()\n    }\n\n    if (this.authRefreshCallbacks.promise) {\n      return this.authRefreshCallbacks.promise\n    }\n\n    this.authRefreshCallbacks.promise = new Promise((resolve, reject) => {\n      this.authRefreshCallbacks.resolve = resolve\n      this.authRefreshCallbacks.reject = reject\n      this.authRefreshCallbacks.timeoutId = setTimeout(() => {\n        this.rejectAuthRefresh(new Error(\"Subscription auth refresh timed out\"))\n      }, AUTH_REFRESH_TIMEOUT_MS)\n    })\n\n    this.subscription.perform(\"refresh_auth\", args)\n\n    return this.authRefreshCallbacks.promise\n  }\n\n  /** forEachSubscription. */\n  forEachSubscription (callback) {\n    const modelIdModes = [\"destroys\", \"updates\"]\n    const subscriptions = digg(this, \"subscriptions\")\n\n    for (const modelName in subscriptions) {\n      for (const modelIdMode of modelIdModes) {\n        if (subscriptions[modelName][modelIdMode]) {\n          for (const modelId in subscriptions[modelName][modelIdMode]) {\n            // eslint-disable-next-line max-depth\n            for (const subscription of subscriptions[modelName][modelIdMode][modelId]) {\n              callback({mode: modelIdMode, modelId, modelName, subscription})\n            }\n          }\n        }\n      }\n\n      if (subscriptions[modelName].creates) {\n        for (const subscription of subscriptions[modelName].creates) {\n          callback({mode: \"creates\", modelName, subscription})\n        }\n      }\n\n      if (subscriptions[modelName].model_class_events) {\n        for (const eventName in subscriptions[modelName].model_class_events) {\n          for (const subscription of subscriptions[modelName].model_class_events[eventName]) {\n            callback({eventName, mode: \"model_class_events\", modelName, subscription})\n          }\n        }\n      }\n\n      if (subscriptions[modelName].events) {\n        for (const modelId in subscriptions[modelName].events) {\n          for (const eventName in subscriptions[modelName].events[modelId]) {\n            // eslint-disable-next-line max-depth\n            for (const subscription of subscriptions[modelName].events[modelId][eventName]) {\n              callback({eventName, mode: \"updates\", modelId, modelName, subscription})\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /** isConnected. */\n  isConnected = () => digg(this, \"connected\")\n\n  /** onConnected. */\n  onConnected = () => {\n    this.connected = true\n\n    this.forEachSubscription(({subscription}) => {\n      subscription.events.emit(\"connected\")\n    })\n  }\n\n  /** onDisconnected. */\n  onDisconnected = () => {\n    this.connected = false\n\n    if (this.skipDisconnectHandling) {\n      return\n    }\n\n    this.rejectAuthRefresh(new Error(\"Subscription auth refresh was interrupted by a disconnect\"))\n  }\n\n  /** onReceived. */\n  onReceived = (rawData) => {\n    if (rawData.type == \"api_maker_subscription_auth_refreshed\") {\n      this.resolveAuthRefresh()\n      return\n    }\n\n    if (rawData.type == \"api_maker_subscription_auth_refresh_error\") {\n      this.rejectAuthRefresh(new Error(rawData.error?.message || \"Subscription auth refresh failed\"))\n      return\n    }\n\n    const data = Deserializer.parse(rawData)\n    const {a: args, e: eventName, m: model, mi: modelId, mt: modelType, t: type} = data\n    const subscriptions = digg(this, \"subscriptions\")\n\n    let modelName\n\n    // This is more effective if it is an option\n    if (model) {\n      modelName = digg(model.modelClassData(), \"name\")\n    } else {\n      modelName = inflection.camelize(inflection.singularize(modelType))\n    }\n\n    if (type == \"u\") {\n      for (const subscription of subscriptions[modelName].updates[modelId]) {\n        subscription.events.emit(\"received\", {model})\n      }\n    } else if (type == \"c\") {\n      for (const subscription of subscriptions[modelName].creates) {\n        subscription.events.emit(\"received\", {model})\n      }\n    } else if (type == \"d\") {\n      const destroySubscriptions = digg(subscriptions, modelName, \"destroys\", modelId)\n\n      for (const subscription of destroySubscriptions) {\n        subscription.events.emit(\"received\", {model})\n      }\n    } else if (type == \"e\") {\n      const eventSubscriptions = digg(subscriptions, modelName, \"events\", eventName, modelId)\n\n      for (const subscription of eventSubscriptions) {\n        subscription.events.emit(\"received\", {args, eventName, model})\n      }\n    } else if (type == \"mce\") {\n      const modelClassEventSubscriptions = digg(subscriptions, modelName, \"model_class_events\", eventName)\n\n      for (const subscription of modelClassEventSubscriptions) {\n        subscription.events.emit(\"received\", {args, eventName})\n      }\n    } else {\n      throw new Error(`Unknown type: ${data.type}`)\n    }\n  }\n\n  /** onSubscribed. */\n  onSubscribed = () => {\n    logger.debug(\"onSubscribed\")\n  }\n\n  /** onRejected. */\n  onRejected = () => {\n    this.connected = false\n\n    if (this.skipDisconnectHandling) {\n      return\n    }\n\n    this.rejectAuthRefresh(new Error(\"Subscription auth refresh was rejected\"))\n  }\n\n  /** @returns {void} */\n  clearAuthRefreshCallbacks () {\n    if (this.authRefreshCallbacks.timeoutId) {\n      clearTimeout(this.authRefreshCallbacks.timeoutId)\n    }\n\n    this.authRefreshCallbacks = {}\n  }\n\n  /** @returns {void} */\n  resolveAuthRefresh () {\n    this.authRefreshCallbacks.resolve?.()\n    this.clearAuthRefreshCallbacks()\n  }\n\n  /**\n   * @param {Error} error\n   * @returns {void}\n   */\n  rejectAuthRefresh (error) {\n    this.authRefreshCallbacks.reject?.(error)\n    this.clearAuthRefreshCallbacks()\n  }\n\n  /** onUnsubscribe. */\n  onUnsubscribe () {\n    if (this.skipDisconnectHandling) {\n      return\n    }\n\n    logger.debug(() => `activeSubscriptions before unsub: ${this.activeSubscriptions}`)\n    this.activeSubscriptions -= 1\n    logger.debug(() => `activeSubscriptions after unsub: ${this.activeSubscriptions}`)\n\n    if (this.activeSubscriptions <= 0) {\n      logger.debug(\"Unsubscribe from ActionCable subscription\")\n      this.subscription.unsubscribe()\n      this.connected = false\n    }\n  }\n\n  /** registerSubscriptions. */\n  registerSubscriptions (subscriptions) {\n    this.subscriptions = subscriptions\n\n    logger.debug(() => [\"registerSubscriptions\", {subscriptions}])\n\n    for (const modelName in subscriptions) {\n      if (subscriptions[modelName].creates) {\n        for (const subscription of subscriptions[modelName].creates) {\n          this.connectUnsubscriptionForSubscription(subscription)\n        }\n      }\n\n      if (subscriptions[modelName].events) {\n        for (const eventName in subscriptions[modelName].events) {\n          for (const modelId in subscriptions[modelName].events[eventName]) {\n            // eslint-disable-next-line max-depth\n            for (const subscription of subscriptions[modelName].events[eventName][modelId]) {\n              this.connectUnsubscriptionForSubscription(subscription)\n            }\n          }\n        }\n      }\n\n      if (subscriptions[modelName].updates) {\n        for (const modelId in subscriptions[modelName].updates) {\n          for (const subscription of subscriptions[modelName].updates[modelId]) {\n            this.connectUnsubscriptionForSubscription(subscription)\n          }\n        }\n      }\n    }\n  }\n\n  /** connectUnsubscriptionForSubscription. */\n  connectUnsubscriptionForSubscription (subscription) {\n    logger.debug(() => [\"Connecting to unsubscribe on subscription\", {subscription}])\n\n    this.activeSubscriptions += 1\n\n    subscription.events.addListener(\"unsubscribed\", () => {\n      logger.debug(\"Call onUnsubscribe on self\")\n\n      // @ts-expect-error\n      this.onUnsubscribe(subscription)\n    })\n  }\n\n  /** @returns {void} */\n  reset () {\n    this.skipDisconnectHandling = true\n    this.connected = false\n    this.rejectAuthRefresh(new Error(\"Subscription pool was reset\"))\n\n    if (this.subscription?.unsubscribe) {\n      this.subscription.unsubscribe()\n    }\n\n    this.subscription = undefined\n    this.subscriptions = undefined\n    this.activeSubscriptions = 0\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cable-subscription-pool.js","sourceRoot":"/src/","sources":["cable-subscription-pool.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\"\nimport {digg} from \"diggerize\"\nimport CommandsPool from \"./commands-pool.js\" // eslint-disable-line sort-imports\nimport Deserializer from \"./deserializer.js\"\nimport getChannelsConsumer from \"./channels-consumer.js\"\nimport Logger from \"./logger.js\" // eslint-disable-line sort-imports\n\nconst logger = new Logger({name: \"ApiMaker / CableSubscriptionPool\"})\nconst AUTH_REFRESH_TIMEOUT_MS = 5000\n\n/** @typedef {import(\"./base-model.js\").default} BaseModel */\n/** @typedef {import(\"./cable-subscription.js\").default} CableSubscription */\n/** @typedef {string | number | boolean | null} EventArgumentPrimitive */\n/** @typedef {EventArgumentPrimitive | EventArgumentPrimitive[]} EventArgumentValue */\n/** @typedef {Record<string, EventArgumentValue>} SubscriptionRefreshArgs */\n/** @typedef {{channel: string, global: object, subscription_data: object}} CableSubscriptionCreateArgs */\n/** @typedef {{model: BaseModel}} ModelMutationPayload */\n/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string, model: BaseModel}} ModelEventPayload */\n/** @typedef {{args: Record<string, EventArgumentValue>, eventName: string}} ModelClassEventPayload */\n/**\n * @typedef {object} SubscriptionIterationArgs\n * @property {string} [eventName]\n * @property {\"creates\"|\"destroys\"|\"updates\"|\"model_class_events\"} mode\n * @property {string} [modelId]\n * @property {string} modelName\n * @property {CableSubscription} subscription\n */\n\n/** Subscription pool for sharing channel subscriptions. */\nexport default class ApiMakerCableSubscriptionPool {\n  /** Initializes bookkeeping for one shared ActionCable subscription pool. */\n  constructor () {\n    this.activeSubscriptions = 0\n    this.authRefreshCallbacks = {}\n    this.connected = false\n    this.skipDisconnectHandling = false\n  }\n\n  /**\n   * Opens the shared ActionCable subscription for the given subscription tree.\n   * @param {object} subscriptionData\n   * @returns {void}\n   */\n  connect (subscriptionData) {\n    const globalData = CommandsPool.current().globalRequestData\n\n    logger.debug(() => [\"Creating subscription\", {subscriptionData}])\n\n    this.subscription = getChannelsConsumer().subscriptions.create(\n      /** @type {CableSubscriptionCreateArgs} */ ({\n        channel: \"ApiMaker::SubscriptionsChannel\",\n        global: globalData,\n        subscription_data: subscriptionData\n      }),\n      {\n        connected: this.onConnected,\n        disconnected: this.onDisconnected,\n        received: this.onReceived,\n        rejected: this.onRejected,\n        subscribed: this.onSubscribed\n      }\n    )\n    this.connected = true\n  }\n\n  /**\n   * Refreshes auth for the existing subscription without recreating the pool.\n   *\n   * @param {SubscriptionRefreshArgs} args\n   * @returns {Promise<void>}\n   */\n  refreshAuthentication (args) {\n    if (!this.connected || !this.subscription) {\n      return Promise.resolve()\n    }\n\n    if (this.authRefreshCallbacks.promise) {\n      return this.authRefreshCallbacks.promise\n    }\n\n    this.authRefreshCallbacks.promise = new Promise((resolve, reject) => {\n      this.authRefreshCallbacks.resolve = resolve\n      this.authRefreshCallbacks.reject = reject\n      this.authRefreshCallbacks.timeoutId = setTimeout(() => {\n        this.rejectAuthRefresh(new Error(\"Subscription auth refresh timed out\"))\n      }, AUTH_REFRESH_TIMEOUT_MS)\n    })\n\n    this.subscription.perform(\"refresh_auth\", args)\n\n    return this.authRefreshCallbacks.promise\n  }\n\n  /**\n   * Iterates over every tracked subscription with its stream metadata.\n   * @param {(args: SubscriptionIterationArgs) => void} callback\n   * @returns {void}\n  */\n  forEachSubscription (callback) {\n    const modelIdModes = /** @type {Array<\"destroys\"|\"updates\">} */ ([\"destroys\", \"updates\"])\n    const subscriptions = digg(this, \"subscriptions\")\n\n    for (const modelName in subscriptions) {\n      for (const modelIdMode of modelIdModes) {\n        if (subscriptions[modelName][modelIdMode]) {\n          for (const modelId in subscriptions[modelName][modelIdMode]) {\n            // eslint-disable-next-line max-depth\n            for (const subscription of subscriptions[modelName][modelIdMode][modelId]) {\n              callback({mode: modelIdMode, modelId, modelName, subscription})\n            }\n          }\n        }\n      }\n\n      if (subscriptions[modelName].creates) {\n        for (const subscription of subscriptions[modelName].creates) {\n          callback({mode: \"creates\", modelName, subscription})\n        }\n      }\n\n      if (subscriptions[modelName].model_class_events) {\n        for (const eventName in subscriptions[modelName].model_class_events) {\n          for (const subscription of subscriptions[modelName].model_class_events[eventName]) {\n            callback({eventName, mode: \"model_class_events\", modelName, subscription})\n          }\n        }\n      }\n\n      if (subscriptions[modelName].events) {\n        for (const modelId in subscriptions[modelName].events) {\n          for (const eventName in subscriptions[modelName].events[modelId]) {\n            // eslint-disable-next-line max-depth\n            for (const subscription of subscriptions[modelName].events[modelId][eventName]) {\n              callback({eventName, mode: \"updates\", modelId, modelName, subscription})\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /** @returns {boolean} */\n  isConnected = () => digg(this, \"connected\")\n\n  /** Marks the pool connected and notifies each subscriber once the stream is ready. */\n  onConnected = () => {\n    this.connected = true\n\n    this.forEachSubscription(({subscription}) => {\n      subscription.events.emit(\"connected\")\n    })\n  }\n\n  /** Marks the pool disconnected and fails pending auth refreshes unless teardown is intentional. */\n  onDisconnected = () => {\n    this.connected = false\n\n    if (this.skipDisconnectHandling) {\n      return\n    }\n\n    this.rejectAuthRefresh(new Error(\"Subscription auth refresh was interrupted by a disconnect\"))\n  }\n\n  /**\n   * Routes one ActionCable payload to the matching logical subscriptions.\n   * @param {object} rawData\n   * @returns {void}\n   */\n  onReceived = (rawData) => {\n    if (rawData.type == \"api_maker_subscription_auth_refreshed\") {\n      this.resolveAuthRefresh()\n      return\n    }\n\n    if (rawData.type == \"api_maker_subscription_auth_refresh_error\") {\n      this.rejectAuthRefresh(new Error(rawData.error?.message || \"Subscription auth refresh failed\"))\n      return\n    }\n\n    const data = Deserializer.parse(rawData)\n    const {a: args, e: eventName, m: model, mi: modelId, mt: modelType, t: type} = data\n    const subscriptions = digg(this, \"subscriptions\")\n\n    let modelName\n\n    // This is more effective if it is an option\n    if (model) {\n      modelName = digg(model.modelClassData(), \"name\")\n    } else {\n      modelName = inflection.camelize(inflection.singularize(modelType))\n    }\n\n    if (type == \"u\") {\n      for (const subscription of subscriptions[modelName].updates[modelId]) {\n        subscription.events.emit(\"received\", /** @type {ModelMutationPayload} */ ({model}))\n      }\n    } else if (type == \"c\") {\n      for (const subscription of subscriptions[modelName].creates) {\n        subscription.events.emit(\"received\", /** @type {ModelMutationPayload} */ ({model}))\n      }\n    } else if (type == \"d\") {\n      const destroySubscriptions = digg(subscriptions, modelName, \"destroys\", modelId)\n\n      for (const subscription of destroySubscriptions) {\n        subscription.events.emit(\"received\", /** @type {ModelMutationPayload} */ ({model}))\n      }\n    } else if (type == \"e\") {\n      const eventSubscriptions = digg(subscriptions, modelName, \"events\", eventName, modelId)\n\n      for (const subscription of eventSubscriptions) {\n        subscription.events.emit(\"received\", /** @type {ModelEventPayload} */ ({args, eventName, model}))\n      }\n    } else if (type == \"mce\") {\n      const modelClassEventSubscriptions = digg(subscriptions, modelName, \"model_class_events\", eventName)\n\n      for (const subscription of modelClassEventSubscriptions) {\n        subscription.events.emit(\"received\", /** @type {ModelClassEventPayload} */ ({args, eventName}))\n      }\n    } else {\n      throw new Error(`Unknown type: ${data.type}`)\n    }\n  }\n\n  /** Logs when ActionCable confirms the shared subscription. */\n  onSubscribed = () => {\n    logger.debug(\"onSubscribed\")\n  }\n\n  /** Marks the pool disconnected when ActionCable rejects the shared subscription. */\n  onRejected = () => {\n    this.connected = false\n\n    if (this.skipDisconnectHandling) {\n      return\n    }\n\n    this.rejectAuthRefresh(new Error(\"Subscription auth refresh was rejected\"))\n  }\n\n  /** @returns {void} */\n  clearAuthRefreshCallbacks () {\n    if (this.authRefreshCallbacks.timeoutId) {\n      clearTimeout(this.authRefreshCallbacks.timeoutId)\n    }\n\n    this.authRefreshCallbacks = {}\n  }\n\n  /** @returns {void} */\n  resolveAuthRefresh () {\n    this.authRefreshCallbacks.resolve?.()\n    this.clearAuthRefreshCallbacks()\n  }\n\n  /**\n   * @param {Error} error\n   * @returns {void}\n   */\n  rejectAuthRefresh (error) {\n    this.authRefreshCallbacks.reject?.(error)\n    this.clearAuthRefreshCallbacks()\n  }\n\n  /** Releases one tracked logical subscription and tears down the shared stream when the pool becomes empty. */\n  onUnsubscribe () {\n    if (this.skipDisconnectHandling) {\n      return\n    }\n\n    logger.debug(() => `activeSubscriptions before unsub: ${this.activeSubscriptions}`)\n    this.activeSubscriptions -= 1\n    logger.debug(() => `activeSubscriptions after unsub: ${this.activeSubscriptions}`)\n\n    if (this.activeSubscriptions <= 0) {\n      logger.debug(\"Unsubscribe from ActionCable subscription\")\n      this.subscription.unsubscribe()\n      this.connected = false\n    }\n  }\n\n  /**\n   * Registers the logical subscriptions served by this shared ActionCable stream.\n   * @param {object} subscriptions\n   * @returns {void}\n   */\n  registerSubscriptions (subscriptions) {\n    this.subscriptions = subscriptions\n\n    logger.debug(() => [\"registerSubscriptions\", {subscriptions}])\n\n    for (const modelName in subscriptions) {\n      if (subscriptions[modelName].creates) {\n        for (const subscription of subscriptions[modelName].creates) {\n          this.connectUnsubscriptionForSubscription(subscription)\n        }\n      }\n\n      if (subscriptions[modelName].events) {\n        for (const eventName in subscriptions[modelName].events) {\n          for (const modelId in subscriptions[modelName].events[eventName]) {\n            // eslint-disable-next-line max-depth\n            for (const subscription of subscriptions[modelName].events[eventName][modelId]) {\n              this.connectUnsubscriptionForSubscription(subscription)\n            }\n          }\n        }\n      }\n\n      if (subscriptions[modelName].updates) {\n        for (const modelId in subscriptions[modelName].updates) {\n          for (const subscription of subscriptions[modelName].updates[modelId]) {\n            this.connectUnsubscriptionForSubscription(subscription)\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Hooks pool bookkeeping up to a child subscription's unsubscribe event.\n   * @param {CableSubscription} subscription\n   * @returns {void}\n   */\n  connectUnsubscriptionForSubscription (subscription) {\n    logger.debug(() => [\"Connecting to unsubscribe on subscription\", {subscription}])\n\n    this.activeSubscriptions += 1\n\n    subscription.events.addListener(\"unsubscribed\", () => {\n      logger.debug(\"Call onUnsubscribe on self\")\n\n      // @ts-expect-error\n      this.onUnsubscribe(subscription)\n    })\n  }\n\n  /** @returns {void} */\n  reset () {\n    this.skipDisconnectHandling = true\n    this.connected = false\n    this.rejectAuthRefresh(new Error(\"Subscription pool was reset\"))\n\n    if (this.subscription?.unsubscribe) {\n      this.subscription.unsubscribe()\n    }\n\n    this.subscription = undefined\n    this.subscriptions = undefined\n    this.activeSubscriptions = 0\n  }\n}\n"]}

package/build/cable-subscription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cable-subscription.d.ts","sourceRoot":"/src/","sources":["cable-subscription.js"],"names":[],"mappings":"AAKA,0DAA0D;AAC1D;IAGI,2CAAgC;IAChC,oBAAsB;IAGxB,sBAAsB;IACtB,eADc,IAAI,CAWjB;CACF;6BAzB0B,eAAe"}
+{"version":3,"file":"cable-subscription.d.ts","sourceRoot":"/src/","sources":["cable-subscription.js"],"names":[],"mappings":"AAMA,0DAA0D;AAC1D;IAGI,2CAAgC;IAChC,oBAAsB;IAGxB,sBAAsB;IACtB,eADc,IAAI,CAWjB;CACF;6BAzB0B,eAAe"}

package/build/cable-subscription.js

@@ -1,9 +1,10 @@
+// @ts-check
 import { EventEmitter } from "eventemitter3";
 import Logger from "./logger.js";
 const logger = new Logger({ name: "ApiMaker / CableSubscription" });
 /** Cable subscription wrapper with unsubscribe events. */
 export default class ApiMakerCableSubscription {
-    /** Constructor. */
+    /** Creates one logical subscription wrapper around an EventEmitter. */
     constructor() {
         this.events = new EventEmitter();
         this.subscribed = true;
@@ -19,4 +20,4 @@ export default class ApiMakerCableSubscription {
         this.events.emit("unsubscribed");
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FibGUtc3Vic2NyaXB0aW9uLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJjYWJsZS1zdWJzY3JpcHRpb24uanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGVBQWUsQ0FBQTtBQUMxQyxPQUFPLE1BQU0sTUFBTSxhQUFhLENBQUE7QUFFaEMsTUFBTSxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsRUFBQyxJQUFJLEVBQUUsOEJBQThCLEVBQUMsQ0FBQyxDQUFBO0FBRWpFLDBEQUEwRDtBQUMxRCxNQUFNLENBQUMsT0FBTyxPQUFPLHlCQUF5QjtJQUM1QyxtQkFBbUI7SUFDbkI7UUFDRSxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksWUFBWSxFQUFFLENBQUE7UUFDaEMsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUE7SUFDeEIsQ0FBQztJQUVELHNCQUFzQjtJQUN0QixXQUFXO1FBQ1QsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNyQixNQUFNLENBQUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUE7WUFDM0MsT0FBTTtRQUNSLENBQUM7UUFFRCxNQUFNLENBQUMsS0FBSyxDQUFDLHFDQUFxQyxDQUFDLENBQUE7UUFFbkQsSUFBSSxDQUFDLFVBQVUsR0FBRyxLQUFLLENBQUE7UUFDdkIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUE7SUFDbEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFdmVudEVtaXR0ZXJ9IGZyb20gXCJldmVudGVtaXR0ZXIzXCJcbmltcG9ydCBMb2dnZXIgZnJvbSBcIi4vbG9nZ2VyLmpzXCJcblxuY29uc3QgbG9nZ2VyID0gbmV3IExvZ2dlcih7bmFtZTogXCJBcGlNYWtlciAvIENhYmxlU3Vic2NyaXB0aW9uXCJ9KVxuXG4vKiogQ2FibGUgc3Vic2NyaXB0aW9uIHdyYXBwZXIgd2l0aCB1bnN1YnNjcmliZSBldmVudHMuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBBcGlNYWtlckNhYmxlU3Vic2NyaXB0aW9uIHtcbiAgLyoqIENvbnN0cnVjdG9yLiAqL1xuICBjb25zdHJ1Y3RvciAoKSB7XG4gICAgdGhpcy5ldmVudHMgPSBuZXcgRXZlbnRFbWl0dGVyKClcbiAgICB0aGlzLnN1YnNjcmliZWQgPSB0cnVlXG4gIH1cblxuICAvKiogQHJldHVybnMge3ZvaWR9ICovXG4gIHVuc3Vic2NyaWJlICgpIHtcbiAgICBpZiAoIXRoaXMuc3Vic2NyaWJlZCkge1xuICAgICAgbG9nZ2VyLmRlYnVnKFwiVW5zdWJzY3JpYmVkIGFscmVhZHkgY2FsbGVkXCIpXG4gICAgICByZXR1cm5cbiAgICB9XG5cbiAgICBsb2dnZXIuZGVidWcoXCJVbnN1YnNjcmliZSBjYWxsZWQgZm9yIHN1YnNjcmlwdGlvblwiKVxuXG4gICAgdGhpcy5zdWJzY3JpYmVkID0gZmFsc2VcbiAgICB0aGlzLmV2ZW50cy5lbWl0KFwidW5zdWJzY3JpYmVkXCIpXG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FibGUtc3Vic2NyaXB0aW9uLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJjYWJsZS1zdWJzY3JpcHRpb24uanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxlQUFlLENBQUE7QUFDMUMsT0FBTyxNQUFNLE1BQU0sYUFBYSxDQUFBO0FBRWhDLE1BQU0sTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLEVBQUMsSUFBSSxFQUFFLDhCQUE4QixFQUFDLENBQUMsQ0FBQTtBQUVqRSwwREFBMEQ7QUFDMUQsTUFBTSxDQUFDLE9BQU8sT0FBTyx5QkFBeUI7SUFDNUMsdUVBQXVFO0lBQ3ZFO1FBQ0UsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLFlBQVksRUFBRSxDQUFBO1FBQ2hDLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFBO0lBQ3hCLENBQUM7SUFFRCxzQkFBc0I7SUFDdEIsV0FBVztRQUNULElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDckIsTUFBTSxDQUFDLEtBQUssQ0FBQyw2QkFBNkIsQ0FBQyxDQUFBO1lBQzNDLE9BQU07UUFDUixDQUFDO1FBRUQsTUFBTSxDQUFDLEtBQUssQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFBO1FBRW5ELElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFBO1FBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFBO0lBQ2xDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuaW1wb3J0IHtFdmVudEVtaXR0ZXJ9IGZyb20gXCJldmVudGVtaXR0ZXIzXCJcbmltcG9ydCBMb2dnZXIgZnJvbSBcIi4vbG9nZ2VyLmpzXCJcblxuY29uc3QgbG9nZ2VyID0gbmV3IExvZ2dlcih7bmFtZTogXCJBcGlNYWtlciAvIENhYmxlU3Vic2NyaXB0aW9uXCJ9KVxuXG4vKiogQ2FibGUgc3Vic2NyaXB0aW9uIHdyYXBwZXIgd2l0aCB1bnN1YnNjcmliZSBldmVudHMuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBBcGlNYWtlckNhYmxlU3Vic2NyaXB0aW9uIHtcbiAgLyoqIENyZWF0ZXMgb25lIGxvZ2ljYWwgc3Vic2NyaXB0aW9uIHdyYXBwZXIgYXJvdW5kIGFuIEV2ZW50RW1pdHRlci4gKi9cbiAgY29uc3RydWN0b3IgKCkge1xuICAgIHRoaXMuZXZlbnRzID0gbmV3IEV2ZW50RW1pdHRlcigpXG4gICAgdGhpcy5zdWJzY3JpYmVkID0gdHJ1ZVxuICB9XG5cbiAgLyoqIEByZXR1cm5zIHt2b2lkfSAqL1xuICB1bnN1YnNjcmliZSAoKSB7XG4gICAgaWYgKCF0aGlzLnN1YnNjcmliZWQpIHtcbiAgICAgIGxvZ2dlci5kZWJ1ZyhcIlVuc3Vic2NyaWJlZCBhbHJlYWR5IGNhbGxlZFwiKVxuICAgICAgcmV0dXJuXG4gICAgfVxuXG4gICAgbG9nZ2VyLmRlYnVnKFwiVW5zdWJzY3JpYmUgY2FsbGVkIGZvciBzdWJzY3JpcHRpb25cIilcblxuICAgIHRoaXMuc3Vic2NyaWJlZCA9IGZhbHNlXG4gICAgdGhpcy5ldmVudHMuZW1pdChcInVuc3Vic2NyaWJlZFwiKVxuICB9XG59XG4iXX0=