@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/cable-subscription-pool.js

@@ -0,0 +1,207 @@
+import getChannelsConsumer from "./channels-consumer";
+import CommandsPool from "./commands-pool";
+import Deserializer from "./deserializer";
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import Logger from "./logger";
+const logger = new Logger({
+  name: "ApiMaker / CableSubscriptionPool"
+});
+export default class ApiMakerCableSubscriptionPool {
+  constructor() {
+    this.activeSubscriptions = 0;
+    this.connected = false;
+  }
+  connect(subscriptionData) {
+    const globalData = CommandsPool.current().globalRequestData;
+    logger.debug(() => ["Creating subscription", {
+      subscriptionData
+    }]);
+    this.subscription = getChannelsConsumer().subscriptions.create({
+      channel: "ApiMaker::SubscriptionsChannel",
+      global: globalData,
+      subscription_data: subscriptionData
+    }, {
+      connected: this.onConnected,
+      received: this.onReceived,
+      subscribed: this.onSubscribed
+    });
+    this.connected = true;
+  }
+  forEachSubscription(callback) {
+    const modelIdModes = ["destroys", "updates"];
+    const subscriptions = digg(this, "subscriptions");
+    for (const modelName in subscriptions) {
+      for (const modelIdMode of modelIdModes) {
+        if (subscriptions[modelName][modelIdMode]) {
+          for (const modelId in subscriptions[modelName][modelIdMode]) {
+            for (const subscription of subscriptions[modelName][modelIdMode][modelId]) {
+              callback({
+                mode: modelIdMode,
+                modelId,
+                modelName,
+                subscription
+              });
+            }
+          }
+        }
+      }
+      if (subscriptions[modelName].creates) {
+        for (const subscription of subscriptions[modelName].creates) {
+          callback({
+            mode: "creates",
+            modelName,
+            subscription
+          });
+        }
+      }
+      if (subscriptions[modelName].model_class_events) {
+        for (const eventName in subscriptions[modelName].model_class_events) {
+          for (const subscription of subscriptions[modelName].model_class_events[eventName]) {
+            callback({
+              eventName,
+              mode: "model_class_events",
+              modelName,
+              subscription
+            });
+          }
+        }
+      }
+      if (subscriptions[modelName].events) {
+        for (const modelId in subscriptions[modelName].events) {
+          for (const eventName in subscriptions[modelName].events[modelId]) {
+            for (const subscription of subscriptions[modelName].events[modelId][eventName]) {
+              callback({
+                eventName,
+                mode: "updates",
+                modelId,
+                modelName,
+                subscription
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  isConnected = () => digg(this, "connected");
+  onConnected = () => {
+    this.forEachSubscription(({
+      subscription
+    }) => {
+      subscription.events.emit("connected");
+    });
+  };
+  onReceived = rawData => {
+    const data = Deserializer.parse(rawData);
+    const {
+      a: args,
+      e: eventName,
+      m: model,
+      mi: modelId,
+      mt: modelType,
+      t: type
+    } = data;
+    const subscriptions = digg(this, "subscriptions");
+    let modelName;
+
+    // This is more effective if it is an option
+    if (model) {
+      modelName = digg(model.modelClassData(), "name");
+    } else {
+      modelName = inflection.camelize(inflection.singularize(modelType));
+    }
+    if (type == "u") {
+      for (const subscription of subscriptions[modelName].updates[modelId]) {
+        subscription.events.emit("received", {
+          model
+        });
+      }
+    } else if (type == "c") {
+      for (const subscription of subscriptions[modelName].creates) {
+        subscription.events.emit("received", {
+          model
+        });
+      }
+    } else if (type == "d") {
+      const destroySubscriptions = digg(subscriptions, modelName, "destroys", modelId);
+      for (const subscription of destroySubscriptions) {
+        subscription.events.emit("received", {
+          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
+        });
+      }
+    } else if (type == "mce") {
+      const modelClassEventSubscriptions = digg(subscriptions, modelName, "model_class_events", eventName);
+      for (const subscription of modelClassEventSubscriptions) {
+        subscription.events.emit("received", {
+          args,
+          eventName
+        });
+      }
+    } else {
+      throw new Error(`Unknown type: ${data.type}`);
+    }
+  };
+  onSubscribed = () => {
+    logger.debug("onSubscribed");
+  };
+  onUnsubscribe() {
+    logger.debug(() => `activeSubscriptions before unsub: ${this.activeSubscriptions}`);
+    this.activeSubscriptions -= 1;
+    logger.debug(() => `activeSubscriptions after unsub: ${this.activeSubscriptions}`);
+    if (this.activeSubscriptions <= 0) {
+      logger.debug("Unsubscribe from ActionCable subscription");
+      this.subscription.unsubscribe();
+      this.connected = false;
+    }
+  }
+  registerSubscriptions(subscriptions) {
+    this.subscriptions = subscriptions;
+    logger.debug(() => ["registerSubscriptions", {
+      subscriptions
+    }]);
+    for (const modelName in subscriptions) {
+      if (subscriptions[modelName].creates) {
+        for (const subscription of subscriptions[modelName].creates) {
+          this.connectUnsubscriptionForSubscription(subscription);
+        }
+      }
+      if (subscriptions[modelName].events) {
+        for (const eventName in subscriptions[modelName].events) {
+          for (const modelId in subscriptions[modelName].events[eventName]) {
+            for (const subscription of subscriptions[modelName].events[eventName][modelId]) {
+              this.connectUnsubscriptionForSubscription(subscription);
+            }
+          }
+        }
+      }
+      if (subscriptions[modelName].updates) {
+        for (const modelId in subscriptions[modelName].updates) {
+          for (const subscription of subscriptions[modelName].updates[modelId]) {
+            this.connectUnsubscriptionForSubscription(subscription);
+          }
+        }
+      }
+    }
+  }
+  connectUnsubscriptionForSubscription(subscription) {
+    logger.debug(() => ["Connecting to unsubscribe on subscription", {
+      subscription
+    }]);
+    this.activeSubscriptions += 1;
+    subscription.events.addListener("unsubscribed", () => {
+      logger.debug("Call onUnsubscribe on self");
+      this.onUnsubscribe(subscription);
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getChannelsConsumer","CommandsPool","Deserializer","digg","inflection","Logger","logger","name","ApiMakerCableSubscriptionPool","constructor","activeSubscriptions","connected","connect","subscriptionData","globalData","current","globalRequestData","debug","subscription","subscriptions","create","channel","global","subscription_data","onConnected","received","onReceived","subscribed","onSubscribed","forEachSubscription","callback","modelIdModes","modelName","modelIdMode","modelId","mode","creates","model_class_events","eventName","events","isConnected","emit","rawData","data","parse","a","args","e","m","model","mi","mt","modelType","t","type","modelClassData","camelize","singularize","updates","destroySubscriptions","eventSubscriptions","modelClassEventSubscriptions","Error","onUnsubscribe","unsubscribe","registerSubscriptions","connectUnsubscriptionForSubscription","addListener"],"sources":["../src/cable-subscription-pool.js"],"sourcesContent":["import getChannelsConsumer from \"./channels-consumer\"\nimport CommandsPool from \"./commands-pool\"\nimport Deserializer from \"./deserializer\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport Logger from \"./logger\"\n\nconst logger = new Logger({name: \"ApiMaker / CableSubscriptionPool\"})\n\nexport default class ApiMakerCableSubscriptionPool {\n  constructor () {\n    this.activeSubscriptions = 0\n    this.connected = false\n  }\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      {\n        channel: \"ApiMaker::SubscriptionsChannel\",\n        global: globalData,\n        subscription_data: subscriptionData\n      },\n      {\n        connected: this.onConnected,\n        received: this.onReceived,\n        subscribed: this.onSubscribed\n      }\n    )\n    this.connected = true\n  }\n\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            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            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 = () => digg(this, \"connected\")\n\n  onConnected = () => {\n    this.forEachSubscription(({subscription}) => {\n      subscription.events.emit(\"connected\")\n    })\n  }\n\n  onReceived = (rawData) => {\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    logger.debug(\"onSubscribed\")\n  }\n\n  onUnsubscribe () {\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 (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            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 (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      this.onUnsubscribe(subscription)\n    })\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/cable-subscription.js

@@ -0,0 +1,21 @@
+import EventEmitter from "events";
+import Logger from "./logger";
+const logger = new Logger({
+  name: "ApiMaker / CableSubscription"
+});
+export default class ApiMakerCableSubscription {
+  constructor() {
+    this.events = new EventEmitter();
+    this.subscribed = true;
+  }
+  unsubscribe() {
+    if (!this.subscribed) {
+      logger.debug("Unsubscribed already called");
+      return;
+    }
+    logger.debug("Unsubscribe called for subscription");
+    this.subscribed = false;
+    this.events.emit("unsubscribed");
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJFdmVudEVtaXR0ZXIiLCJMb2dnZXIiLCJsb2dnZXIiLCJuYW1lIiwiQXBpTWFrZXJDYWJsZVN1YnNjcmlwdGlvbiIsImNvbnN0cnVjdG9yIiwiZXZlbnRzIiwic3Vic2NyaWJlZCIsInVuc3Vic2NyaWJlIiwiZGVidWciLCJlbWl0Il0sInNvdXJjZXMiOlsiLi4vc3JjL2NhYmxlLXN1YnNjcmlwdGlvbi5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgRXZlbnRFbWl0dGVyIGZyb20gXCJldmVudHNcIlxuaW1wb3J0IExvZ2dlciBmcm9tIFwiLi9sb2dnZXJcIlxuXG5jb25zdCBsb2dnZXIgPSBuZXcgTG9nZ2VyKHtuYW1lOiBcIkFwaU1ha2VyIC8gQ2FibGVTdWJzY3JpcHRpb25cIn0pXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyQ2FibGVTdWJzY3JpcHRpb24ge1xuICBjb25zdHJ1Y3RvciAoKSB7XG4gICAgdGhpcy5ldmVudHMgPSBuZXcgRXZlbnRFbWl0dGVyKClcbiAgICB0aGlzLnN1YnNjcmliZWQgPSB0cnVlXG4gIH1cblxuICB1bnN1YnNjcmliZSAoKSB7XG4gICAgaWYgKCF0aGlzLnN1YnNjcmliZWQpIHtcbiAgICAgIGxvZ2dlci5kZWJ1ZyhcIlVuc3Vic2NyaWJlZCBhbHJlYWR5IGNhbGxlZFwiKVxuICAgICAgcmV0dXJuXG4gICAgfVxuXG4gICAgbG9nZ2VyLmRlYnVnKFwiVW5zdWJzY3JpYmUgY2FsbGVkIGZvciBzdWJzY3JpcHRpb25cIilcblxuICAgIHRoaXMuc3Vic2NyaWJlZCA9IGZhbHNlXG4gICAgdGhpcy5ldmVudHMuZW1pdChcInVuc3Vic2NyaWJlZFwiKVxuICB9XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLFlBQVksTUFBTSxRQUFRO0FBQ2pDLE9BQU9DLE1BQU0sTUFBTSxVQUFVO0FBRTdCLE1BQU1DLE1BQU0sR0FBRyxJQUFJRCxNQUFNLENBQUM7RUFBQ0UsSUFBSSxFQUFFO0FBQThCLENBQUMsQ0FBQztBQUVqRSxlQUFlLE1BQU1DLHlCQUF5QixDQUFDO0VBQzdDQyxXQUFXQSxDQUFBLEVBQUk7SUFDYixJQUFJLENBQUNDLE1BQU0sR0FBRyxJQUFJTixZQUFZLENBQUMsQ0FBQztJQUNoQyxJQUFJLENBQUNPLFVBQVUsR0FBRyxJQUFJO0VBQ3hCO0VBRUFDLFdBQVdBLENBQUEsRUFBSTtJQUNiLElBQUksQ0FBQyxJQUFJLENBQUNELFVBQVUsRUFBRTtNQUNwQkwsTUFBTSxDQUFDTyxLQUFLLENBQUMsNkJBQTZCLENBQUM7TUFDM0M7SUFDRjtJQUVBUCxNQUFNLENBQUNPLEtBQUssQ0FBQyxxQ0FBcUMsQ0FBQztJQUVuRCxJQUFJLENBQUNGLFVBQVUsR0FBRyxLQUFLO0lBQ3ZCLElBQUksQ0FBQ0QsTUFBTSxDQUFDSSxJQUFJLENBQUMsY0FBYyxDQUFDO0VBQ2xDO0FBQ0YiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/cache-key-generator.js

@@ -0,0 +1,81 @@
+import SparkMD5 from "spark-md5";
+export default class CacheKeyGenerator {
+  constructor(model) {
+    this.model = model;
+    this.allModels = [model];
+    this.readModels = {};
+    this.recordModelType(model.modelClassData().name);
+    this.recordModel(model.modelClassData().name, model);
+    this.filledModels = false;
+  }
+  local() {
+    const md5 = new SparkMD5();
+    this.feedModel(this.model, md5);
+    return md5.end();
+  }
+  recordModelType(relationshipType) {
+    if (!(relationshipType in this.readModels)) {
+      this.readModels[relationshipType] = {};
+    }
+  }
+  recordModel(relationshipType, model) {
+    this.allModels.push(model);
+    this.readModels[relationshipType][model.id() || model.uniqueKey()] = true;
+  }
+  isModelRecorded(relationshipType, model) {
+    if (model.id() in this.readModels[relationshipType]) {
+      return true;
+    }
+  }
+  fillModels(model) {
+    for (const relationshipType in model.relationships) {
+      this.recordModelType(relationshipType);
+      const loadedRelationship = model.relationships[relationshipType];
+      if (Array.isArray(loadedRelationship)) {
+        // has_many
+        for (const anotherModel of loadedRelationship) {
+          if (this.isModelRecorded(relationshipType, anotherModel)) {
+            continue;
+          }
+          this.recordModel(relationshipType, anotherModel);
+          this.fillModels(anotherModel);
+        }
+      } else if (loadedRelationship) {
+        // belongs_to, has_one
+        if (this.isModelRecorded(relationshipType, loadedRelationship)) {
+          continue;
+        }
+        this.recordModel(relationshipType, loadedRelationship);
+        this.fillModels(loadedRelationship);
+      }
+    }
+    this.filledModels = true;
+  }
+  cacheKey() {
+    if (!this.filledModels) {
+      this.fillModels(this.model);
+    }
+    const md5 = new SparkMD5();
+    for (const model of this.allModels) {
+      this.feedModel(model, md5);
+    }
+    return md5.end();
+  }
+  feedModel(model, md5) {
+    md5.append("--model--");
+    md5.append(model.modelClassData().name);
+    md5.append("--unique-key--");
+    md5.append(model.id() || model.uniqueKey());
+    if (model.markedForDestruction()) {
+      md5.append("--marked-for-destruction--");
+    }
+    md5.append("-attributes-");
+    const attributes = model.attributes();
+    for (const attributeName in attributes) {
+      md5.append(attributeName);
+      md5.append("--attribute--");
+      md5.append(`${model.readAttributeUnderscore(attributeName)}`);
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/can-can.js

@@ -0,0 +1,134 @@
+import { digg } from "diggerize";
+import EventEmitter from "events";
+import * as inflection from "inflection";
+import { ReadersWriterLock } from "epic-locks";
+import Services from "./services";
+const shared = {};
+export default class ApiMakerCanCan {
+  abilities = [];
+  abilitiesToLoad = [];
+  abilitiesToLoadData = [];
+  events = new EventEmitter();
+  lock = new ReadersWriterLock();
+  static current() {
+    if (!shared.currentApiMakerCanCan) shared.currentApiMakerCanCan = new ApiMakerCanCan();
+    return shared.currentApiMakerCanCan;
+  }
+  can(ability, subject) {
+    let abilityToUse = inflection.underscore(ability);
+    const foundAbility = this.findAbility(abilityToUse, subject);
+    if (foundAbility === undefined) {
+      let subjectLabel = subject;
+
+      // Translate resource-models into class name strings
+      if (typeof subject == "function" && subject.modelClassData) {
+        subjectLabel = digg(subject.modelClassData(), "name");
+      }
+      console.error(`Ability not loaded ${subjectLabel}#${abilityToUse}`, {
+        abilities: this.abilities,
+        ability,
+        subject
+      });
+      return false;
+    } else {
+      return digg(foundAbility, "can");
+    }
+  }
+  findAbility(ability, subject) {
+    return this.abilities.find(abilityData => {
+      const abilityDataSubject = digg(abilityData, "subject");
+      const abilityDataAbility = digg(abilityData, "ability");
+      if (abilityDataAbility == ability) {
+        // If actually same class
+        if (abilityDataSubject == subject) return true;
+
+        // Sometimes in dev when using linking it will actually be two different but identical resource classes
+        if (typeof subject == "function" && subject.modelClassData && typeof abilityDataSubject == "function" && abilityDataSubject.modelClassData && digg(subject.modelClassData(), "name") == digg(abilityDataSubject.modelClassData(), "name")) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  isAbilityLoaded(ability, subject) {
+    const foundAbility = this.findAbility(ability, subject);
+    if (foundAbility !== undefined) {
+      return true;
+    }
+    return false;
+  }
+  async loadAbilities(abilities) {
+    await this.lock.read(async () => {
+      const promises = [];
+      for (const abilityData of abilities) {
+        const subject = abilityData[0];
+        if (!subject) throw new Error(`Invalid subject given in abilities: ${subject} - ${JSON.stringify(abilities)}`);
+        if (!Array.isArray(abilityData[1])) throw new Error(`Expected an array of abilities but got: ${typeof abilityData[1]}: ${abilityData[1]}`);
+        for (const ability of abilityData[1]) {
+          const promise = this.loadAbility(ability, subject);
+          promises.push(promise);
+        }
+      }
+      await Promise.all(promises);
+    });
+  }
+  loadAbility(ability, subject) {
+    return new Promise(resolve => {
+      ability = inflection.underscore(ability);
+      if (this.isAbilityLoaded(ability, subject)) {
+        resolve();
+        return;
+      }
+      const foundAbility = this.abilitiesToLoad.find(abilityToLoad => digg(abilityToLoad, "ability") == ability && digg(abilityToLoad, "subject") == subject);
+      if (foundAbility) {
+        foundAbility.callbacks.push(resolve);
+      } else {
+        this.abilitiesToLoad.push({
+          ability,
+          callbacks: [resolve],
+          subject
+        });
+        this.abilitiesToLoadData.push({
+          ability,
+          subject
+        });
+        this.queueAbilitiesRequest();
+      }
+    });
+  }
+  queueAbilitiesRequest() {
+    if (this.queueAbilitiesRequestTimeout) {
+      clearTimeout(this.queueAbilitiesRequestTimeout);
+    }
+    this.queueAbilitiesRequestTimeout = setTimeout(this.sendAbilitiesRequest, 0);
+  }
+  async resetAbilities() {
+    await this.lock.write(() => {
+      this.abilities = [];
+    });
+    this.events.emit("onResetAbilities");
+  }
+  sendAbilitiesRequest = async () => {
+    const abilitiesToLoad = this.abilitiesToLoad;
+    const abilitiesToLoadData = this.abilitiesToLoadData;
+    this.abilitiesToLoad = [];
+    this.abilitiesToLoadData = [];
+
+    // Load abilities from backend
+    const result = await Services.current().sendRequest("CanCan::LoadAbilities", {
+      request: abilitiesToLoadData
+    });
+    const abilities = digg(result, "abilities");
+
+    // Set the loaded abilities
+    this.abilities = this.abilities.concat(abilities);
+
+    // Call the callbacks that are waiting for the ability to have been loaded
+    for (const abilityData of abilitiesToLoad) {
+      for (const callback of abilityData.callbacks) {
+        callback();
+      }
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digg","EventEmitter","inflection","ReadersWriterLock","Services","shared","ApiMakerCanCan","abilities","abilitiesToLoad","abilitiesToLoadData","events","lock","current","currentApiMakerCanCan","can","ability","subject","abilityToUse","underscore","foundAbility","findAbility","undefined","subjectLabel","modelClassData","console","error","find","abilityData","abilityDataSubject","abilityDataAbility","isAbilityLoaded","loadAbilities","read","promises","Error","JSON","stringify","Array","isArray","promise","loadAbility","push","Promise","all","resolve","abilityToLoad","callbacks","queueAbilitiesRequest","queueAbilitiesRequestTimeout","clearTimeout","setTimeout","sendAbilitiesRequest","resetAbilities","write","emit","result","sendRequest","request","concat","callback"],"sources":["../src/can-can.js"],"sourcesContent":["import {digg} from \"diggerize\"\nimport EventEmitter from \"events\"\nimport * as inflection from \"inflection\"\nimport {ReadersWriterLock} from \"epic-locks\"\nimport Services from \"./services\"\n\nconst shared = {}\n\nexport default class ApiMakerCanCan {\n  abilities = []\n  abilitiesToLoad = []\n  abilitiesToLoadData = []\n  events = new EventEmitter()\n  lock = new ReadersWriterLock()\n\n  static current () {\n    if (!shared.currentApiMakerCanCan) shared.currentApiMakerCanCan = new ApiMakerCanCan()\n\n    return shared.currentApiMakerCanCan\n  }\n\n  can (ability, subject) {\n    let abilityToUse = inflection.underscore(ability)\n    const foundAbility = this.findAbility(abilityToUse, subject)\n\n    if (foundAbility === undefined) {\n      let subjectLabel = subject\n\n      // Translate resource-models into class name strings\n      if (typeof subject == \"function\" && subject.modelClassData) {\n        subjectLabel = digg(subject.modelClassData(), \"name\")\n      }\n\n      console.error(`Ability not loaded ${subjectLabel}#${abilityToUse}`, {abilities: this.abilities, ability, subject})\n\n      return false\n    } else {\n      return digg(foundAbility, \"can\")\n    }\n  }\n\n  findAbility (ability, subject) {\n    return this.abilities.find((abilityData) => {\n      const abilityDataSubject = digg(abilityData, \"subject\")\n      const abilityDataAbility = digg(abilityData, \"ability\")\n\n      if (abilityDataAbility == ability) {\n        // If actually same class\n        if (abilityDataSubject == subject) return true\n\n        // Sometimes in dev when using linking it will actually be two different but identical resource classes\n        if (\n          typeof subject == \"function\" &&\n          subject.modelClassData &&\n          typeof abilityDataSubject == \"function\" &&\n          abilityDataSubject.modelClassData &&\n          digg(subject.modelClassData(), \"name\") == digg(abilityDataSubject.modelClassData(), \"name\")\n        ) {\n          return true\n        }\n      }\n\n      return false\n    })\n  }\n\n  isAbilityLoaded (ability, subject) {\n    const foundAbility = this.findAbility(ability, subject)\n\n    if (foundAbility !== undefined) {\n      return true\n    }\n\n    return false\n  }\n\n  async loadAbilities (abilities) {\n    await this.lock.read(async () => {\n      const promises = []\n\n      for (const abilityData of abilities) {\n        const subject = abilityData[0]\n\n        if (!subject) throw new Error(`Invalid subject given in abilities: ${subject} - ${JSON.stringify(abilities)}`)\n        if (!Array.isArray(abilityData[1])) throw new Error(`Expected an array of abilities but got: ${typeof abilityData[1]}: ${abilityData[1]}`)\n\n        for (const ability of abilityData[1]) {\n          const promise = this.loadAbility(ability, subject)\n\n          promises.push(promise)\n        }\n      }\n\n      await Promise.all(promises)\n    })\n  }\n\n  loadAbility (ability, subject) {\n    return new Promise((resolve) => {\n      ability = inflection.underscore(ability)\n\n      if (this.isAbilityLoaded(ability, subject)) {\n        resolve()\n        return\n      }\n\n      const foundAbility = this.abilitiesToLoad.find((abilityToLoad) => digg(abilityToLoad, \"ability\") == ability && digg(abilityToLoad, \"subject\") == subject)\n\n      if (foundAbility) {\n        foundAbility.callbacks.push(resolve)\n      } else {\n        this.abilitiesToLoad.push({ability, callbacks: [resolve], subject})\n        this.abilitiesToLoadData.push({ability, subject})\n\n        this.queueAbilitiesRequest()\n      }\n    })\n  }\n\n  queueAbilitiesRequest () {\n    if (this.queueAbilitiesRequestTimeout) {\n      clearTimeout(this.queueAbilitiesRequestTimeout)\n    }\n\n    this.queueAbilitiesRequestTimeout = setTimeout(this.sendAbilitiesRequest, 0)\n  }\n\n  async resetAbilities () {\n    await this.lock.write(() => {\n      this.abilities = []\n    })\n    this.events.emit(\"onResetAbilities\")\n  }\n\n  sendAbilitiesRequest = async () => {\n    const abilitiesToLoad = this.abilitiesToLoad\n    const abilitiesToLoadData = this.abilitiesToLoadData\n\n    this.abilitiesToLoad = []\n    this.abilitiesToLoadData = []\n\n    // Load abilities from backend\n    const result = await Services.current().sendRequest(\"CanCan::LoadAbilities\", {\n      request: abilitiesToLoadData\n    })\n    const abilities = digg(result, \"abilities\")\n\n    // Set the loaded abilities\n    this.abilities = this.abilities.concat(abilities)\n\n    // Call the callbacks that are waiting for the ability to have been loaded\n    for (const abilityData of abilitiesToLoad) {\n      for (const callback of abilityData.callbacks) {\n        callback()\n      }\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/channels-consumer.js

@@ -0,0 +1,9 @@
+import Config from "./config";
+import { createConsumer } from "@rails/actioncable";
+export default () => {
+  if (!globalThis.apiMakerChannelsConsumer) {
+    globalThis.apiMakerChannelsConsumer = createConsumer(Config.getCableUrl());
+  }
+  return globalThis.apiMakerChannelsConsumer;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDb25maWciLCJjcmVhdGVDb25zdW1lciIsImdsb2JhbFRoaXMiLCJhcGlNYWtlckNoYW5uZWxzQ29uc3VtZXIiLCJnZXRDYWJsZVVybCJdLCJzb3VyY2VzIjpbIi4uL3NyYy9jaGFubmVscy1jb25zdW1lci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgQ29uZmlnIGZyb20gXCIuL2NvbmZpZ1wiXG5pbXBvcnQge2NyZWF0ZUNvbnN1bWVyfSBmcm9tIFwiQHJhaWxzL2FjdGlvbmNhYmxlXCJcblxuZXhwb3J0IGRlZmF1bHQgKCkgPT4ge1xuICBpZiAoIWdsb2JhbFRoaXMuYXBpTWFrZXJDaGFubmVsc0NvbnN1bWVyKSB7XG4gICAgZ2xvYmFsVGhpcy5hcGlNYWtlckNoYW5uZWxzQ29uc3VtZXIgPSBjcmVhdGVDb25zdW1lcihDb25maWcuZ2V0Q2FibGVVcmwoKSlcbiAgfVxuXG4gIHJldHVybiBnbG9iYWxUaGlzLmFwaU1ha2VyQ2hhbm5lbHNDb25zdW1lclxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxNQUFNLE1BQU0sVUFBVTtBQUM3QixTQUFRQyxjQUFjLFFBQU8sb0JBQW9CO0FBRWpELGVBQWUsTUFBTTtFQUNuQixJQUFJLENBQUNDLFVBQVUsQ0FBQ0Msd0JBQXdCLEVBQUU7SUFDeENELFVBQVUsQ0FBQ0Msd0JBQXdCLEdBQUdGLGNBQWMsQ0FBQ0QsTUFBTSxDQUFDSSxXQUFXLENBQUMsQ0FBQyxDQUFDO0VBQzVFO0VBRUEsT0FBT0YsVUFBVSxDQUFDQyx3QkFBd0I7QUFDNUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/build/collection-loader.js

@@ -0,0 +1,48 @@
+import Collection from "./collection";
+import { digg } from "diggerize";
+import memo from "set-state-compare/src/memo";
+import { useMemo } from "react";
+import PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import useCollection from "./use-collection";
+import useShape from "set-state-compare/src/use-shape";
+const CollectionLoader = ({
+  component,
+  ...restProps
+}) => {
+  const s = useShape(restProps);
+  const useCollectionResult = useCollection(restProps);
+  const cachePartsKeys = ["modelIdsCacheString", "overallCount", "qParams", "queryName", "queryPerKey", "queryQName", "querySName", "queryPageName", "searchParams", "showNoRecordsAvailableContent", "showNoRecordsFoundContent"];
+  const cacheParts = [];
+  for (const cachePartsKey of cachePartsKeys) {
+    cacheParts.push(digg(useCollectionResult, cachePartsKey));
+  }
+  s.updateMeta({
+    component,
+    useCollectionResult
+  });
+  useMemo(() => {
+    s.m.component.setState(s.m.useCollectionResult);
+  }, cacheParts);
+  return null;
+};
+CollectionLoader.propTypes = PropTypesExact({
+  abilities: PropTypes.object,
+  collection: PropTypes.instanceOf(Collection),
+  component: PropTypes.object.isRequired,
+  defaultParams: PropTypes.object,
+  groupBy: PropTypes.array,
+  modelClass: PropTypes.func.isRequired,
+  noRecordsAvailableContent: PropTypes.func,
+  noRecordsFoundContent: PropTypes.func,
+  onModelsLoaded: PropTypes.func,
+  pagination: PropTypes.bool,
+  preloads: PropTypes.array,
+  queryMethod: PropTypes.func,
+  queryName: PropTypes.string,
+  ransack: PropTypes.object,
+  select: PropTypes.object,
+  selectColumns: PropTypes.object
+});
+export default memo(CollectionLoader);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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