@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/collection.js

@@ -0,0 +1,280 @@
+import cloneDeep from "clone-deep";
+import CommandsPool from "./commands-pool";
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import { incorporate } from "incorporator";
+import modelClassRequire from "./model-class-require";
+import Result from "./result";
+import uniqunize from "uniqunize";
+export default class ApiMakerCollection {
+  static apiMakerType = "Collection";
+  constructor(args, queryArgs = {}) {
+    this.queryArgs = queryArgs;
+    this.args = args;
+  }
+  abilities(originalAbilities) {
+    const newAbilities = {};
+    for (const originalAbilityName in originalAbilities) {
+      const newModelName = inflection.underscore(originalAbilityName);
+      const newValues = [];
+      const originalValues = originalAbilities[originalAbilityName];
+      for (const originalAbilityName of originalValues) {
+        const newAbilityName = inflection.underscore(originalAbilityName);
+        newValues.push(newAbilityName);
+      }
+      newAbilities[newModelName] = newValues;
+    }
+    return this._merge({
+      abilities: newAbilities
+    });
+  }
+  accessibleBy(abilityName) {
+    return this._merge({
+      accessibleBy: inflection.underscore(abilityName)
+    });
+  }
+  async count() {
+    const response = await this.clone()._merge({
+      count: true
+    })._response();
+    return digg(response, "count");
+  }
+  distinct() {
+    return this._merge({
+      distinct: true
+    });
+  }
+  async each(callback) {
+    const array = await this.toArray();
+    for (const model in array) {
+      callback.call(model);
+    }
+  }
+  except(...keys) {
+    for (const key of keys) {
+      if (key == "page") {
+        delete this.queryArgs[key];
+      } else {
+        throw new Error(`Unhandled key: ${key}`);
+      }
+    }
+    return this;
+  }
+  async first() {
+    const models = await this.toArray();
+    return models[0];
+  }
+  groupBy(...arrayOfTablesAndColumns) {
+    const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map(tableAndColumn => {
+      if (Array.isArray(tableAndColumn)) {
+        return [tableAndColumn[0], tableAndColumn[1].toLowerCase()];
+      } else {
+        return tableAndColumn.toLowerCase();
+      }
+    });
+    const currentGroupBy = this.queryArgs.groupBy || [];
+    const newGroupBy = currentGroupBy.concat(arrayOfTablesAndColumnsWithLowercaseColumns);
+    return this._merge({
+      groupBy: newGroupBy
+    });
+  }
+  isLoaded() {
+    if (this.args.reflectionName in this.args.model.relationshipsCache) return true;
+    return false;
+  }
+  limit(amount) {
+    return this._merge({
+      limit: amount
+    });
+  }
+  preloaded() {
+    if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {
+      throw new Error(`${this.args.reflectionName} hasnt been loaded yet`);
+    }
+    return this.args.model.relationshipsCache[this.args.reflectionName];
+  }
+  loaded() {
+    const {
+      model,
+      reflectionName
+    } = this.args;
+    if (reflectionName in model.relationships) {
+      return model.relationships[reflectionName];
+    } else if (reflectionName in model.relationshipsCache) {
+      return model.relationshipsCache[reflectionName];
+    } else if (model.isNewRecord()) {
+      const reflectionNameUnderscore = inflection.underscore(reflectionName);
+
+      // Initialize as empty and try again to return the empty result
+      this.set([]);
+      return digg(model.relationships, reflectionNameUnderscore);
+    } else {
+      const relationshipsLoaded = uniqunize(Object.keys(model.relationships).concat(Object.keys(model.relationshipsCache)));
+      throw new Error(`${reflectionName} hasnt been loaded yet on ${model.modelClassData().name}. Loaded was: ${relationshipsLoaded.join(", ")}`);
+    }
+  }
+
+  // Replaces the relationships with the given new collection.
+  set(newCollection) {
+    this.args.model.relationships[this.args.reflectionName] = newCollection;
+  }
+
+  // Pushes another model onto the given collection.
+  push(newModel) {
+    if (!(this.args.reflectionName in this.args.model.relationships)) {
+      this.args.model.relationships[this.args.reflectionName] = [];
+    }
+    this.args.model.relationships[this.args.reflectionName].push(newModel);
+  }
+
+  // Array shortcuts
+  find = (...args) => this.loaded().find(...args);
+  forEach = (...args) => this.loaded().forEach(...args);
+  map = (...args) => this.loaded().map(...args);
+  preload(preloadValue) {
+    return this._merge({
+      preload: preloadValue
+    });
+  }
+  page(page) {
+    if (!page) page = 1;
+    return this._merge({
+      page
+    });
+  }
+  pageKey(pageKey) {
+    return this._merge({
+      pageKey
+    });
+  }
+  params() {
+    let params = {};
+    if (this.queryArgs.params) params = incorporate(params, this.queryArgs.params);
+    if (this.queryArgs.abilities) params.abilities = this.queryArgs.abilities;
+    if (this.queryArgs.accessibleBy) params.accessible_by = inflection.underscore(this.queryArgs.accessibleBy);
+    if (this.queryArgs.count) params.count = this.queryArgs.count;
+    if (this.queryArgs.distinct) params.distinct = this.queryArgs.distinct;
+    if (this.queryArgs.groupBy) params.group_by = this.queryArgs.groupBy;
+    if (this.queryArgs.ransack) params.q = this.queryArgs.ransack;
+    if (this.queryArgs.limit) params.limit = this.queryArgs.limit;
+    if (this.queryArgs.preload) params.preload = this.queryArgs.preload;
+    if (this.queryArgs.page) params.page = this.queryArgs.page;
+    if (this.queryArgs.per) params.per = this.queryArgs.per;
+    if (this.queryArgs.search) params.search = this.queryArgs.search;
+    if (this.queryArgs.select) params.select = this.queryArgs.select;
+    if (this.queryArgs.selectColumns) params.select_columns = this.queryArgs.selectColumns;
+    return params;
+  }
+  per(per) {
+    return this._merge({
+      per
+    });
+  }
+  perKey(perKey) {
+    return this._merge({
+      perKey
+    });
+  }
+  ransack(params) {
+    if (params) this._merge({
+      ransack: params
+    });
+    return this;
+  }
+  async result() {
+    const response = await this._response();
+    const models = digg(response, "collection");
+    this._addQueryToModels(models);
+    const result = new Result({
+      collection: this,
+      models,
+      response
+    });
+    return result;
+  }
+  search(params) {
+    if (params) this._merge({
+      search: params
+    });
+    return this;
+  }
+  searchKey(searchKey) {
+    return this._merge({
+      searchKey
+    });
+  }
+  select(originalSelect) {
+    const newSelect = {};
+    for (const originalModelName in originalSelect) {
+      const newModelName = inflection.underscore(originalModelName);
+      const newValues = [];
+      const originalValues = originalSelect[originalModelName];
+      for (const originalAttributeName of originalValues) {
+        const newAttributeName = inflection.underscore(originalAttributeName);
+        newValues.push(newAttributeName);
+      }
+      newSelect[newModelName] = newValues;
+    }
+    return this._merge({
+      select: newSelect
+    });
+  }
+  selectColumns(originalSelect) {
+    const newSelect = {};
+    for (const originalModelName in originalSelect) {
+      const newModelName = inflection.underscore(inflection.underscore(originalModelName));
+      const newValues = [];
+      const originalValues = originalSelect[originalModelName];
+      for (const originalAttributeName of originalValues) {
+        const newAttributeName = inflection.underscore(originalAttributeName);
+        newValues.push(newAttributeName);
+      }
+      newSelect[newModelName] = newValues;
+    }
+    return this._merge({
+      selectColumns: newSelect
+    });
+  }
+  sort(sortBy) {
+    return this._merge({
+      ransack: {
+        s: sortBy
+      }
+    });
+  }
+  async toArray() {
+    const response = await this._response();
+    const models = digg(response, "collection");
+    this._addQueryToModels(models);
+    return models;
+  }
+  modelClass() {
+    const modelName = digg(this.args.modelClass.modelClassData(), "name");
+    return modelClassRequire(modelName);
+  }
+  clone() {
+    const clonedQueryArgs = cloneDeep(this.queryArgs);
+    return new ApiMakerCollection(this.args, clonedQueryArgs);
+  }
+
+  // This is needed when reloading a version of the model with the same selected attributes and preloads
+  _addQueryToModels(models) {
+    for (const model of models) {
+      model.collection = this;
+    }
+  }
+  _merge(newQueryArgs) {
+    incorporate(this.queryArgs, newQueryArgs);
+    return this;
+  }
+  _response() {
+    const modelClassData = this.args.modelClass.modelClassData();
+    return CommandsPool.addCommand({
+      args: this.params(),
+      command: `${modelClassData.collectionName}-index`,
+      collectionName: modelClassData.collectionName,
+      type: "index"
+    }, {});
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["cloneDeep","CommandsPool","digg","inflection","incorporate","modelClassRequire","Result","uniqunize","ApiMakerCollection","apiMakerType","constructor","args","queryArgs","abilities","originalAbilities","newAbilities","originalAbilityName","newModelName","underscore","newValues","originalValues","newAbilityName","push","_merge","accessibleBy","abilityName","count","response","clone","_response","distinct","each","callback","array","toArray","model","call","except","keys","key","Error","first","models","groupBy","arrayOfTablesAndColumns","arrayOfTablesAndColumnsWithLowercaseColumns","map","tableAndColumn","Array","isArray","toLowerCase","currentGroupBy","newGroupBy","concat","isLoaded","reflectionName","relationshipsCache","limit","amount","preloaded","loaded","relationships","isNewRecord","reflectionNameUnderscore","set","relationshipsLoaded","Object","modelClassData","name","join","newCollection","newModel","find","forEach","preload","preloadValue","page","pageKey","params","accessible_by","group_by","ransack","q","per","search","select","selectColumns","select_columns","perKey","result","_addQueryToModels","collection","searchKey","originalSelect","newSelect","originalModelName","originalAttributeName","newAttributeName","sort","sortBy","s","modelClass","modelName","clonedQueryArgs","newQueryArgs","addCommand","command","collectionName","type"],"sources":["../src/collection.js"],"sourcesContent":["import cloneDeep from \"clone-deep\"\nimport CommandsPool from \"./commands-pool\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport {incorporate} from \"incorporator\"\nimport modelClassRequire from \"./model-class-require\"\nimport Result from \"./result\"\nimport uniqunize from \"uniqunize\"\n\nexport default class ApiMakerCollection {\n  static apiMakerType = \"Collection\"\n\n  constructor(args, queryArgs = {}) {\n    this.queryArgs = queryArgs\n    this.args = args\n  }\n\n  abilities(originalAbilities) {\n    const newAbilities = {}\n\n    for (const originalAbilityName in originalAbilities) {\n      const newModelName = inflection.underscore(originalAbilityName)\n      const newValues = []\n      const originalValues = originalAbilities[originalAbilityName]\n\n      for (const originalAbilityName of originalValues) {\n        const newAbilityName = inflection.underscore(originalAbilityName)\n        newValues.push(newAbilityName)\n      }\n\n      newAbilities[newModelName] = newValues\n    }\n\n    return this._merge({abilities: newAbilities})\n  }\n\n  accessibleBy(abilityName) {\n    return this._merge({accessibleBy: inflection.underscore(abilityName)})\n  }\n\n  async count() {\n    const response = await this.clone()._merge({count: true})._response()\n\n    return digg(response, \"count\")\n  }\n\n  distinct() {\n    return this._merge({distinct: true})\n  }\n\n  async each(callback) {\n    const array = await this.toArray()\n\n    for (const model in array) {\n      callback.call(model)\n    }\n  }\n\n  except(...keys) {\n    for (const key of keys) {\n      if (key == \"page\") {\n        delete this.queryArgs[key]\n      } else {\n        throw new Error(`Unhandled key: ${key}`)\n      }\n    }\n\n    return this\n  }\n\n  async first() {\n    const models = await this.toArray()\n    return models[0]\n  }\n\n  groupBy(...arrayOfTablesAndColumns) {\n    const arrayOfTablesAndColumnsWithLowercaseColumns = arrayOfTablesAndColumns.map((tableAndColumn) => {\n      if (Array.isArray(tableAndColumn)) {\n        return [tableAndColumn[0], tableAndColumn[1].toLowerCase()]\n      } else {\n        return tableAndColumn.toLowerCase()\n      }\n    })\n    const currentGroupBy = this.queryArgs.groupBy || []\n    const newGroupBy = currentGroupBy.concat(arrayOfTablesAndColumnsWithLowercaseColumns)\n\n    return this._merge({\n      groupBy: newGroupBy\n    })\n  }\n\n  isLoaded() {\n    if (this.args.reflectionName in this.args.model.relationshipsCache)\n      return true\n\n    return false\n  }\n\n  limit(amount) {\n    return this._merge({limit: amount})\n  }\n\n  preloaded() {\n    if (!(this.args.reflectionName in this.args.model.relationshipsCache)) {\n      throw new Error(`${this.args.reflectionName} hasnt been loaded yet`)\n    }\n\n    return this.args.model.relationshipsCache[this.args.reflectionName]\n  }\n\n  loaded() {\n    const {model, reflectionName} = this.args\n\n    if (reflectionName in model.relationships) {\n      return model.relationships[reflectionName]\n    } else if (reflectionName in model.relationshipsCache) {\n      return model.relationshipsCache[reflectionName]\n    } else if (model.isNewRecord()) {\n      const reflectionNameUnderscore = inflection.underscore(reflectionName)\n\n      // Initialize as empty and try again to return the empty result\n      this.set([])\n\n      return digg(model.relationships, reflectionNameUnderscore)\n    } else {\n      const relationshipsLoaded = uniqunize(Object.keys(model.relationships).concat(Object.keys(model.relationshipsCache)))\n\n      throw new Error(`${reflectionName} hasnt been loaded yet on ${model.modelClassData().name}. Loaded was: ${relationshipsLoaded.join(\", \")}`)\n    }\n  }\n\n  // Replaces the relationships with the given new collection.\n  set(newCollection) {\n    this.args.model.relationships[this.args.reflectionName] = newCollection\n  }\n\n  // Pushes another model onto the given collection.\n  push(newModel) {\n    if (!(this.args.reflectionName in this.args.model.relationships)) {\n      this.args.model.relationships[this.args.reflectionName] = []\n    }\n\n    this.args.model.relationships[this.args.reflectionName].push(newModel)\n  }\n\n  // Array shortcuts\n  find = (...args) => this.loaded().find(...args)\n  forEach = (...args) => this.loaded().forEach(...args)\n  map = (...args) => this.loaded().map(...args)\n\n  preload(preloadValue) {\n    return this._merge({preload: preloadValue})\n  }\n\n  page(page) {\n    if (!page)\n      page = 1\n\n    return this._merge({page})\n  }\n\n  pageKey(pageKey) {\n    return this._merge({pageKey})\n  }\n\n  params() {\n    let params = {}\n\n    if (this.queryArgs.params) params = incorporate(params, this.queryArgs.params)\n    if (this.queryArgs.abilities) params.abilities = this.queryArgs.abilities\n    if (this.queryArgs.accessibleBy) params.accessible_by = inflection.underscore(this.queryArgs.accessibleBy)\n    if (this.queryArgs.count) params.count = this.queryArgs.count\n    if (this.queryArgs.distinct) params.distinct = this.queryArgs.distinct\n    if (this.queryArgs.groupBy) params.group_by = this.queryArgs.groupBy\n    if (this.queryArgs.ransack) params.q = this.queryArgs.ransack\n    if (this.queryArgs.limit) params.limit = this.queryArgs.limit\n    if (this.queryArgs.preload) params.preload = this.queryArgs.preload\n    if (this.queryArgs.page) params.page = this.queryArgs.page\n    if (this.queryArgs.per) params.per = this.queryArgs.per\n    if (this.queryArgs.search) params.search = this.queryArgs.search\n    if (this.queryArgs.select) params.select = this.queryArgs.select\n    if (this.queryArgs.selectColumns) params.select_columns = this.queryArgs.selectColumns\n\n    return params\n  }\n\n  per(per) {\n    return this._merge({per})\n  }\n\n  perKey(perKey) {\n    return this._merge({perKey})\n  }\n\n  ransack(params) {\n    if (params) this._merge({ransack: params})\n    return this\n  }\n\n  async result() {\n    const response = await this._response()\n    const models = digg(response, \"collection\")\n\n    this._addQueryToModels(models)\n\n    const result = new Result({collection: this, models, response})\n\n    return result\n  }\n\n  search(params) {\n    if (params) this._merge({search: params})\n    return this\n  }\n\n  searchKey(searchKey) {\n    return this._merge({searchKey})\n  }\n\n  select(originalSelect) {\n    const newSelect = {}\n\n    for (const originalModelName in originalSelect) {\n      const newModelName = inflection.underscore(originalModelName)\n      const newValues = []\n      const originalValues = originalSelect[originalModelName]\n\n      for (const originalAttributeName of originalValues) {\n        const newAttributeName = inflection.underscore(originalAttributeName)\n        newValues.push(newAttributeName)\n      }\n\n      newSelect[newModelName] = newValues\n    }\n\n    return this._merge({select: newSelect})\n  }\n\n  selectColumns(originalSelect) {\n    const newSelect = {}\n\n    for (const originalModelName in originalSelect) {\n      const newModelName = inflection.underscore(inflection.underscore(originalModelName))\n      const newValues = []\n      const originalValues = originalSelect[originalModelName]\n\n      for (const originalAttributeName of originalValues) {\n        const newAttributeName = inflection.underscore(originalAttributeName)\n        newValues.push(newAttributeName)\n      }\n\n      newSelect[newModelName] = newValues\n    }\n\n    return this._merge({selectColumns: newSelect})\n  }\n\n  sort(sortBy) {\n    return this._merge({ransack: {s: sortBy}})\n  }\n\n  async toArray() {\n    const response = await this._response()\n    const models = digg(response, \"collection\")\n\n    this._addQueryToModels(models)\n\n    return models\n  }\n\n  modelClass() {\n    const modelName = digg(this.args.modelClass.modelClassData(), \"name\")\n\n    return modelClassRequire(modelName)\n  }\n\n  clone() {\n    const clonedQueryArgs = cloneDeep(this.queryArgs)\n\n    return new ApiMakerCollection(this.args, clonedQueryArgs)\n  }\n\n  // This is needed when reloading a version of the model with the same selected attributes and preloads\n  _addQueryToModels(models) {\n    for(const model of models) {\n      model.collection = this\n    }\n  }\n\n  _merge(newQueryArgs) {\n    incorporate(this.queryArgs, newQueryArgs)\n\n    return this\n  }\n\n  _response() {\n    const modelClassData = this.args.modelClass.modelClassData()\n\n    return CommandsPool.addCommand(\n      {\n        args: this.params(),\n        command: `${modelClassData.collectionName}-index`,\n        collectionName: modelClassData.collectionName,\n        type: \"index\"\n      },\n      {}\n    )\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/command-submit-data.js

@@ -0,0 +1,81 @@
+import objectToFormData from "object-to-formdata";
+export default class ApiMakerCommandSubmitData {
+  constructor(data) {
+    this.data = data;
+    this.filesCount = 0;
+    this.jsonData = this.traverseObject(this.data, "json");
+  }
+  getFilesCount = () => this.filesCount;
+  getJsonData = () => this.jsonData;
+  getRawData() {
+    if (!this.rawData) {
+      this.rawData = this.traverseObject(this.data, "raw");
+    }
+    return this.rawData;
+  }
+  getFormData() {
+    const objectForFormData = this.getRawData() || {};
+    objectForFormData.json = JSON.stringify(this.getJsonData());
+    const formData = objectToFormData.serialize(objectForFormData);
+    return formData;
+  }
+  convertDynamic(value, type) {
+    if (Array.isArray(value)) {
+      return this.traverseArray(value, type);
+    } else if (typeof value == "object" && value !== null && value.constructor.name == "Object") {
+      return this.traverseObject(value, type);
+    } else {
+      return value;
+    }
+  }
+  shouldSkip(object, type) {
+    if (type == "json" && object instanceof File) {
+      this.filesCount += 1;
+      return true;
+    }
+    if (type == "raw" && !Array.isArray(object) && !this.isObject(object) && !(object instanceof File)) {
+      return true;
+    }
+    return false;
+  }
+  isObject(value) {
+    if (typeof value == "object" && value !== null && value.constructor.name == "Object") {
+      return true;
+    }
+    return false;
+  }
+  traverseArray(array, type) {
+    const newArray = [];
+    for (const value of array) {
+      if (this.shouldSkip(value, type)) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        newArray.push(this.convertDynamic(value, type));
+      } else if (this.isObject(value)) {
+        newArray.push(this.convertDynamic(value, type));
+      } else {
+        newArray.push(value);
+      }
+    }
+    return newArray;
+  }
+  traverseObject(object, type) {
+    const newObject = {};
+    for (const key in object) {
+      const value = object[key];
+      if (this.shouldSkip(value, type)) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        newObject[key] = this.convertDynamic(value, type);
+      } else if (this.isObject(value)) {
+        newObject[key] = this.convertDynamic(value, type);
+      } else {
+        newObject[key] = value;
+      }
+    }
+    return newObject;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/commands-pool.js

@@ -0,0 +1,195 @@
+import Api from "./api";
+import CommandSubmitData from "./command-submit-data";
+import CustomError from "./custom-error";
+import DestroyError from "./destroy-error";
+import Deserializer from "./deserializer";
+import { dig, digg } from "diggerize";
+import events from "./events";
+import FormDataObjectizer from "form-data-objectizer";
+import RunLast from "./run-last";
+import Serializer from "./serializer";
+import SessionStatusUpdater from "./session-status-updater";
+import ValidationError from "./validation-error";
+import { ValidationErrors } from "./validation-errors";
+const shared = {};
+export default class ApiMakerCommandsPool {
+  static addCommand(data, args = {}) {
+    let pool;
+    if (args.instant) {
+      pool = new ApiMakerCommandsPool();
+    } else {
+      pool = ApiMakerCommandsPool.current();
+    }
+    const promiseResult = pool.addCommand(data);
+    if (args.instant) {
+      pool.flushRunLast.run();
+    } else {
+      pool.flushRunLast.queue();
+    }
+    return promiseResult;
+  }
+  static current() {
+    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool();
+    return shared.currentApiMakerCommandsPool;
+  }
+  static flush() {
+    ApiMakerCommandsPool.current().flush();
+  }
+  constructor() {
+    this.flushCount = 0;
+    this.pool = {};
+    this.poolData = {};
+    this.currentId = 1;
+    this.globalRequestData = {};
+  }
+  addCommand(data) {
+    const stack = Error().stack;
+    return new Promise((resolve, reject) => {
+      const id = this.currentId;
+      this.currentId += 1;
+      const commandType = data.type;
+      const commandName = data.command;
+      const collectionName = data.collectionName;
+      this.pool[id] = {
+        resolve,
+        reject,
+        stack
+      };
+      if (!this.poolData[commandType]) this.poolData[commandType] = {};
+      if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {};
+      if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {};
+      let args;
+      if (data.args?.nodeName == "FORM") {
+        const formData = new FormData(data.args);
+        args = FormDataObjectizer.toObject(formData);
+      } else if (data.args instanceof FormData) {
+        args = FormDataObjectizer.toObject(data.args);
+      } else {
+        args = Serializer.serialize(data.args);
+      }
+      this.poolData[commandType][collectionName][commandName][id] = {
+        args,
+        primary_key: data.primaryKey,
+        id
+      };
+    });
+  }
+  commandsCount() {
+    return Object.keys(this.pool);
+  }
+  async sendRequest({
+    commandSubmitData,
+    url
+  }) {
+    let response;
+    for (let i = 0; i < 3; i++) {
+      if (commandSubmitData.getFilesCount() > 0) {
+        response = await Api.requestLocal({
+          path: url,
+          method: "POST",
+          rawData: commandSubmitData.getFormData()
+        });
+      } else {
+        response = await Api.requestLocal({
+          path: url,
+          method: "POST",
+          data: commandSubmitData.getJsonData()
+        });
+      }
+      if (response.success === false && response.type == "invalid_authenticity_token") {
+        console.log("Invalid authenticity token - try again");
+        await SessionStatusUpdater.current().updateSessionStatus();
+        continue;
+      }
+      return response;
+    }
+    throw new Error("Couldnt successfully execute request");
+  }
+  flush = async () => {
+    if (this.commandsCount() == 0) {
+      return;
+    }
+    const currentPool = this.pool;
+    const currentPoolData = this.poolData;
+    this.pool = {};
+    this.poolData = {};
+    this.flushCount++;
+    try {
+      const submitData = {
+        pool: currentPoolData
+      };
+      if (Object.keys(this.globalRequestData).length > 0) submitData.global = this.globalRequestData;
+      const commandSubmitData = new CommandSubmitData(submitData);
+      const url = "/api_maker/commands";
+      const response = await this.sendRequest({
+        commandSubmitData,
+        url
+      });
+      for (const commandId in response.responses) {
+        const commandResponse = response.responses[commandId];
+        const commandResponseData = Deserializer.parse(commandResponse.data);
+        const commandData = currentPool[parseInt(commandId, 10)];
+        const responseType = commandResponse.type;
+        if (commandResponseData && typeof commandResponseData == "object") {
+          const bugReportUrl = dig(commandResponseData, "bug_report_url");
+          if (bugReportUrl) {
+            console.log(`Bug report URL: ${bugReportUrl}`);
+          }
+        }
+        if (responseType == "success") {
+          commandData.resolve(commandResponseData);
+        } else if (responseType == "error") {
+          const error = new CustomError("Command error", {
+            response: commandResponseData
+          });
+          error.stack += "\n";
+          error.stack += commandData.stack.split("\n").slice(1).join("\n");
+          commandData.reject(error);
+        } else if (responseType == "failed") {
+          this.handleFailedResponse(commandData, commandResponseData);
+        } else {
+          throw new Error(`Unhandled response type: ${responseType}`);
+        }
+      }
+    } finally {
+      this.flushCount--;
+    }
+  };
+  handleFailedResponse(commandData, commandResponseData) {
+    let error;
+    if (commandResponseData.error_type == "destroy_error") {
+      error = new DestroyError(`Destroy failed`, {
+        response: commandResponseData
+      });
+    } else if (commandResponseData.error_type == "validation_error") {
+      const validationErrors = new ValidationErrors({
+        model: digg(commandResponseData, "model"),
+        validationErrors: digg(commandResponseData, "validation_errors")
+      });
+      error = new ValidationError(validationErrors, {
+        response: commandResponseData
+      });
+      events.emit("onValidationErrors", validationErrors);
+    } else {
+      let errorMessage;
+      if (!commandResponseData.errors) {
+        errorMessage = "Command failed";
+      }
+      error = new CustomError(errorMessage, {
+        response: commandResponseData
+      });
+    }
+    commandData.reject(error);
+  }
+  isActive() {
+    if (this.commandsCount() > 0) {
+      return true;
+    }
+    if (this.flushCount > 0) {
+      return true;
+    }
+    return false;
+  }
+  flushRunLast = new RunLast(this.flush);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Api","CommandSubmitData","CustomError","DestroyError","Deserializer","dig","digg","events","FormDataObjectizer","RunLast","Serializer","SessionStatusUpdater","ValidationError","ValidationErrors","shared","ApiMakerCommandsPool","addCommand","data","args","pool","instant","current","promiseResult","flushRunLast","run","queue","currentApiMakerCommandsPool","flush","constructor","flushCount","poolData","currentId","globalRequestData","stack","Error","Promise","resolve","reject","id","commandType","type","commandName","command","collectionName","nodeName","formData","FormData","toObject","serialize","primary_key","primaryKey","commandsCount","Object","keys","sendRequest","commandSubmitData","url","response","i","getFilesCount","requestLocal","path","method","rawData","getFormData","getJsonData","success","console","log","updateSessionStatus","currentPool","currentPoolData","submitData","length","global","commandId","responses","commandResponse","commandResponseData","parse","commandData","parseInt","responseType","bugReportUrl","error","split","slice","join","handleFailedResponse","error_type","validationErrors","model","emit","errorMessage","errors","isActive"],"sources":["../src/commands-pool.js"],"sourcesContent":["import Api from \"./api\"\nimport CommandSubmitData from \"./command-submit-data\"\nimport CustomError from \"./custom-error\"\nimport DestroyError from \"./destroy-error\"\nimport Deserializer from \"./deserializer\"\nimport {dig, digg} from \"diggerize\"\nimport events from \"./events\"\nimport FormDataObjectizer from \"form-data-objectizer\"\nimport RunLast from \"./run-last\"\nimport Serializer from \"./serializer\"\nimport SessionStatusUpdater from \"./session-status-updater\"\nimport ValidationError from \"./validation-error\"\nimport {ValidationErrors} from \"./validation-errors\"\n\nconst shared = {}\n\nexport default class ApiMakerCommandsPool {\n  static addCommand(data, args = {}) {\n    let pool\n\n    if (args.instant) {\n      pool = new ApiMakerCommandsPool()\n    } else {\n      pool = ApiMakerCommandsPool.current()\n    }\n\n    const promiseResult = pool.addCommand(data)\n\n    if (args.instant) {\n      pool.flushRunLast.run()\n    } else {\n      pool.flushRunLast.queue()\n    }\n\n    return promiseResult\n  }\n\n  static current() {\n    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool()\n\n    return shared.currentApiMakerCommandsPool\n  }\n\n  static flush() {\n    ApiMakerCommandsPool.current().flush()\n  }\n\n  constructor() {\n    this.flushCount = 0\n    this.pool = {}\n    this.poolData = {}\n    this.currentId = 1\n    this.globalRequestData = {}\n  }\n\n  addCommand(data) {\n    const stack = Error().stack\n\n    return new Promise((resolve, reject) => {\n      const id = this.currentId\n      this.currentId += 1\n\n      const commandType = data.type\n      const commandName = data.command\n      const collectionName = data.collectionName\n\n      this.pool[id] = {resolve, reject, stack}\n\n      if (!this.poolData[commandType]) this.poolData[commandType] = {}\n      if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {}\n      if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {}\n\n      let args\n\n      if (data.args?.nodeName == \"FORM\") {\n        const formData = new FormData(data.args)\n\n        args = FormDataObjectizer.toObject(formData)\n      } else if (data.args instanceof FormData) {\n        args = FormDataObjectizer.toObject(data.args)\n      } else {\n        args = Serializer.serialize(data.args)\n      }\n\n      this.poolData[commandType][collectionName][commandName][id] = {\n        args,\n        primary_key: data.primaryKey,\n        id\n      }\n    })\n  }\n\n  commandsCount() {\n    return Object.keys(this.pool)\n  }\n\n  async sendRequest({commandSubmitData, url}) {\n    let response\n\n    for (let i = 0; i < 3; i++) {\n      if (commandSubmitData.getFilesCount() > 0) {\n        response = await Api.requestLocal({path: url, method: \"POST\", rawData: commandSubmitData.getFormData()})\n      } else {\n        response = await Api.requestLocal({path: url, method: \"POST\", data: commandSubmitData.getJsonData()})\n      }\n\n      if (response.success === false && response.type == \"invalid_authenticity_token\") {\n        console.log(\"Invalid authenticity token - try again\")\n        await SessionStatusUpdater.current().updateSessionStatus()\n        continue\n      }\n\n      return response\n    }\n\n    throw new Error(\"Couldnt successfully execute request\")\n  }\n\n  flush = async () => {\n    if (this.commandsCount() == 0) {\n      return\n    }\n\n    const currentPool = this.pool\n    const currentPoolData = this.poolData\n\n    this.pool = {}\n    this.poolData = {}\n    this.flushCount++\n\n    try {\n      const submitData = {pool: currentPoolData}\n\n      if (Object.keys(this.globalRequestData).length > 0)\n        submitData.global = this.globalRequestData\n\n      const commandSubmitData = new CommandSubmitData(submitData)\n      const url = \"/api_maker/commands\"\n      const response = await this.sendRequest({commandSubmitData, url})\n\n      for (const commandId in response.responses) {\n        const commandResponse = response.responses[commandId]\n        const commandResponseData = Deserializer.parse(commandResponse.data)\n        const commandData = currentPool[parseInt(commandId, 10)]\n        const responseType = commandResponse.type\n\n        if (commandResponseData && typeof commandResponseData == \"object\") {\n          const bugReportUrl = dig(commandResponseData, \"bug_report_url\")\n\n          if (bugReportUrl) {\n            console.log(`Bug report URL: ${bugReportUrl}`)\n          }\n        }\n\n        if (responseType == \"success\") {\n          commandData.resolve(commandResponseData)\n        } else if (responseType == \"error\") {\n          const error = new CustomError(\"Command error\", {response: commandResponseData})\n\n          error.stack += \"\\n\"\n          error.stack += commandData.stack.split(\"\\n\").slice(1).join(\"\\n\")\n\n          commandData.reject(error)\n        } else if (responseType == \"failed\") {\n          this.handleFailedResponse(commandData, commandResponseData)\n        } else {\n          throw new Error(`Unhandled response type: ${responseType}`)\n        }\n      }\n    } finally {\n      this.flushCount--\n    }\n  }\n\n  handleFailedResponse(commandData, commandResponseData) {\n    let error\n\n    if (commandResponseData.error_type == \"destroy_error\") {\n      error = new DestroyError(`Destroy failed`, {response: commandResponseData})\n    } else if (commandResponseData.error_type == \"validation_error\") {\n      const validationErrors = new ValidationErrors({\n        model: digg(commandResponseData, \"model\"),\n        validationErrors: digg(commandResponseData, \"validation_errors\")\n      })\n      error = new ValidationError(validationErrors, {response: commandResponseData})\n\n      events.emit(\"onValidationErrors\", validationErrors)\n    } else {\n      let errorMessage\n\n      if (!commandResponseData.errors) { errorMessage = \"Command failed\" }\n\n      error = new CustomError(errorMessage, {response: commandResponseData})\n    }\n\n    commandData.reject(error)\n  }\n\n  isActive() {\n    if (this.commandsCount() > 0) {\n      return true\n    }\n\n    if (this.flushCount > 0) {\n      return true\n    }\n\n    return false\n  }\n\n  flushRunLast = new RunLast(this.flush)\n}\n"],"mappings":"AAAA,OAAOA,GAAG,MAAM,OAAO;AACvB,OAAOC,iBAAiB,MAAM,uBAAuB;AACrD,OAAOC,WAAW,MAAM,gBAAgB;AACxC,OAAOC,YAAY,MAAM,iBAAiB;AAC1C,OAAOC,YAAY,MAAM,gBAAgB;AACzC,SAAQC,GAAG,EAAEC,IAAI,QAAO,WAAW;AACnC,OAAOC,MAAM,MAAM,UAAU;AAC7B,OAAOC,kBAAkB,MAAM,sBAAsB;AACrD,OAAOC,OAAO,MAAM,YAAY;AAChC,OAAOC,UAAU,MAAM,cAAc;AACrC,OAAOC,oBAAoB,MAAM,0BAA0B;AAC3D,OAAOC,eAAe,MAAM,oBAAoB;AAChD,SAAQC,gBAAgB,QAAO,qBAAqB;AAEpD,MAAMC,MAAM,GAAG,CAAC,CAAC;AAEjB,eAAe,MAAMC,oBAAoB,CAAC;EACxC,OAAOC,UAAUA,CAACC,IAAI,EAAEC,IAAI,GAAG,CAAC,CAAC,EAAE;IACjC,IAAIC,IAAI;IAER,IAAID,IAAI,CAACE,OAAO,EAAE;MAChBD,IAAI,GAAG,IAAIJ,oBAAoB,CAAC,CAAC;IACnC,CAAC,MAAM;MACLI,IAAI,GAAGJ,oBAAoB,CAACM,OAAO,CAAC,CAAC;IACvC;IAEA,MAAMC,aAAa,GAAGH,IAAI,CAACH,UAAU,CAACC,IAAI,CAAC;IAE3C,IAAIC,IAAI,CAACE,OAAO,EAAE;MAChBD,IAAI,CAACI,YAAY,CAACC,GAAG,CAAC,CAAC;IACzB,CAAC,MAAM;MACLL,IAAI,CAACI,YAAY,CAACE,KAAK,CAAC,CAAC;IAC3B;IAEA,OAAOH,aAAa;EACtB;EAEA,OAAOD,OAAOA,CAAA,EAAG;IACf,IAAI,CAACP,MAAM,CAACY,2BAA2B,EAAEZ,MAAM,CAACY,2BAA2B,GAAG,IAAIX,oBAAoB,CAAC,CAAC;IAExG,OAAOD,MAAM,CAACY,2BAA2B;EAC3C;EAEA,OAAOC,KAAKA,CAAA,EAAG;IACbZ,oBAAoB,CAACM,OAAO,CAAC,CAAC,CAACM,KAAK,CAAC,CAAC;EACxC;EAEAC,WAAWA,CAAA,EAAG;IACZ,IAAI,CAACC,UAAU,GAAG,CAAC;IACnB,IAAI,CAACV,IAAI,GAAG,CAAC,CAAC;IACd,IAAI,CAACW,QAAQ,GAAG,CAAC,CAAC;IAClB,IAAI,CAACC,SAAS,GAAG,CAAC;IAClB,IAAI,CAACC,iBAAiB,GAAG,CAAC,CAAC;EAC7B;EAEAhB,UAAUA,CAACC,IAAI,EAAE;IACf,MAAMgB,KAAK,GAAGC,KAAK,CAAC,CAAC,CAACD,KAAK;IAE3B,OAAO,IAAIE,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;MACtC,MAAMC,EAAE,GAAG,IAAI,CAACP,SAAS;MACzB,IAAI,CAACA,SAAS,IAAI,CAAC;MAEnB,MAAMQ,WAAW,GAAGtB,IAAI,CAACuB,IAAI;MAC7B,MAAMC,WAAW,GAAGxB,IAAI,CAACyB,OAAO;MAChC,MAAMC,cAAc,GAAG1B,IAAI,CAAC0B,cAAc;MAE1C,IAAI,CAACxB,IAAI,CAACmB,EAAE,CAAC,GAAG;QAACF,OAAO;QAAEC,MAAM;QAAEJ;MAAK,CAAC;MAExC,IAAI,CAAC,IAAI,CAACH,QAAQ,CAACS,WAAW,CAAC,EAAE,IAAI,CAACT,QAAQ,CAACS,WAAW,CAAC,GAAG,CAAC,CAAC;MAChE,IAAI,CAAC,IAAI,CAACT,QAAQ,CAACS,WAAW,CAAC,CAACI,cAAc,CAAC,EAAE,IAAI,CAACb,QAAQ,CAACS,WAAW,CAAC,CAACI,cAAc,CAAC,GAAG,CAAC,CAAC;MAChG,IAAI,CAAC,IAAI,CAACb,QAAQ,CAACS,WAAW,CAAC,CAACI,cAAc,CAAC,CAACF,WAAW,CAAC,EAAE,IAAI,CAACX,QAAQ,CAACS,WAAW,CAAC,CAACI,cAAc,CAAC,CAACF,WAAW,CAAC,GAAG,CAAC,CAAC;MAE1H,IAAIvB,IAAI;MAER,IAAID,IAAI,CAACC,IAAI,EAAE0B,QAAQ,IAAI,MAAM,EAAE;QACjC,MAAMC,QAAQ,GAAG,IAAIC,QAAQ,CAAC7B,IAAI,CAACC,IAAI,CAAC;QAExCA,IAAI,GAAGV,kBAAkB,CAACuC,QAAQ,CAACF,QAAQ,CAAC;MAC9C,CAAC,MAAM,IAAI5B,IAAI,CAACC,IAAI,YAAY4B,QAAQ,EAAE;QACxC5B,IAAI,GAAGV,kBAAkB,CAACuC,QAAQ,CAAC9B,IAAI,CAACC,IAAI,CAAC;MAC/C,CAAC,MAAM;QACLA,IAAI,GAAGR,UAAU,CAACsC,SAAS,CAAC/B,IAAI,CAACC,IAAI,CAAC;MACxC;MAEA,IAAI,CAACY,QAAQ,CAACS,WAAW,CAAC,CAACI,cAAc,CAAC,CAACF,WAAW,CAAC,CAACH,EAAE,CAAC,GAAG;QAC5DpB,IAAI;QACJ+B,WAAW,EAAEhC,IAAI,CAACiC,UAAU;QAC5BZ;MACF,CAAC;IACH,CAAC,CAAC;EACJ;EAEAa,aAAaA,CAAA,EAAG;IACd,OAAOC,MAAM,CAACC,IAAI,CAAC,IAAI,CAAClC,IAAI,CAAC;EAC/B;EAEA,MAAMmC,WAAWA,CAAC;IAACC,iBAAiB;IAAEC;EAAG,CAAC,EAAE;IAC1C,IAAIC,QAAQ;IAEZ,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;MAC1B,IAAIH,iBAAiB,CAACI,aAAa,CAAC,CAAC,GAAG,CAAC,EAAE;QACzCF,QAAQ,GAAG,MAAMzD,GAAG,CAAC4D,YAAY,CAAC;UAACC,IAAI,EAAEL,GAAG;UAAEM,MAAM,EAAE,MAAM;UAAEC,OAAO,EAAER,iBAAiB,CAACS,WAAW,CAAC;QAAC,CAAC,CAAC;MAC1G,CAAC,MAAM;QACLP,QAAQ,GAAG,MAAMzD,GAAG,CAAC4D,YAAY,CAAC;UAACC,IAAI,EAAEL,GAAG;UAAEM,MAAM,EAAE,MAAM;UAAE7C,IAAI,EAAEsC,iBAAiB,CAACU,WAAW,CAAC;QAAC,CAAC,CAAC;MACvG;MAEA,IAAIR,QAAQ,CAACS,OAAO,KAAK,KAAK,IAAIT,QAAQ,CAACjB,IAAI,IAAI,4BAA4B,EAAE;QAC/E2B,OAAO,CAACC,GAAG,CAAC,wCAAwC,CAAC;QACrD,MAAMzD,oBAAoB,CAACU,OAAO,CAAC,CAAC,CAACgD,mBAAmB,CAAC,CAAC;QAC1D;MACF;MAEA,OAAOZ,QAAQ;IACjB;IAEA,MAAM,IAAIvB,KAAK,CAAC,sCAAsC,CAAC;EACzD;EAEAP,KAAK,GAAG,MAAAA,CAAA,KAAY;IAClB,IAAI,IAAI,CAACwB,aAAa,CAAC,CAAC,IAAI,CAAC,EAAE;MAC7B;IACF;IAEA,MAAMmB,WAAW,GAAG,IAAI,CAACnD,IAAI;IAC7B,MAAMoD,eAAe,GAAG,IAAI,CAACzC,QAAQ;IAErC,IAAI,CAACX,IAAI,GAAG,CAAC,CAAC;IACd,IAAI,CAACW,QAAQ,GAAG,CAAC,CAAC;IAClB,IAAI,CAACD,UAAU,EAAE;IAEjB,IAAI;MACF,MAAM2C,UAAU,GAAG;QAACrD,IAAI,EAAEoD;MAAe,CAAC;MAE1C,IAAInB,MAAM,CAACC,IAAI,CAAC,IAAI,CAACrB,iBAAiB,CAAC,CAACyC,MAAM,GAAG,CAAC,EAChDD,UAAU,CAACE,MAAM,GAAG,IAAI,CAAC1C,iBAAiB;MAE5C,MAAMuB,iBAAiB,GAAG,IAAItD,iBAAiB,CAACuE,UAAU,CAAC;MAC3D,MAAMhB,GAAG,GAAG,qBAAqB;MACjC,MAAMC,QAAQ,GAAG,MAAM,IAAI,CAACH,WAAW,CAAC;QAACC,iBAAiB;QAAEC;MAAG,CAAC,CAAC;MAEjE,KAAK,MAAMmB,SAAS,IAAIlB,QAAQ,CAACmB,SAAS,EAAE;QAC1C,MAAMC,eAAe,GAAGpB,QAAQ,CAACmB,SAAS,CAACD,SAAS,CAAC;QACrD,MAAMG,mBAAmB,GAAG1E,YAAY,CAAC2E,KAAK,CAACF,eAAe,CAAC5D,IAAI,CAAC;QACpE,MAAM+D,WAAW,GAAGV,WAAW,CAACW,QAAQ,CAACN,SAAS,EAAE,EAAE,CAAC,CAAC;QACxD,MAAMO,YAAY,GAAGL,eAAe,CAACrC,IAAI;QAEzC,IAAIsC,mBAAmB,IAAI,OAAOA,mBAAmB,IAAI,QAAQ,EAAE;UACjE,MAAMK,YAAY,GAAG9E,GAAG,CAACyE,mBAAmB,EAAE,gBAAgB,CAAC;UAE/D,IAAIK,YAAY,EAAE;YAChBhB,OAAO,CAACC,GAAG,CAAC,mBAAmBe,YAAY,EAAE,CAAC;UAChD;QACF;QAEA,IAAID,YAAY,IAAI,SAAS,EAAE;UAC7BF,WAAW,CAAC5C,OAAO,CAAC0C,mBAAmB,CAAC;QAC1C,CAAC,MAAM,IAAII,YAAY,IAAI,OAAO,EAAE;UAClC,MAAME,KAAK,GAAG,IAAIlF,WAAW,CAAC,eAAe,EAAE;YAACuD,QAAQ,EAAEqB;UAAmB,CAAC,CAAC;UAE/EM,KAAK,CAACnD,KAAK,IAAI,IAAI;UACnBmD,KAAK,CAACnD,KAAK,IAAI+C,WAAW,CAAC/C,KAAK,CAACoD,KAAK,CAAC,IAAI,CAAC,CAACC,KAAK,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC;UAEhEP,WAAW,CAAC3C,MAAM,CAAC+C,KAAK,CAAC;QAC3B,CAAC,MAAM,IAAIF,YAAY,IAAI,QAAQ,EAAE;UACnC,IAAI,CAACM,oBAAoB,CAACR,WAAW,EAAEF,mBAAmB,CAAC;QAC7D,CAAC,MAAM;UACL,MAAM,IAAI5C,KAAK,CAAC,4BAA4BgD,YAAY,EAAE,CAAC;QAC7D;MACF;IACF,CAAC,SAAS;MACR,IAAI,CAACrD,UAAU,EAAE;IACnB;EACF,CAAC;EAED2D,oBAAoBA,CAACR,WAAW,EAAEF,mBAAmB,EAAE;IACrD,IAAIM,KAAK;IAET,IAAIN,mBAAmB,CAACW,UAAU,IAAI,eAAe,EAAE;MACrDL,KAAK,GAAG,IAAIjF,YAAY,CAAC,gBAAgB,EAAE;QAACsD,QAAQ,EAAEqB;MAAmB,CAAC,CAAC;IAC7E,CAAC,MAAM,IAAIA,mBAAmB,CAACW,UAAU,IAAI,kBAAkB,EAAE;MAC/D,MAAMC,gBAAgB,GAAG,IAAI7E,gBAAgB,CAAC;QAC5C8E,KAAK,EAAErF,IAAI,CAACwE,mBAAmB,EAAE,OAAO,CAAC;QACzCY,gBAAgB,EAAEpF,IAAI,CAACwE,mBAAmB,EAAE,mBAAmB;MACjE,CAAC,CAAC;MACFM,KAAK,GAAG,IAAIxE,eAAe,CAAC8E,gBAAgB,EAAE;QAACjC,QAAQ,EAAEqB;MAAmB,CAAC,CAAC;MAE9EvE,MAAM,CAACqF,IAAI,CAAC,oBAAoB,EAAEF,gBAAgB,CAAC;IACrD,CAAC,MAAM;MACL,IAAIG,YAAY;MAEhB,IAAI,CAACf,mBAAmB,CAACgB,MAAM,EAAE;QAAED,YAAY,GAAG,gBAAgB;MAAC;MAEnET,KAAK,GAAG,IAAIlF,WAAW,CAAC2F,YAAY,EAAE;QAACpC,QAAQ,EAAEqB;MAAmB,CAAC,CAAC;IACxE;IAEAE,WAAW,CAAC3C,MAAM,CAAC+C,KAAK,CAAC;EAC3B;EAEAW,QAAQA,CAAA,EAAG;IACT,IAAI,IAAI,CAAC5C,aAAa,CAAC,CAAC,GAAG,CAAC,EAAE;MAC5B,OAAO,IAAI;IACb;IAEA,IAAI,IAAI,CAACtB,UAAU,GAAG,CAAC,EAAE;MACvB,OAAO,IAAI;IACb;IAEA,OAAO,KAAK;EACd;EAEAN,YAAY,GAAG,IAAId,OAAO,CAAC,IAAI,CAACkB,KAAK,CAAC;AACxC","ignoreList":[]}

package/build/compose.js

@@ -0,0 +1,9 @@
+export default function apiMakerCompose(wrappedComponentClass, ...funcs) {
+  if (!wrappedComponentClass) throw new Error("No 'wrappedComponentClass' given");
+  let currentComponentClass = wrappedComponentClass;
+  for (const func of funcs) {
+    currentComponentClass = func(currentComponentClass);
+  }
+  return currentComponentClass;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcGlNYWtlckNvbXBvc2UiLCJ3cmFwcGVkQ29tcG9uZW50Q2xhc3MiLCJmdW5jcyIsIkVycm9yIiwiY3VycmVudENvbXBvbmVudENsYXNzIiwiZnVuYyJdLCJzb3VyY2VzIjpbIi4uL3NyYy9jb21wb3NlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGFwaU1ha2VyQ29tcG9zZSh3cmFwcGVkQ29tcG9uZW50Q2xhc3MsIC4uLmZ1bmNzKSB7XG4gIGlmICghd3JhcHBlZENvbXBvbmVudENsYXNzKSB0aHJvdyBuZXcgRXJyb3IoXCJObyAnd3JhcHBlZENvbXBvbmVudENsYXNzJyBnaXZlblwiKVxuXG4gIGxldCBjdXJyZW50Q29tcG9uZW50Q2xhc3MgPSB3cmFwcGVkQ29tcG9uZW50Q2xhc3NcblxuICBmb3IgKGNvbnN0IGZ1bmMgb2YgZnVuY3MpIHtcbiAgICBjdXJyZW50Q29tcG9uZW50Q2xhc3MgPSBmdW5jKGN1cnJlbnRDb21wb25lbnRDbGFzcylcbiAgfVxuXG4gIHJldHVybiBjdXJyZW50Q29tcG9uZW50Q2xhc3Ncbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZSxTQUFTQSxlQUFlQSxDQUFDQyxxQkFBcUIsRUFBRSxHQUFHQyxLQUFLLEVBQUU7RUFDdkUsSUFBSSxDQUFDRCxxQkFBcUIsRUFBRSxNQUFNLElBQUlFLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQztFQUUvRSxJQUFJQyxxQkFBcUIsR0FBR0gscUJBQXFCO0VBRWpELEtBQUssTUFBTUksSUFBSSxJQUFJSCxLQUFLLEVBQUU7SUFDeEJFLHFCQUFxQixHQUFHQyxJQUFJLENBQUNELHFCQUFxQixDQUFDO0VBQ3JEO0VBRUEsT0FBT0EscUJBQXFCO0FBQzlCIiwiaWdub3JlTGlzdCI6W119