@kaspernj/api-maker 1.0.2011 → 1.0.2012

package/build/bootstrap/radio-buttons.js

@@ -0,0 +1,72 @@
+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 { digs } from "diggerize";
+import inputWrapper from "../inputs/input-wrapper";
+import InvalidFeedback from "./invalid-feedback";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+class ApiMakerBootstrapRadioButtons extends React.PureComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.string,
+    collection: PropTypes.array.isRequired,
+    defaultValue: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+    id: PropTypes.string,
+    inputProps: PropTypes.object.isRequired,
+    name: PropTypes.string,
+    model: PropTypes.object,
+    onChange: PropTypes.func,
+    onMatchValidationError: PropTypes.func,
+    wrapperClassName: PropTypes.string,
+    wrapperOpts: PropTypes.object.isRequired
+  });
+  render() {
+    return /*#__PURE__*/React.createElement("div", {
+      className: this.wrapperClassName()
+    }, /*#__PURE__*/React.createElement("input", _extends({}, this.props.inputProps, {
+      type: "hidden",
+      value: ""
+    })), this.props.collection.map((option, index) => this.optionElement(option, index)));
+  }
+  inputRadioClassName() {
+    const classNames = ["form-check-input"];
+    if (this.props.wrapperOpts.errors.length > 0) classNames.push("is-invalid");
+    return classNames.join(" ");
+  }
+  generatedId() {
+    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  }
+  optionElement(option, index) {
+    const {
+      collection
+    } = digs(this.props, "collection");
+    const {
+      onChange
+    } = this.props;
+    const id = this.generatedId();
+    return /*#__PURE__*/React.createElement("div", {
+      className: "form-check",
+      key: `option-${option[1]}`
+    }, /*#__PURE__*/React.createElement("input", {
+      className: this.inputRadioClassName(),
+      "data-option-value": option[1],
+      defaultChecked: option[1] == this.props.inputProps.defaultValue,
+      id: id,
+      name: this.props.inputProps.name,
+      onChange: onChange,
+      type: "radio",
+      value: option[1]
+    }), /*#__PURE__*/React.createElement("label", {
+      className: "form-check-label",
+      htmlFor: id
+    }, option[0]), index + 1 == collection.length && this.props.wrapperOpts.errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: this.props.wrapperOpts.errors
+    }));
+  }
+  wrapperClassName() {
+    const classNames = ["component-bootstrap-radio-buttons"];
+    if (this.props.wrapperClassName) classNames.push(this.props.wrapperClassName);
+    return classNames.join(" ");
+  }
+}
+export default inputWrapper(ApiMakerBootstrapRadioButtons);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digs","inputWrapper","InvalidFeedback","PropTypes","propTypesExact","React","ApiMakerBootstrapRadioButtons","PureComponent","propTypes","attribute","string","collection","array","isRequired","defaultValue","oneOfType","number","id","inputProps","object","name","model","onChange","func","onMatchValidationError","wrapperClassName","wrapperOpts","render","createElement","className","_extends","props","type","value","map","option","index","optionElement","inputRadioClassName","classNames","errors","length","push","join","generatedId","Math","random","toString","substring","key","defaultChecked","htmlFor"],"sources":["../../src/bootstrap/radio-buttons.jsx"],"sourcesContent":["import {digs} from \"diggerize\"\nimport inputWrapper from \"../inputs/input-wrapper\"\nimport InvalidFeedback from \"./invalid-feedback\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport React from \"react\"\n\nclass ApiMakerBootstrapRadioButtons extends React.PureComponent {\n  static propTypes = propTypesExact({\n    attribute: PropTypes.string,\n    collection: PropTypes.array.isRequired,\n    defaultValue: PropTypes.oneOfType([\n      PropTypes.number,\n      PropTypes.string\n    ]),\n    id: PropTypes.string,\n    inputProps: PropTypes.object.isRequired,\n    name: PropTypes.string,\n    model: PropTypes.object,\n    onChange: PropTypes.func,\n    onMatchValidationError: PropTypes.func,\n    wrapperClassName: PropTypes.string,\n    wrapperOpts: PropTypes.object.isRequired\n  })\n\n  render () {\n    return (\n      <div className={this.wrapperClassName()}>\n        <input {...this.props.inputProps} type=\"hidden\" value=\"\" />\n        {this.props.collection.map((option, index) => this.optionElement(option, index))}\n      </div>\n    )\n  }\n\n  inputRadioClassName () {\n    const classNames = [\"form-check-input\"]\n\n    if (this.props.wrapperOpts.errors.length > 0)\n      classNames.push(\"is-invalid\")\n\n    return classNames.join(\" \")\n  }\n\n  generatedId () {\n    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15)\n  }\n\n  optionElement (option, index) {\n    const {collection} = digs(this.props, \"collection\")\n    const {onChange} = this.props\n    const id = this.generatedId()\n\n    return (\n      <div className=\"form-check\" key={`option-${option[1]}`}>\n        <input\n          className={this.inputRadioClassName()}\n          data-option-value={option[1]}\n          defaultChecked={option[1] == this.props.inputProps.defaultValue}\n          id={id}\n          name={this.props.inputProps.name}\n          onChange={onChange}\n          type=\"radio\"\n          value={option[1]}\n        />\n\n        <label className=\"form-check-label\" htmlFor={id}>\n          {option[0]}\n        </label>\n\n        {(index + 1) == collection.length && this.props.wrapperOpts.errors.length > 0 &&\n          <InvalidFeedback errors={this.props.wrapperOpts.errors} />\n        }\n      </div>\n    )\n  }\n\n  wrapperClassName () {\n    const classNames = [\"component-bootstrap-radio-buttons\"]\n\n    if (this.props.wrapperClassName)\n      classNames.push(this.props.wrapperClassName)\n\n    return classNames.join(\" \")\n  }\n}\n\nexport default inputWrapper(ApiMakerBootstrapRadioButtons)\n"],"mappings":"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","ignoreList":[]}

package/build/bootstrap/select.js

@@ -0,0 +1,88 @@
+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 { digs } from "diggerize";
+import inputWrapper from "../inputs/input-wrapper";
+import { Select } from "../inputs/select";
+import InvalidFeedback from "./invalid-feedback";
+import PropTypes from "prop-types";
+import React from "react";
+class ApiMakerBootstrapSelect extends React.PureComponent {
+  static propTypes = {
+    attribute: PropTypes.string,
+    className: PropTypes.string,
+    description: PropTypes.node,
+    id: PropTypes.string,
+    hint: PropTypes.node,
+    hintBottom: PropTypes.node,
+    inputProps: PropTypes.object.isRequired,
+    label: PropTypes.node,
+    labelContainerClassName: PropTypes.string,
+    model: PropTypes.object,
+    wrapperClassName: PropTypes.string,
+    wrapperOpts: PropTypes.object.isRequired
+  };
+  render() {
+    const {
+      children,
+      className,
+      description,
+      id,
+      inputProps,
+      hint,
+      hintBottom,
+      label,
+      labelContainerClassName,
+      name,
+      wrapperClassName,
+      wrapperOpts,
+      ...restProps
+    } = this.props;
+    const {
+      ref,
+      ...forwardedInputProps
+    } = inputProps;
+    const {
+      errors
+    } = digs(wrapperOpts, "errors");
+    return /*#__PURE__*/React.createElement("div", {
+      className: this.wrapperClassName()
+    }, wrapperOpts.label && /*#__PURE__*/React.createElement("div", {
+      className: labelContainerClassName ? labelContainerClassName : null
+    }, /*#__PURE__*/React.createElement("label", {
+      className: this.labelClassName(),
+      htmlFor: inputProps.id
+    }, wrapperOpts.label)), description && /*#__PURE__*/React.createElement("div", {
+      className: "mb-4"
+    }, description), hint && /*#__PURE__*/React.createElement("span", {
+      className: "font-smoothing font-xs form-text text-muted"
+    }, hint), children, !children && /*#__PURE__*/React.createElement(Select, _extends({}, forwardedInputProps, {
+      className: this.selectClassName(),
+      inputProps: inputProps,
+      inputRef: ref,
+      wrapperOpts: wrapperOpts
+    }, restProps)), hintBottom && /*#__PURE__*/React.createElement("span", {
+      className: "form-text text-muted font-smoothing font-xs"
+    }, hintBottom), errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: errors
+    }));
+  }
+  labelClassName() {
+    const classNames = ["form-group-label"];
+    if (this.props.labelClassName) classNames.push(this.props.labelClassName);
+    return classNames.join(" ");
+  }
+  selectClassName() {
+    const classNames = ["form-control"];
+    if (this.props.className) classNames.push(this.props.className);
+    if (this.props.wrapperOpts.errors.length > 0) classNames.push("is-invalid");
+    return classNames.join(" ");
+  }
+  wrapperClassName() {
+    const classNames = ["form-group", "component-bootstrap-select"];
+    if (this.props.wrapperClassName) classNames.push(this.props.wrapperClassName);
+    return classNames.join(" ");
+  }
+}
+export default inputWrapper(ApiMakerBootstrapSelect, {
+  type: "select"
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digs","inputWrapper","Select","InvalidFeedback","PropTypes","React","ApiMakerBootstrapSelect","PureComponent","propTypes","attribute","string","className","description","node","id","hint","hintBottom","inputProps","object","isRequired","label","labelContainerClassName","model","wrapperClassName","wrapperOpts","render","children","name","restProps","props","ref","forwardedInputProps","errors","createElement","labelClassName","htmlFor","_extends","selectClassName","inputRef","length","classNames","push","join","type"],"sources":["../../src/bootstrap/select.jsx"],"sourcesContent":["import {digs} from \"diggerize\"\nimport inputWrapper from \"../inputs/input-wrapper\"\nimport {Select} from \"../inputs/select\"\nimport InvalidFeedback from \"./invalid-feedback\"\nimport PropTypes from \"prop-types\"\nimport React from \"react\"\n\nclass ApiMakerBootstrapSelect extends React.PureComponent {\n  static propTypes = {\n    attribute: PropTypes.string,\n    className: PropTypes.string,\n    description: PropTypes.node,\n    id: PropTypes.string,\n    hint: PropTypes.node,\n    hintBottom: PropTypes.node,\n    inputProps: PropTypes.object.isRequired,\n    label: PropTypes.node,\n    labelContainerClassName: PropTypes.string,\n    model: PropTypes.object,\n    wrapperClassName: PropTypes.string,\n    wrapperOpts: PropTypes.object.isRequired\n  }\n\n  render () {\n    const {\n      children,\n      className,\n      description,\n      id,\n      inputProps,\n      hint,\n      hintBottom,\n      label,\n      labelContainerClassName,\n      name,\n      wrapperClassName,\n      wrapperOpts,\n      ...restProps\n    } = this.props\n    const {ref, ...forwardedInputProps} = inputProps\n    const {errors} = digs(wrapperOpts, \"errors\")\n\n    return (\n      <div className={this.wrapperClassName()}>\n        {wrapperOpts.label &&\n          <div className={labelContainerClassName ? labelContainerClassName : null}>\n            <label className={this.labelClassName()} htmlFor={inputProps.id}>\n              {wrapperOpts.label}\n            </label>\n          </div>\n        }\n        {description &&\n          <div className=\"mb-4\">\n            {description}\n          </div>\n        }\n        {hint &&\n          <span className=\"font-smoothing font-xs form-text text-muted\">\n            {hint}\n          </span>\n        }\n        {children}\n        {!children &&\n          <Select\n            {...forwardedInputProps}\n            className={this.selectClassName()}\n            inputProps={inputProps}\n            inputRef={ref}\n            wrapperOpts={wrapperOpts}\n            {...restProps}\n          />\n        }\n        {hintBottom &&\n          <span className=\"form-text text-muted font-smoothing font-xs\">\n            {hintBottom}\n          </span>\n        }\n        {errors.length > 0 && <InvalidFeedback errors={errors} />}\n      </div>\n    )\n  }\n\n  labelClassName () {\n    const classNames = [\"form-group-label\"]\n\n    if (this.props.labelClassName)\n      classNames.push(this.props.labelClassName)\n\n    return classNames.join(\" \")\n  }\n\n  selectClassName () {\n    const classNames = [\"form-control\"]\n\n    if (this.props.className) classNames.push(this.props.className)\n    if (this.props.wrapperOpts.errors.length > 0) classNames.push(\"is-invalid\")\n\n    return classNames.join(\" \")\n  }\n\n  wrapperClassName () {\n    const classNames = [\"form-group\", \"component-bootstrap-select\"]\n\n    if (this.props.wrapperClassName) classNames.push(this.props.wrapperClassName)\n\n    return classNames.join(\" \")\n  }\n}\n\nexport default inputWrapper(ApiMakerBootstrapSelect, {type: \"select\"})\n"],"mappings":"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","ignoreList":[]}

package/build/bootstrap/sort-link.js

@@ -0,0 +1,131 @@
+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 Icon from "../utils/icon";
+import PropTypes from "prop-types";
+import qs from "qs";
+import memo from "set-state-compare/src/memo";
+import React from "react";
+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/build/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(Icon, {
+      name: "chevron-down",
+      size: 14,
+      style: {
+        marginLeft: 3
+      }
+    }), isSortedByAttribute && sortMode == "desc" && /*#__PURE__*/React.createElement(Icon, {
+      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","Icon","PropTypes","qs","memo","React","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","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 Icon from \"../utils/icon\"\nimport PropTypes from \"prop-types\"\nimport qs from \"qs\"\nimport memo from \"set-state-compare/src/memo\"\nimport React from \"react\"\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/build/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          <Icon name=\"chevron-down\" size={14} style={{marginLeft: 3}} />\n        }\n        {isSortedByAttribute && sortMode == \"desc\" &&\n          <Icon 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":[]}