@kaspernj/api-maker 1.0.445 → 1.0.447

package/build/bootstrap/sort-link.js

@@ -0,0 +1,130 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import BaseComponent from "../base-component";
+import * as inflection from "inflection";
+import FontAwesomeIcon from "react-native-vector-icons/FontAwesome";
+import PropTypes from "prop-types";
+import qs from "qs";
+import memo from "set-state-compare/src/memo";
+import Text from "../utils/text";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import urlEncode from "../url-encode";
+import useSorting from "../table/use-sorting";
+import Link from "../link";
+import useQueryParams from "on-location-changed/src/use-query-params";
+export default memo(shapeComponent(class ApiMakerBootstrapSortLink extends BaseComponent {
+  static propTypes = {
+    attribute: PropTypes.string.isRequired,
+    className: PropTypes.string,
+    defaultParams: PropTypes.object,
+    linkComponent: PropTypes.object,
+    onChanged: PropTypes.func,
+    query: PropTypes.object.isRequired,
+    title: PropTypes.node
+  };
+  setup() {
+    const {
+      attribute,
+      defaultParams,
+      query
+    } = this.props;
+    const {
+      qParams,
+      searchKey,
+      sortAttribute,
+      sortMode
+    } = useSorting({
+      defaultParams,
+      query
+    });
+    this.setInstance({
+      isSortedByAttribute: sortAttribute == attribute,
+      qParams,
+      searchKey,
+      sortMode
+    });
+    this.queryParams = useQueryParams();
+    this.searchKey = this.p.query.queryArgs.searchKey || "q";
+    this.attribute = inflection.underscore(this.p.attribute);
+  }
+  href() {
+    const qParams = Object.assign({}, this.tt.qParams);
+    const {
+      attribute,
+      queryParams,
+      searchKey,
+      sortMode
+    } = this.tt;
+    const newQueryParams = {
+      ...queryParams
+    };
+    qParams.s = `${attribute} ${sortMode == "asc" ? "desc" : "asc"}`; // eslint-disable-line id-length
+
+    newQueryParams[searchKey] = JSON.stringify(qParams);
+    const newParams = qs.stringify(newQueryParams, {
+      encoder: urlEncode
+    });
+    const newPath = `${location.pathname}?${newParams}`;
+    return newPath;
+  }
+  render() {
+    const {
+      isSortedByAttribute,
+      sortMode
+    } = this.tt;
+    const LinkComponent = this.linkComponent();
+    const {
+      attribute,
+      className,
+      dataSet,
+      defaultParams,
+      linkComponent,
+      onChanged,
+      query,
+      style,
+      textProps,
+      title,
+      ...restProps
+    } = this.props;
+    const actualDataSet = Object.assign({
+      attribute,
+      class: className,
+      component: "api-maker/bootstrap/sort-link",
+      sortMode: this.tt.sortMode
+    }, dataSet);
+    const actualStyle = Object.assign({
+      display: "flex",
+      flexDirection: "row",
+      alignItems: "center"
+    }, style);
+    return /*#__PURE__*/React.createElement(LinkComponent, _extends({
+      dataSet: actualDataSet,
+      style: actualStyle,
+      to: this.href()
+    }, restProps), /*#__PURE__*/React.createElement(Text, textProps, this.title()), isSortedByAttribute && sortMode == "asc" && /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+      name: "chevron-down",
+      size: 14,
+      style: {
+        marginLeft: 3
+      }
+    }), isSortedByAttribute && sortMode == "desc" && /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+      name: "chevron-up",
+      size: 14,
+      style: {
+        marginLeft: 3
+      }
+    }));
+  }
+  linkComponent = () => this.props.linkComponent || Link;
+  title() {
+    const {
+      attribute,
+      query
+    } = this.p;
+    const {
+      title
+    } = this.props;
+    if (title) return title;
+    return query.modelClass().humanAttributeName(attribute);
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","inflection","FontAwesomeIcon","PropTypes","qs","memo","Text","shapeComponent","urlEncode","useSorting","Link","useQueryParams","ApiMakerBootstrapSortLink","propTypes","attribute","string","isRequired","className","defaultParams","object","linkComponent","onChanged","func","query","title","node","setup","props","qParams","searchKey","sortAttribute","sortMode","setInstance","isSortedByAttribute","queryParams","p","queryArgs","underscore","href","Object","assign","tt","newQueryParams","s","JSON","stringify","newParams","encoder","newPath","location","pathname","render","LinkComponent","dataSet","style","textProps","restProps","actualDataSet","class","component","actualStyle","display","flexDirection","alignItems","React","createElement","_extends","to","name","size","marginLeft","modelClass","humanAttributeName"],"sources":["../../src/bootstrap/sort-link.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport * as inflection from \"inflection\"\nimport FontAwesomeIcon from \"react-native-vector-icons/FontAwesome\"\nimport PropTypes from \"prop-types\"\nimport qs from \"qs\"\nimport memo from \"set-state-compare/src/memo\"\nimport Text from \"../utils/text\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport urlEncode from \"../url-encode\"\nimport useSorting from \"../table/use-sorting\"\n\nimport Link from \"../link\"\nimport useQueryParams from \"on-location-changed/src/use-query-params\"\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.node\n  }\n\n  setup() {\n    const {attribute, defaultParams, query} = this.props\n    const {qParams, searchKey, sortAttribute, sortMode} = useSorting({defaultParams, query})\n\n    this.setInstance({\n      isSortedByAttribute: sortAttribute == attribute,\n      qParams,\n      searchKey,\n      sortMode\n    })\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 = Object.assign({}, this.tt.qParams)\n    const {attribute, queryParams, searchKey, sortMode} = this.tt\n    const newQueryParams = {...queryParams}\n\n    qParams.s = `${attribute} ${sortMode == \"asc\" ? \"desc\" : \"asc\"}` // eslint-disable-line id-length\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 = Object.assign(\n      {\n        attribute,\n        class: className,\n        component: \"api-maker/bootstrap/sort-link\",\n        sortMode: this.tt.sortMode\n      },\n      dataSet\n    )\n    const actualStyle = Object.assign(\n      {display: \"flex\", flexDirection: \"row\", 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          <FontAwesomeIcon name=\"chevron-down\" size={14} style={{marginLeft: 3}} />\n        }\n        {isSortedByAttribute && sortMode == \"desc\" &&\n          <FontAwesomeIcon name=\"chevron-up\" size={14} style={{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"],"mappings":"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","ignoreList":[]}

package/build/cable-connection-pool.js

@@ -0,0 +1,128 @@
+import CableSubscriptionPool from "./cable-subscription-pool";
+import CableSubscription from "./cable-subscription";
+import { dig } from "diggerize";
+import RunLast from "./run-last";
+const shared = {};
+export default class ApiMakerCableConnectionPool {
+  cableSubscriptionPools = [];
+  connections = {};
+  upcomingSubscriptionData = {};
+  upcomingSubscriptions = {};
+  static current() {
+    if (!shared.apiMakerCableConnectionPool) shared.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool();
+    return shared.apiMakerCableConnectionPool;
+  }
+  connectEventToExistingSubscription({
+    path,
+    subscription,
+    value
+  }) {
+    for (const cableSubscriptionPool of this.cableSubscriptionPools) {
+      if (!cableSubscriptionPool.isConnected()) {
+        continue;
+      }
+      let existingSubscriptions;
+      if (value === true) {
+        existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path);
+      } else {
+        existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path, value);
+      }
+      if (existingSubscriptions !== undefined) {
+        if (!Array.isArray(existingSubscriptions)) {
+          throw new Error(`existingSubscriptions wasn't an array: ${typeof existingSubscriptions} (${dig(existingSubscriptions, "constructor", "name")})`);
+        }
+        existingSubscriptions.push(subscription);
+        cableSubscriptionPool.connectUnsubscriptionForSubscription(subscription);
+        return true;
+      }
+    }
+    return false;
+  }
+  connectModelEvent({
+    callback,
+    path,
+    value
+  }) {
+    const subscription = new CableSubscription();
+    subscription.events.addListener("received", callback);
+    if (this.connectEventToExistingSubscription({
+      path,
+      subscription,
+      value
+    })) {
+      // Managed to connect to existing connection
+      return subscription;
+    }
+    let currentSubscriptionData = this.upcomingSubscriptionData;
+    let currentSubscription = this.upcomingSubscriptions;
+    for (let i = 0; i < path.length; i++) {
+      const pathPart = path[i];
+      if (!(pathPart in currentSubscriptionData)) {
+        if (i == path.length - 1) {
+          currentSubscriptionData[pathPart] = [];
+        } else {
+          currentSubscriptionData[pathPart] = {};
+        }
+      }
+      currentSubscriptionData = currentSubscriptionData[pathPart];
+      if (!(pathPart in currentSubscription)) {
+        if (value === true && i == path.length - 1) {
+          currentSubscription[pathPart] = [];
+        } else {
+          currentSubscription[pathPart] = {};
+        }
+      }
+      currentSubscription = currentSubscription[pathPart];
+    }
+    if (!currentSubscriptionData.includes(value)) {
+      currentSubscriptionData.push(value);
+    }
+    if (value === true) {
+      currentSubscription.push(subscription);
+    } else {
+      if (!(value in currentSubscription)) {
+        currentSubscription[value] = [];
+      }
+      currentSubscription[value].push(subscription);
+    }
+    this.scheduleConnectUpcomingRunLast.queue();
+    return subscription;
+  }
+  connectCreated = (modelName, callback) => this.connectModelEvent({
+    callback,
+    value: true,
+    path: [modelName, "creates"]
+  });
+  connectEvent = (modelName, modelId, eventName, callback) => this.connectModelEvent({
+    callback,
+    value: modelId,
+    path: [modelName, "events", eventName]
+  });
+  connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({
+    callback,
+    value: modelId,
+    path: [modelName, "destroys"]
+  });
+  connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({
+    callback,
+    value: eventName,
+    path: [modelName, "model_class_events"]
+  });
+  connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({
+    callback,
+    value: modelId,
+    path: [modelName, "updates"]
+  });
+  connectUpcoming = () => {
+    const subscriptionData = this.upcomingSubscriptionData;
+    const subscriptions = this.upcomingSubscriptions;
+    this.upcomingSubscriptionData = {};
+    this.upcomingSubscriptions = {};
+    const cableSubscriptionPool = new CableSubscriptionPool();
+    cableSubscriptionPool.registerSubscriptions(subscriptions);
+    cableSubscriptionPool.connect(subscriptionData);
+    this.cableSubscriptionPools.push(cableSubscriptionPool);
+  };
+  scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CableSubscriptionPool","CableSubscription","dig","RunLast","shared","ApiMakerCableConnectionPool","cableSubscriptionPools","connections","upcomingSubscriptionData","upcomingSubscriptions","current","apiMakerCableConnectionPool","connectEventToExistingSubscription","path","subscription","value","cableSubscriptionPool","isConnected","existingSubscriptions","subscriptions","undefined","Array","isArray","Error","push","connectUnsubscriptionForSubscription","connectModelEvent","callback","events","addListener","currentSubscriptionData","currentSubscription","i","length","pathPart","includes","scheduleConnectUpcomingRunLast","queue","connectCreated","modelName","connectEvent","modelId","eventName","connectDestroyed","connectModelClassEvent","connectUpdate","connectUpcoming","subscriptionData","registerSubscriptions","connect"],"sources":["../src/cable-connection-pool.js"],"sourcesContent":["import CableSubscriptionPool from \"./cable-subscription-pool\"\nimport CableSubscription from \"./cable-subscription\"\nimport {dig} from \"diggerize\"\nimport RunLast from \"./run-last\"\n\nconst shared = {}\n\nexport default class ApiMakerCableConnectionPool {\n  cableSubscriptionPools = []\n  connections = {}\n  upcomingSubscriptionData = {}\n  upcomingSubscriptions = {}\n\n  static current () {\n    if (!shared.apiMakerCableConnectionPool) shared.apiMakerCableConnectionPool = new ApiMakerCableConnectionPool()\n\n    return shared.apiMakerCableConnectionPool\n  }\n\n  connectEventToExistingSubscription ({path, subscription, value}) {\n    for (const cableSubscriptionPool of this.cableSubscriptionPools) {\n      if (!cableSubscriptionPool.isConnected()) {\n        continue\n      }\n\n      let existingSubscriptions\n\n      if (value === true) {\n        existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path)\n      } else {\n        existingSubscriptions = dig(cableSubscriptionPool.subscriptions, ...path, value)\n      }\n\n      if (existingSubscriptions !== undefined) {\n        if (!Array.isArray(existingSubscriptions)) {\n          throw new Error(`existingSubscriptions wasn't an array: ${typeof existingSubscriptions} (${dig(existingSubscriptions, \"constructor\", \"name\")})`)\n        }\n\n        existingSubscriptions.push(subscription)\n        cableSubscriptionPool.connectUnsubscriptionForSubscription(subscription)\n\n        return true\n      }\n    }\n\n    return false\n  }\n\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 = (modelName, callback) => this.connectModelEvent({callback, value: true, path: [modelName, \"creates\"]})\n  connectEvent = (modelName, modelId, eventName, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"events\", eventName]})\n  connectDestroyed = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"destroys\"]})\n  connectModelClassEvent = (modelName, eventName, callback) => this.connectModelEvent({callback, value: eventName, path: [modelName, \"model_class_events\"]})\n  connectUpdate = (modelName, modelId, callback) => this.connectModelEvent({callback, value: modelId, path: [modelName, \"updates\"]})\n\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  scheduleConnectUpcomingRunLast = new RunLast(this.connectUpcoming)\n}\n"],"mappings":"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","ignoreList":[]}

package/build/cable-subscription-pool.js

@@ -0,0 +1,207 @@
+import ChannelsConsumer 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 = ChannelsConsumer.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":["ChannelsConsumer","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 ChannelsConsumer 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 = ChannelsConsumer.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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