@kaspernj/api-maker 1.0.445 → 1.0.447

package/build/can-can.js

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

package/build/channels-consumer.js

@@ -0,0 +1,3 @@
+import { createConsumer } from "@rails/actioncable";
+export default createConsumer();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjcmVhdGVDb25zdW1lciJdLCJzb3VyY2VzIjpbIi4uL3NyYy9jaGFubmVscy1jb25zdW1lci5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2NyZWF0ZUNvbnN1bWVyfSBmcm9tIFwiQHJhaWxzL2FjdGlvbmNhYmxlXCJcblxuZXhwb3J0IGRlZmF1bHQgY3JlYXRlQ29uc3VtZXIoKVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFRQSxjQUFjLFFBQU8sb0JBQW9CO0FBRWpELGVBQWVBLGNBQWMsQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/build/collection-loader.js

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

package/build/collection.js

@@ -0,0 +1,279 @@
+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";
+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","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","uniqunize","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\"\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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJvYmplY3RUb0Zvcm1EYXRhIiwiQXBpTWFrZXJDb21tYW5kU3VibWl0RGF0YSIsImNvbnN0cnVjdG9yIiwiZGF0YSIsImZpbGVzQ291bnQiLCJqc29uRGF0YSIsInRyYXZlcnNlT2JqZWN0IiwiZ2V0RmlsZXNDb3VudCIsImdldEpzb25EYXRhIiwiZ2V0UmF3RGF0YSIsInJhd0RhdGEiLCJnZXRGb3JtRGF0YSIsIm9iamVjdEZvckZvcm1EYXRhIiwianNvbiIsIkpTT04iLCJzdHJpbmdpZnkiLCJmb3JtRGF0YSIsInNlcmlhbGl6ZSIsImNvbnZlcnREeW5hbWljIiwidmFsdWUiLCJ0eXBlIiwiQXJyYXkiLCJpc0FycmF5IiwidHJhdmVyc2VBcnJheSIsIm5hbWUiLCJzaG91bGRTa2lwIiwib2JqZWN0IiwiRmlsZSIsImlzT2JqZWN0IiwiYXJyYXkiLCJuZXdBcnJheSIsInB1c2giLCJuZXdPYmplY3QiLCJrZXkiXSwic291cmNlcyI6WyIuLi9zcmMvY29tbWFuZC1zdWJtaXQtZGF0YS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgb2JqZWN0VG9Gb3JtRGF0YSBmcm9tIFwib2JqZWN0LXRvLWZvcm1kYXRhXCJcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXBpTWFrZXJDb21tYW5kU3VibWl0RGF0YSB7XG4gIGNvbnN0cnVjdG9yIChkYXRhKSB7XG4gICAgdGhpcy5kYXRhID0gZGF0YVxuICAgIHRoaXMuZmlsZXNDb3VudCA9IDBcbiAgICB0aGlzLmpzb25EYXRhID0gdGhpcy50cmF2ZXJzZU9iamVjdCh0aGlzLmRhdGEsIFwianNvblwiKVxuICB9XG5cbiAgZ2V0RmlsZXNDb3VudCA9ICgpID0+IHRoaXMuZmlsZXNDb3VudFxuICBnZXRKc29uRGF0YSA9ICgpID0+IHRoaXMuanNvbkRhdGFcblxuICBnZXRSYXdEYXRhICgpIHtcbiAgICBpZiAoIXRoaXMucmF3RGF0YSkge1xuICAgICAgdGhpcy5yYXdEYXRhID0gdGhpcy50cmF2ZXJzZU9iamVjdCh0aGlzLmRhdGEsIFwicmF3XCIpXG4gICAgfVxuXG4gICAgcmV0dXJuIHRoaXMucmF3RGF0YVxuICB9XG5cbiAgZ2V0Rm9ybURhdGEgKCkge1xuICAgIGNvbnN0IG9iamVjdEZvckZvcm1EYXRhID0gdGhpcy5nZXRSYXdEYXRhKCkgfHwge31cblxuICAgIG9iamVjdEZvckZvcm1EYXRhLmpzb24gPSBKU09OLnN0cmluZ2lmeSh0aGlzLmdldEpzb25EYXRhKCkpXG5cbiAgICBjb25zdCBmb3JtRGF0YSA9IG9iamVjdFRvRm9ybURhdGEuc2VyaWFsaXplKG9iamVjdEZvckZvcm1EYXRhKVxuXG4gICAgcmV0dXJuIGZvcm1EYXRhXG4gIH1cblxuICBjb252ZXJ0RHluYW1pYyAodmFsdWUsIHR5cGUpIHtcbiAgICBpZiAoQXJyYXkuaXNBcnJheSh2YWx1ZSkpIHtcbiAgICAgIHJldHVybiB0aGlzLnRyYXZlcnNlQXJyYXkodmFsdWUsIHR5cGUpXG4gICAgfSBlbHNlIGlmICh0eXBlb2YgdmFsdWUgPT0gXCJvYmplY3RcIiAmJiB2YWx1ZSAhPT0gbnVsbCAmJiB2YWx1ZS5jb25zdHJ1Y3Rvci5uYW1lID09IFwiT2JqZWN0XCIpIHtcbiAgICAgIHJldHVybiB0aGlzLnRyYXZlcnNlT2JqZWN0KHZhbHVlLCB0eXBlKVxuICAgIH0gZWxzZSB7XG4gICAgICByZXR1cm4gdmFsdWVcbiAgICB9XG4gIH1cblxuICBzaG91bGRTa2lwIChvYmplY3QsIHR5cGUpIHtcbiAgICBpZiAodHlwZSA9PSBcImpzb25cIiAmJiBvYmplY3QgaW5zdGFuY2VvZiBGaWxlKSB7XG4gICAgICB0aGlzLmZpbGVzQ291bnQgKz0gMVxuICAgICAgcmV0dXJuIHRydWVcbiAgICB9XG5cbiAgICBpZiAodHlwZSA9PSBcInJhd1wiICYmICFBcnJheS5pc0FycmF5KG9iamVjdCkgJiYgIXRoaXMuaXNPYmplY3Qob2JqZWN0KSAmJiAhKG9iamVjdCBpbnN0YW5jZW9mIEZpbGUpKSB7XG4gICAgICByZXR1cm4gdHJ1ZVxuICAgIH1cblxuICAgIHJldHVybiBmYWxzZVxuICB9XG5cbiAgaXNPYmplY3QgKHZhbHVlKSB7XG4gICAgaWYgKHR5cGVvZiB2YWx1ZSA9PSBcIm9iamVjdFwiICYmIHZhbHVlICE9PSBudWxsICYmIHZhbHVlLmNvbnN0cnVjdG9yLm5hbWUgPT0gXCJPYmplY3RcIikge1xuICAgICAgcmV0dXJuIHRydWVcbiAgICB9XG5cbiAgICByZXR1cm4gZmFsc2VcbiAgfVxuXG4gIHRyYXZlcnNlQXJyYXkgKGFycmF5LCB0eXBlKSB7XG4gICAgY29uc3QgbmV3QXJyYXkgPSBbXVxuXG4gICAgZm9yIChjb25zdCB2YWx1ZSBvZiBhcnJheSkge1xuICAgICAgaWYgKHRoaXMuc2hvdWxkU2tpcCh2YWx1ZSwgdHlwZSkpIHtcbiAgICAgICAgY29udGludWVcbiAgICAgIH1cblxuICAgICAgaWYgKEFycmF5LmlzQXJyYXkodmFsdWUpKSB7XG4gICAgICAgIG5ld0FycmF5LnB1c2godGhpcy5jb252ZXJ0RHluYW1pYyh2YWx1ZSwgdHlwZSkpXG4gICAgICB9IGVsc2UgaWYgKHRoaXMuaXNPYmplY3QodmFsdWUpKSB7XG4gICAgICAgIG5ld0FycmF5LnB1c2godGhpcy5jb252ZXJ0RHluYW1pYyh2YWx1ZSwgdHlwZSkpXG4gICAgICB9IGVsc2Uge1xuICAgICAgICBuZXdBcnJheS5wdXNoKHZhbHVlKVxuICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBuZXdBcnJheVxuICB9XG5cbiAgdHJhdmVyc2VPYmplY3QgKG9iamVjdCwgdHlwZSkge1xuICAgIGNvbnN0IG5ld09iamVjdCA9IHt9XG5cbiAgICBmb3IgKGNvbnN0IGtleSBpbiBvYmplY3QpIHtcbiAgICAgIGNvbnN0IHZhbHVlID0gb2JqZWN0W2tleV1cblxuICAgICAgaWYgKHRoaXMuc2hvdWxkU2tpcCh2YWx1ZSwgdHlwZSkpIHtcbiAgICAgICAgY29udGludWVcbiAgICAgIH1cblxuICAgICAgaWYgKEFycmF5LmlzQXJyYXkodmFsdWUpKSB7XG4gICAgICAgIG5ld09iamVjdFtrZXldID0gdGhpcy5jb252ZXJ0RHluYW1pYyh2YWx1ZSwgdHlwZSlcbiAgICAgIH0gZWxzZSBpZiAodGhpcy5pc09iamVjdCh2YWx1ZSkpIHtcbiAgICAgICAgbmV3T2JqZWN0W2tleV0gPSB0aGlzLmNvbnZlcnREeW5hbWljKHZhbHVlLCB0eXBlKVxuICAgICAgfSBlbHNlIHtcbiAgICAgICAgbmV3T2JqZWN0W2tleV0gPSB2YWx1ZVxuICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBuZXdPYmplY3RcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxnQkFBZ0IsTUFBTSxvQkFBb0I7QUFFakQsZUFBZSxNQUFNQyx5QkFBeUIsQ0FBQztFQUM3Q0MsV0FBV0EsQ0FBRUMsSUFBSSxFQUFFO0lBQ2pCLElBQUksQ0FBQ0EsSUFBSSxHQUFHQSxJQUFJO0lBQ2hCLElBQUksQ0FBQ0MsVUFBVSxHQUFHLENBQUM7SUFDbkIsSUFBSSxDQUFDQyxRQUFRLEdBQUcsSUFBSSxDQUFDQyxjQUFjLENBQUMsSUFBSSxDQUFDSCxJQUFJLEVBQUUsTUFBTSxDQUFDO0VBQ3hEO0VBRUFJLGFBQWEsR0FBR0EsQ0FBQSxLQUFNLElBQUksQ0FBQ0gsVUFBVTtFQUNyQ0ksV0FBVyxHQUFHQSxDQUFBLEtBQU0sSUFBSSxDQUFDSCxRQUFRO0VBRWpDSSxVQUFVQSxDQUFBLEVBQUk7SUFDWixJQUFJLENBQUMsSUFBSSxDQUFDQyxPQUFPLEVBQUU7TUFDakIsSUFBSSxDQUFDQSxPQUFPLEdBQUcsSUFBSSxDQUFDSixjQUFjLENBQUMsSUFBSSxDQUFDSCxJQUFJLEVBQUUsS0FBSyxDQUFDO0lBQ3REO0lBRUEsT0FBTyxJQUFJLENBQUNPLE9BQU87RUFDckI7RUFFQUMsV0FBV0EsQ0FBQSxFQUFJO0lBQ2IsTUFBTUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDSCxVQUFVLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUVqREcsaUJBQWlCLENBQUNDLElBQUksR0FBR0MsSUFBSSxDQUFDQyxTQUFTLENBQUMsSUFBSSxDQUFDUCxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBRTNELE1BQU1RLFFBQVEsR0FBR2hCLGdCQUFnQixDQUFDaUIsU0FBUyxDQUFDTCxpQkFBaUIsQ0FBQztJQUU5RCxPQUFPSSxRQUFRO0VBQ2pCO0VBRUFFLGNBQWNBLENBQUVDLEtBQUssRUFBRUMsSUFBSSxFQUFFO0lBQzNCLElBQUlDLEtBQUssQ0FBQ0MsT0FBTyxDQUFDSCxLQUFLLENBQUMsRUFBRTtNQUN4QixPQUFPLElBQUksQ0FBQ0ksYUFBYSxDQUFDSixLQUFLLEVBQUVDLElBQUksQ0FBQztJQUN4QyxDQUFDLE1BQU0sSUFBSSxPQUFPRCxLQUFLLElBQUksUUFBUSxJQUFJQSxLQUFLLEtBQUssSUFBSSxJQUFJQSxLQUFLLENBQUNqQixXQUFXLENBQUNzQixJQUFJLElBQUksUUFBUSxFQUFFO01BQzNGLE9BQU8sSUFBSSxDQUFDbEIsY0FBYyxDQUFDYSxLQUFLLEVBQUVDLElBQUksQ0FBQztJQUN6QyxDQUFDLE1BQU07TUFDTCxPQUFPRCxLQUFLO0lBQ2Q7RUFDRjtFQUVBTSxVQUFVQSxDQUFFQyxNQUFNLEVBQUVOLElBQUksRUFBRTtJQUN4QixJQUFJQSxJQUFJLElBQUksTUFBTSxJQUFJTSxNQUFNLFlBQVlDLElBQUksRUFBRTtNQUM1QyxJQUFJLENBQUN2QixVQUFVLElBQUksQ0FBQztNQUNwQixPQUFPLElBQUk7SUFDYjtJQUVBLElBQUlnQixJQUFJLElBQUksS0FBSyxJQUFJLENBQUNDLEtBQUssQ0FBQ0MsT0FBTyxDQUFDSSxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQ0UsUUFBUSxDQUFDRixNQUFNLENBQUMsSUFBSSxFQUFFQSxNQUFNLFlBQVlDLElBQUksQ0FBQyxFQUFFO01BQ2xHLE9BQU8sSUFBSTtJQUNiO0lBRUEsT0FBTyxLQUFLO0VBQ2Q7RUFFQUMsUUFBUUEsQ0FBRVQsS0FBSyxFQUFFO0lBQ2YsSUFBSSxPQUFPQSxLQUFLLElBQUksUUFBUSxJQUFJQSxLQUFLLEtBQUssSUFBSSxJQUFJQSxLQUFLLENBQUNqQixXQUFXLENBQUNzQixJQUFJLElBQUksUUFBUSxFQUFFO01BQ3BGLE9BQU8sSUFBSTtJQUNiO0lBRUEsT0FBTyxLQUFLO0VBQ2Q7RUFFQUQsYUFBYUEsQ0FBRU0sS0FBSyxFQUFFVCxJQUFJLEVBQUU7SUFDMUIsTUFBTVUsUUFBUSxHQUFHLEVBQUU7SUFFbkIsS0FBSyxNQUFNWCxLQUFLLElBQUlVLEtBQUssRUFBRTtNQUN6QixJQUFJLElBQUksQ0FBQ0osVUFBVSxDQUFDTixLQUFLLEVBQUVDLElBQUksQ0FBQyxFQUFFO1FBQ2hDO01BQ0Y7TUFFQSxJQUFJQyxLQUFLLENBQUNDLE9BQU8sQ0FBQ0gsS0FBSyxDQUFDLEVBQUU7UUFDeEJXLFFBQVEsQ0FBQ0MsSUFBSSxDQUFDLElBQUksQ0FBQ2IsY0FBYyxDQUFDQyxLQUFLLEVBQUVDLElBQUksQ0FBQyxDQUFDO01BQ2pELENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQ1EsUUFBUSxDQUFDVCxLQUFLLENBQUMsRUFBRTtRQUMvQlcsUUFBUSxDQUFDQyxJQUFJLENBQUMsSUFBSSxDQUFDYixjQUFjLENBQUNDLEtBQUssRUFBRUMsSUFBSSxDQUFDLENBQUM7TUFDakQsQ0FBQyxNQUFNO1FBQ0xVLFFBQVEsQ0FBQ0MsSUFBSSxDQUFDWixLQUFLLENBQUM7TUFDdEI7SUFDRjtJQUVBLE9BQU9XLFFBQVE7RUFDakI7RUFFQXhCLGNBQWNBLENBQUVvQixNQUFNLEVBQUVOLElBQUksRUFBRTtJQUM1QixNQUFNWSxTQUFTLEdBQUcsQ0FBQyxDQUFDO0lBRXBCLEtBQUssTUFBTUMsR0FBRyxJQUFJUCxNQUFNLEVBQUU7TUFDeEIsTUFBTVAsS0FBSyxHQUFHTyxNQUFNLENBQUNPLEdBQUcsQ0FBQztNQUV6QixJQUFJLElBQUksQ0FBQ1IsVUFBVSxDQUFDTixLQUFLLEVBQUVDLElBQUksQ0FBQyxFQUFFO1FBQ2hDO01BQ0Y7TUFFQSxJQUFJQyxLQUFLLENBQUNDLE9BQU8sQ0FBQ0gsS0FBSyxDQUFDLEVBQUU7UUFDeEJhLFNBQVMsQ0FBQ0MsR0FBRyxDQUFDLEdBQUcsSUFBSSxDQUFDZixjQUFjLENBQUNDLEtBQUssRUFBRUMsSUFBSSxDQUFDO01BQ25ELENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQ1EsUUFBUSxDQUFDVCxLQUFLLENBQUMsRUFBRTtRQUMvQmEsU0FBUyxDQUFDQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUNmLGNBQWMsQ0FBQ0MsS0FBSyxFQUFFQyxJQUFJLENBQUM7TUFDbkQsQ0FBQyxNQUFNO1FBQ0xZLFNBQVMsQ0FBQ0MsR0FBRyxDQUFDLEdBQUdkLEtBQUs7TUFDeEI7SUFDRjtJQUVBLE9BQU9hLFNBQVM7RUFDbEI7QUFDRiIsImlnbm9yZUxpc3QiOltdfQ==