@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/config.js

@@ -0,0 +1,62 @@
+import * as inflection from "inflection";
+const accessors = {
+  breakPoints: {
+    default: [["xxl", 1400], ["xl", 1200], ["lg", 992], ["md", 768], ["sm", 576], ["xs", 0]],
+    required: true
+  },
+  cableUrl: {
+    require: false
+  },
+  currenciesCollection: {
+    required: true
+  },
+  history: {
+    required: true
+  },
+  host: {
+    required: false
+  },
+  i18n: {
+    required: false
+  },
+  linkTo: {
+    required: true
+  },
+  modal: {
+    required: false
+  },
+  navigation: {
+    required: true
+  },
+  routes: {
+    required: false
+  },
+  routeDefinitions: {
+    required: false
+  }
+};
+class ApiMakerConfig {
+  constructor() {
+    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {};
+    this.global = globalThis.apiMakerConfigGlobal;
+  }
+}
+for (const accessorName in accessors) {
+  const accessorData = accessors[accessorName];
+  const camelizedAccessor = inflection.camelize(accessorName);
+  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {
+    this.global[accessorName] = newValue;
+  };
+  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {
+    if (!this.global[accessorName]) {
+      if (accessorData.default) return accessorData.default;
+      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`);
+    }
+    const value = this.global[accessorName];
+    if (typeof value == "function") return value(...args);
+    return value;
+  };
+}
+const apiMakerConfig = new ApiMakerConfig();
+export default apiMakerConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/custom-error.js

@@ -0,0 +1,5 @@
+import BaseError from "./base-error";
+class CustomError extends BaseError {}
+CustomError.apiMakerType = "CustomError";
+export default CustomError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJCYXNlRXJyb3IiLCJDdXN0b21FcnJvciIsImFwaU1ha2VyVHlwZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9jdXN0b20tZXJyb3IuanMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IEJhc2VFcnJvciBmcm9tIFwiLi9iYXNlLWVycm9yXCJcblxuY2xhc3MgQ3VzdG9tRXJyb3IgZXh0ZW5kcyBCYXNlRXJyb3Ige31cblxuQ3VzdG9tRXJyb3IuYXBpTWFrZXJUeXBlID0gXCJDdXN0b21FcnJvclwiXG5cbmV4cG9ydCBkZWZhdWx0IEN1c3RvbUVycm9yXG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLFNBQVMsTUFBTSxjQUFjO0FBRXBDLE1BQU1DLFdBQVcsU0FBU0QsU0FBUyxDQUFDO0FBRXBDQyxXQUFXLENBQUNDLFlBQVksR0FBRyxhQUFhO0FBRXhDLGVBQWVELFdBQVciLCJpZ25vcmVMaXN0IjpbXX0=

package/build/data-set-to-attributes.js

@@ -0,0 +1,10 @@
+import * as inflection from "inflection";
+export default function dataSetToAttributes(dataSet) {
+  const result = {};
+  for (const key in dataSet) {
+    const dasherizedKey = `data-${inflection.dasherize(inflection.underscore(key))}`;
+    result[dasherizedKey] = dataSet[key];
+  }
+  return result;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJpbmZsZWN0aW9uIiwiZGF0YVNldFRvQXR0cmlidXRlcyIsImRhdGFTZXQiLCJyZXN1bHQiLCJrZXkiLCJkYXNoZXJpemVkS2V5IiwiZGFzaGVyaXplIiwidW5kZXJzY29yZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhLXNldC10by1hdHRyaWJ1dGVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGluZmxlY3Rpb24gZnJvbSBcImluZmxlY3Rpb25cIlxuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBkYXRhU2V0VG9BdHRyaWJ1dGVzKGRhdGFTZXQpIHtcbiAgY29uc3QgcmVzdWx0ID0ge31cblxuICBmb3IgKGNvbnN0IGtleSBpbiBkYXRhU2V0KSB7XG4gICAgY29uc3QgZGFzaGVyaXplZEtleSA9IGBkYXRhLSR7aW5mbGVjdGlvbi5kYXNoZXJpemUoaW5mbGVjdGlvbi51bmRlcnNjb3JlKGtleSkpfWBcblxuICAgIHJlc3VsdFtkYXNoZXJpemVkS2V5XSA9IGRhdGFTZXRba2V5XVxuICB9XG5cbiAgcmV0dXJuIHJlc3VsdFxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLFVBQVUsTUFBTSxZQUFZO0FBRXhDLGVBQWUsU0FBU0MsbUJBQW1CQSxDQUFDQyxPQUFPLEVBQUU7RUFDbkQsTUFBTUMsTUFBTSxHQUFHLENBQUMsQ0FBQztFQUVqQixLQUFLLE1BQU1DLEdBQUcsSUFBSUYsT0FBTyxFQUFFO0lBQ3pCLE1BQU1HLGFBQWEsR0FBRyxRQUFRTCxVQUFVLENBQUNNLFNBQVMsQ0FBQ04sVUFBVSxDQUFDTyxVQUFVLENBQUNILEdBQUcsQ0FBQyxDQUFDLEVBQUU7SUFFaEZELE1BQU0sQ0FBQ0UsYUFBYSxDQUFDLEdBQUdILE9BQU8sQ0FBQ0UsR0FBRyxDQUFDO0VBQ3RDO0VBRUEsT0FBT0QsTUFBTTtBQUNmIiwiaWdub3JlTGlzdCI6W119

package/build/deserializer.js

@@ -0,0 +1,56 @@
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import modelClassRequire from "./model-class-require";
+import ModelsResponseReader from "./models-response-reader";
+import Money from "js-money";
+export default class ApiMakerDeserializer {
+  static parse(object) {
+    if (Array.isArray(object)) {
+      return object.map(value => ApiMakerDeserializer.parse(value));
+    } else if (object && typeof object == "object") {
+      if (object.api_maker_type == "date") {
+        const date = new Date(digg(object, "value"));
+        date.apiMakerType = "date";
+        return date;
+      } else if (object.api_maker_type == "time") {
+        const date = new Date(digg(object, "value"));
+        date.apiMakerType = "time";
+        return date;
+      } else if (object.api_maker_type == "collection") {
+        // Need to remove type to avoid circular error
+        const {
+          api_maker_type,
+          ...restObject
+        } = object;
+        return ModelsResponseReader.collection(ApiMakerDeserializer.parse(restObject));
+      } else if (object.api_maker_type == "money") {
+        const cents = digg(object, "amount");
+        const currency = digg(object, "currency");
+        return Money.fromInteger(cents, currency);
+      } else if (object.api_maker_type == "model") {
+        const modelClassName = inflection.classify(digg(object, "model_name"));
+        const ModelClass = modelClassRequire(modelClassName);
+        const data = ApiMakerDeserializer.parse(digg(object, "serialized"));
+        const model = new ModelClass({
+          data,
+          isNewRecord: false
+        });
+        return model;
+      } else if (object.api_maker_type == "resource") {
+        const modelClassName = inflection.classify(digg(object, "name"));
+        const ModelClass = modelClassRequire(modelClassName);
+        return ModelClass;
+      } else {
+        const newObject = {};
+        for (const key in object) {
+          const value = object[key];
+          newObject[key] = ApiMakerDeserializer.parse(value);
+        }
+        return newObject;
+      }
+    } else {
+      return object;
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/destroy-error.js

@@ -0,0 +1,5 @@
+import CustomError from "./custom-error";
+class DestroyError extends CustomError {}
+DestroyError.apiMakerType = "DestroyError";
+export default DestroyError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDdXN0b21FcnJvciIsIkRlc3Ryb3lFcnJvciIsImFwaU1ha2VyVHlwZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9kZXN0cm95LWVycm9yLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDdXN0b21FcnJvciBmcm9tIFwiLi9jdXN0b20tZXJyb3JcIlxuXG5jbGFzcyBEZXN0cm95RXJyb3IgZXh0ZW5kcyBDdXN0b21FcnJvciB7fVxuXG5EZXN0cm95RXJyb3IuYXBpTWFrZXJUeXBlID0gXCJEZXN0cm95RXJyb3JcIlxuXG5leHBvcnQgZGVmYXVsdCBEZXN0cm95RXJyb3JcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsV0FBVyxNQUFNLGdCQUFnQjtBQUV4QyxNQUFNQyxZQUFZLFNBQVNELFdBQVcsQ0FBQztBQUV2Q0MsWUFBWSxDQUFDQyxZQUFZLEdBQUcsY0FBYztBQUUxQyxlQUFlRCxZQUFZIiwiaWdub3JlTGlzdCI6W119

package/build/devise.js

@@ -0,0 +1,112 @@
+import Deserializer from "./deserializer";
+import events from "./events";
+import * as inflection from "inflection";
+import modelClassRequire from "./model-class-require";
+import Services from "./services";
+if (!globalThis.ApiMakerDevise) globalThis.ApiMakerDevise = {
+  scopes: {}
+};
+const shared = globalThis.ApiMakerDevise;
+export default class ApiMakerDevise {
+  static callSignOutEvent(args) {
+    events.emit("onDeviseSignOut", {
+      args
+    });
+  }
+  static current() {
+    if (!shared.currentApiMakerDevise) {
+      shared.currentApiMakerDevise = new ApiMakerDevise();
+    }
+    return shared.currentApiMakerDevise;
+  }
+  static events() {
+    return events;
+  }
+  static addUserScope(scope, args = {}) {
+    const currentMethodName = `current${inflection.camelize(scope)}`;
+    const isSignedInMethodName = `is${inflection.camelize(scope)}SignedIn`;
+    const getArgsMethodName = `get${inflection.camelize(scope)}Args`;
+    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope);
+    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope));
+    ApiMakerDevise[getArgsMethodName] = () => args;
+  }
+  static async signIn(username, password, args = {}) {
+    if (!args.scope) args.scope = "user";
+    const postData = {
+      username,
+      password,
+      args
+    };
+    const response = await Services.current().sendRequest("Devise::SignIn", postData);
+    let model = response.model;
+    if (Array.isArray(model)) model = model[0];
+    ApiMakerDevise.updateSession(model);
+    events.emit("onDeviseSignIn", Object.assign({
+      username
+    }, args));
+    return {
+      model,
+      response
+    };
+  }
+  static updateSession(model, args = {}) {
+    if (!args.scope) args.scope = "user";
+    const camelizedScopeName = inflection.camelize(args.scope, true);
+    ApiMakerDevise.current().currents[camelizedScopeName] = model;
+  }
+  hasCurrentScope(scope) {
+    const camelizedScopeName = inflection.camelize(scope, true);
+    return camelizedScopeName in ApiMakerDevise.current().currents;
+  }
+  static setSignedOut(args) {
+    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null;
+  }
+  static async signOut(args = {}) {
+    if (!args.scope) {
+      args.scope = "user";
+    }
+    const response = await Services.current().sendRequest("Devise::SignOut", {
+      args
+    });
+
+    // Cannot use the class because they would both import each other
+    if (shared.apiMakerSessionStatusUpdater) {
+      shared.apiMakerSessionStatusUpdater.updateSessionStatus();
+    }
+    ApiMakerDevise.setSignedOut(args);
+    ApiMakerDevise.callSignOutEvent(args);
+    return response;
+  }
+  constructor() {
+    this.currents = {};
+  }
+  getCurrentScope(scope) {
+    if (!(scope in this.currents)) {
+      this.currents[scope] = this.loadCurrentScope(scope);
+    }
+    return this.currents[scope];
+  }
+  hasGlobalCurrentScope(scope) {
+    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {
+      return true;
+    }
+    return false;
+  }
+  loadCurrentScope(scope) {
+    if (!this.hasGlobalCurrentScope(scope)) {
+      return null;
+    }
+    const scopeData = globalThis.apiMakerDeviseCurrent[scope];
+    if (!scopeData) return null;
+    const parsedScopeData = Deserializer.parse(scopeData);
+
+    // Might be a collection with preloaded relationships
+    if (Array.isArray(parsedScopeData)) return parsedScopeData[0];
+    const ModelClass = modelClassRequire(scope);
+    const modelInstance = new ModelClass({
+      data: parsedScopeData
+    });
+    return modelInstance;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Deserializer","events","inflection","modelClassRequire","Services","globalThis","ApiMakerDevise","scopes","shared","callSignOutEvent","args","emit","current","currentApiMakerDevise","addUserScope","scope","currentMethodName","camelize","isSignedInMethodName","getArgsMethodName","getCurrentScope","Boolean","signIn","username","password","postData","response","sendRequest","model","Array","isArray","updateSession","Object","assign","camelizedScopeName","currents","hasCurrentScope","setSignedOut","signOut","apiMakerSessionStatusUpdater","updateSessionStatus","constructor","loadCurrentScope","hasGlobalCurrentScope","apiMakerDeviseCurrent","scopeData","parsedScopeData","parse","ModelClass","modelInstance","data"],"sources":["../src/devise.js"],"sourcesContent":["import Deserializer from \"./deserializer\"\nimport events from \"./events\"\nimport * as inflection from \"inflection\"\nimport modelClassRequire from \"./model-class-require\"\nimport Services from \"./services\"\n\nif (!globalThis.ApiMakerDevise) globalThis.ApiMakerDevise = {scopes: {}}\n\nconst shared = globalThis.ApiMakerDevise\n\nexport default class ApiMakerDevise {\n  static callSignOutEvent(args) {\n    events.emit(\"onDeviseSignOut\", {args})\n  }\n\n  static current() {\n    if (!shared.currentApiMakerDevise) {\n      shared.currentApiMakerDevise = new ApiMakerDevise()\n    }\n\n    return shared.currentApiMakerDevise\n  }\n\n  static events() {\n    return events\n  }\n\n  static addUserScope(scope, args = {}) {\n    const currentMethodName = `current${inflection.camelize(scope)}`\n    const isSignedInMethodName = `is${inflection.camelize(scope)}SignedIn`\n    const getArgsMethodName = `get${inflection.camelize(scope)}Args`\n\n    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope)\n    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope))\n    ApiMakerDevise[getArgsMethodName] = () => args\n  }\n\n  static async signIn(username, password, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const postData = {username, password, args}\n    const response = await Services.current().sendRequest(\"Devise::SignIn\", postData)\n\n    let model = response.model\n\n    if (Array.isArray(model)) model = model[0]\n\n    ApiMakerDevise.updateSession(model)\n    events.emit(\"onDeviseSignIn\", Object.assign({username}, args))\n\n    return {model, response}\n  }\n\n  static updateSession(model, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const camelizedScopeName = inflection.camelize(args.scope, true)\n\n    ApiMakerDevise.current().currents[camelizedScopeName] = model\n  }\n\n  hasCurrentScope(scope) {\n    const camelizedScopeName = inflection.camelize(scope, true)\n\n    return camelizedScopeName in ApiMakerDevise.current().currents\n  }\n\n  static setSignedOut(args) {\n    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null\n  }\n\n  static async signOut(args = {}) {\n    if (!args.scope) {\n      args.scope = \"user\"\n    }\n\n    const response = await Services.current().sendRequest(\"Devise::SignOut\", {args})\n\n    // Cannot use the class because they would both import each other\n    if (shared.apiMakerSessionStatusUpdater) {\n      shared.apiMakerSessionStatusUpdater.updateSessionStatus()\n    }\n\n    ApiMakerDevise.setSignedOut(args)\n    ApiMakerDevise.callSignOutEvent(args)\n\n    return response\n  }\n\n  constructor() {\n    this.currents = {}\n  }\n\n  getCurrentScope(scope) {\n    if (!(scope in this.currents)) {\n      this.currents[scope] = this.loadCurrentScope(scope)\n    }\n\n    return this.currents[scope]\n  }\n\n  hasGlobalCurrentScope(scope) {\n    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {\n      return true\n    }\n\n    return false\n  }\n\n  loadCurrentScope(scope) {\n    if (!this.hasGlobalCurrentScope(scope)) {\n      return null\n    }\n\n    const scopeData = globalThis.apiMakerDeviseCurrent[scope]\n\n    if (!scopeData) return null\n\n    const parsedScopeData = Deserializer.parse(scopeData)\n\n    // Might be a collection with preloaded relationships\n    if (Array.isArray(parsedScopeData)) return parsedScopeData[0]\n\n    const ModelClass = modelClassRequire(scope)\n    const modelInstance = new ModelClass({data: parsedScopeData})\n\n    return modelInstance\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/draggable-sort/controller.js

@@ -0,0 +1,136 @@
+import { digg } from "diggerize";
+import EventEmitter from "events";
+export default class DraggableSortController {
+  constructor({
+    data,
+    events,
+    keyExtractor
+  }) {
+    this.data = data;
+    this.currentOrder = [...data];
+    this.events = events || new EventEmitter();
+    this.keyExtractor = keyExtractor;
+    this.draggedItem = null;
+    this.draggedItemData = null;
+    this.draggedItemNewPosition = null;
+    this.draggedOverItem = null;
+    this.draggedOverItemData = null;
+    this.itemData = {};
+    for (const itemIndex in data) {
+      this.itemData[itemIndex] = {
+        index: itemIndex,
+        item: data[itemIndex],
+        position: itemIndex
+      };
+    }
+  }
+  getEvents = () => this.events;
+  getItemDataForItem = item => this.getItemDataForIndex(this.data.indexOf(item));
+  getItemDataForKey = key => this.itemData.find(itemDataI => digg(itemDataI, "key") == key);
+  getItemDataForIndex = index => digg(this, "itemData", index);
+  onDragStart = ({
+    item,
+    itemIndex
+  }) => {
+    if (item) {
+      this.draggedItem = item;
+      this.draggedItemData = this.getItemDataForIndex(itemIndex);
+      this.draggedItemIndex = itemIndex;
+      this.draggedItemPosition = this.draggedItemData.position;
+      this.events.emit("onDragStart", {
+        item,
+        itemData: this.draggedItemData
+      });
+    }
+  };
+  onDragEnd = () => {
+    const itemData = this.draggedItemData;
+    const fromIndex = itemData.index;
+    const fromPosition = digg(this, "draggedItemPosition");
+    const toPosition = this.draggedItemNewPosition;
+    const fromItem = this.draggedItem;
+    const toItem = this.draggedOverItem;
+    const callbackArgs = {
+      item: itemData.item,
+      itemData,
+      fromIndex,
+      fromItem,
+      fromPosition,
+      toItem,
+      toPosition
+    };
+    this.draggedItemData.events.emit("resetPosition", {
+      callback: () => {
+        this.events.emit("onDragEndAnimation", callbackArgs);
+      }
+    });
+    this.draggedItem = null;
+    this.draggedItemData = null;
+    this.draggedItemNewPosition = null;
+    this.draggedOverItem = null;
+    this.draggedOverItemData = null;
+    this.events.emit("onDragEnd", callbackArgs);
+  };
+  onItemLayout = ({
+    events,
+    index,
+    item,
+    layout
+  }) => {
+    if (!(index in this.itemData)) throw new Error(`Item not found for index ${index}`);
+    const itemData = this.itemData[index];
+    itemData.layout = layout;
+    if (!itemData.initialLayout) {
+      itemData.baseX = layout.x;
+      itemData.events = events;
+      itemData.initialLayout = layout;
+      itemData.key = this.keyExtractor(item);
+    }
+  };
+  onMove = ({
+    gestate
+  }) => {
+    // Send move-event to the item being dragged so it will actually move around
+    this.draggedItemData?.events?.emit("move", {
+      gestate
+    });
+    const moveX = gestate.dx + this.initialDragPosition.x;
+    for (const itemIndex in this.itemData) {
+      const itemData = this.getItemDataForIndex(itemIndex);
+      const baseX = digg(itemData, "baseX");
+      let smallestWidth = this.draggedItemData.layout.width;
+      if (itemData.layout.width < smallestWidth) smallestWidth = itemData.layout.width;
+      if (moveX > baseX && moveX < baseX + smallestWidth && itemIndex != this.draggedItemData.index) {
+        this.draggedOverItem = itemData.item;
+        this.draggedOverItemData = itemData;
+        const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item);
+        const positionOfOverItem = this.currentOrder.indexOf(this.draggedOverItemData.item);
+        this.currentOrder[positionOfDraggedItem] = this.draggedOverItemData.item;
+        this.currentOrder[positionOfOverItem] = this.draggedItemData.item;
+        this.draggedItemData.position = positionOfOverItem;
+        this.draggedOverItemData.position = positionOfDraggedItem;
+        this.updatePositionOfItems();
+        this.draggedItemNewPosition = positionOfOverItem;
+      }
+    }
+  };
+  setInitialDragPosition = initialDragPosition => {
+    this.initialDragPosition = initialDragPosition;
+  };
+  updatePositionOfItems() {
+    let currentPosition = 0;
+    for (const item of this.currentOrder) {
+      const itemData = this.getItemDataForItem(item);
+      if (digg(itemData, "index") != digg(this, "draggedItemData", "index")) {
+        // Dont animate dragged element to a new position because it is currently being dragged
+        itemData.events.emit("moveToPosition", {
+          x: currentPosition,
+          y: 0
+        });
+      }
+      itemData.baseX = currentPosition;
+      currentPosition += digg(itemData, "layout", "width");
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digg","EventEmitter","DraggableSortController","constructor","data","events","keyExtractor","currentOrder","draggedItem","draggedItemData","draggedItemNewPosition","draggedOverItem","draggedOverItemData","itemData","itemIndex","index","item","position","getEvents","getItemDataForItem","getItemDataForIndex","indexOf","getItemDataForKey","key","find","itemDataI","onDragStart","draggedItemIndex","draggedItemPosition","emit","onDragEnd","fromIndex","fromPosition","toPosition","fromItem","toItem","callbackArgs","callback","onItemLayout","layout","Error","initialLayout","baseX","x","onMove","gestate","moveX","dx","initialDragPosition","smallestWidth","width","positionOfDraggedItem","positionOfOverItem","updatePositionOfItems","setInitialDragPosition","currentPosition","y"],"sources":["../../src/draggable-sort/controller.js"],"sourcesContent":["import {digg} from \"diggerize\"\nimport EventEmitter from \"events\"\n\nexport default class DraggableSortController {\n  constructor({data, events, keyExtractor}) {\n    this.data = data\n    this.currentOrder = [...data]\n    this.events = events || new EventEmitter()\n    this.keyExtractor = keyExtractor\n\n    this.draggedItem = null\n    this.draggedItemData = null\n    this.draggedItemNewPosition = null\n\n    this.draggedOverItem = null\n    this.draggedOverItemData = null\n\n    this.itemData = {}\n\n    for (const itemIndex in data) {\n      this.itemData[itemIndex] = {\n        index: itemIndex,\n        item: data[itemIndex],\n        position: itemIndex\n      }\n    }\n  }\n\n  getEvents = () => this.events\n  getItemDataForItem = (item) => this.getItemDataForIndex(this.data.indexOf(item))\n  getItemDataForKey = (key) => this.itemData.find((itemDataI) => digg(itemDataI, \"key\") == key)\n  getItemDataForIndex = (index) => digg(this, \"itemData\", index)\n\n  onDragStart = ({item, itemIndex}) => {\n    if (item) {\n      this.draggedItem = item\n      this.draggedItemData = this.getItemDataForIndex(itemIndex)\n      this.draggedItemIndex = itemIndex\n      this.draggedItemPosition = this.draggedItemData.position\n      this.events.emit(\"onDragStart\", {item, itemData: this.draggedItemData})\n    }\n  }\n\n  onDragEnd = () => {\n    const itemData = this.draggedItemData\n    const fromIndex = itemData.index\n    const fromPosition = digg(this, \"draggedItemPosition\")\n    const toPosition = this.draggedItemNewPosition\n    const fromItem = this.draggedItem\n    const toItem = this.draggedOverItem\n    const callbackArgs = {item: itemData.item, itemData, fromIndex, fromItem, fromPosition, toItem, toPosition}\n\n    this.draggedItemData.events.emit(\"resetPosition\", {\n      callback: () => {\n        this.events.emit(\"onDragEndAnimation\", callbackArgs)\n      }\n    })\n\n    this.draggedItem = null\n    this.draggedItemData = null\n    this.draggedItemNewPosition = null\n\n    this.draggedOverItem = null\n    this.draggedOverItemData = null\n\n    this.events.emit(\"onDragEnd\", callbackArgs)\n  }\n\n  onItemLayout = ({events, index, item, layout}) => {\n    if (!(index in this.itemData)) throw new Error(`Item not found for index ${index}`)\n\n    const itemData = this.itemData[index]\n\n    itemData.layout = layout\n\n    if (!itemData.initialLayout) {\n      itemData.baseX = layout.x\n      itemData.events = events\n      itemData.initialLayout = layout\n      itemData.key = this.keyExtractor(item)\n    }\n  }\n\n  onMove = ({gestate}) => {\n    // Send move-event to the item being dragged so it will actually move around\n    this.draggedItemData?.events?.emit(\"move\", {gestate})\n\n    const moveX = gestate.dx + this.initialDragPosition.x\n\n    for (const itemIndex in this.itemData) {\n      const itemData = this.getItemDataForIndex(itemIndex)\n      const baseX = digg(itemData, \"baseX\")\n      let smallestWidth = this.draggedItemData.layout.width\n\n      if (itemData.layout.width < smallestWidth) smallestWidth = itemData.layout.width\n\n      if (moveX > baseX && moveX < (baseX + smallestWidth) && itemIndex != this.draggedItemData.index) {\n        this.draggedOverItem = itemData.item\n        this.draggedOverItemData = itemData\n\n        const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item)\n        const positionOfOverItem = this.currentOrder.indexOf(this.draggedOverItemData.item)\n\n        this.currentOrder[positionOfDraggedItem] = this.draggedOverItemData.item\n        this.currentOrder[positionOfOverItem] = this.draggedItemData.item\n\n        this.draggedItemData.position = positionOfOverItem\n        this.draggedOverItemData.position = positionOfDraggedItem\n\n        this.updatePositionOfItems()\n        this.draggedItemNewPosition = positionOfOverItem\n      }\n    }\n  }\n\n  setInitialDragPosition = (initialDragPosition) => {\n    this.initialDragPosition = initialDragPosition\n  }\n\n  updatePositionOfItems() {\n    let currentPosition = 0\n\n    for (const item of this.currentOrder) {\n      const itemData = this.getItemDataForItem(item)\n\n      if (digg(itemData, \"index\") != digg(this, \"draggedItemData\", \"index\")) { // Dont animate dragged element to a new position because it is currently being dragged\n        itemData.events.emit(\"moveToPosition\", {\n          x: currentPosition,\n          y: 0\n        })\n      }\n\n      itemData.baseX = currentPosition\n      currentPosition += digg(itemData, \"layout\", \"width\")\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/draggable-sort/index.js

@@ -0,0 +1,114 @@
+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 React, { useMemo } from "react";
+import { Animated, PanResponder } from "react-native";
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import Controller from "./controller";
+import DraggableSortItem from "./item";
+import EventEmitter from "events";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import useEventEmitter from "../use-event-emitter";
+export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
+  static defaultProps = {
+    horizontal: false
+  };
+  static propTypes = propTypesExact({
+    cacheKeyExtractor: PropTypes.func,
+    data: PropTypes.array.isRequired,
+    dataSet: PropTypes.object,
+    events: PropTypes.instanceOf(EventEmitter),
+    horizontal: PropTypes.bool.isRequired,
+    keyExtractor: PropTypes.func.isRequired,
+    onDragItemEnd: PropTypes.func,
+    onDragItemStart: PropTypes.func,
+    onItemMoved: PropTypes.func,
+    onReordered: PropTypes.func.isRequired,
+    renderItem: PropTypes.func.isRequired
+  });
+  setup() {
+    const {
+      data,
+      keyExtractor
+    } = this.p;
+    const {
+      events
+    } = this.props;
+    this.controller = useMemo(() => new Controller({
+      data,
+      events,
+      keyExtractor
+    }), []);
+    this.panResponder = useMemo(() => PanResponder.create({
+      onStartShouldSetPanResponder: e => {
+        const initialDragPosition = {
+          x: e.nativeEvent.locationX,
+          y: e.nativeEvent.locationY
+        };
+        this.controller.setInitialDragPosition(initialDragPosition);
+        if (this.controller.draggedItemData) {
+          return true;
+        }
+      },
+      onPanResponderMove: (e, gestate) => {
+        this.tt.controller.onMove({
+          gestate
+        });
+      },
+      onPanResponderRelease: (e, gestate) => {
+        if (this.controller.draggedItem) {
+          this.tt.controller.onDragEnd();
+        }
+      }
+    }), []);
+    useEventEmitter(this.controller.getEvents(), "onDragStart", this.tt.onDragItemStart);
+    useEventEmitter(this.controller.getEvents(), "onDragEnd", this.tt.onDragItemEnd);
+  }
+  render() {
+    const {
+      data,
+      horizontal,
+      keyExtractor,
+      renderItem
+    } = this.p;
+    const {
+      cacheKeyExtractor,
+      dataSet
+    } = this.props;
+    const actualDataSet = useMemo(() => Object.assign({
+      component: "draggable-sort"
+    }, dataSet), [dataSet]);
+    return /*#__PURE__*/React.createElement(Animated.View, _extends({
+      dataSet: actualDataSet,
+      style: {
+        flexDirection: horizontal ? "row" : "column"
+      }
+    }, this.tt.panResponder.panHandlers), data.map((item, itemIndex) => /*#__PURE__*/React.createElement(DraggableSortItem, {
+      cacheKey: cacheKeyExtractor ? cacheKeyExtractor(item) : undefined,
+      controller: this.tt.controller,
+      item: item,
+      itemIndex: itemIndex,
+      key: keyExtractor(item),
+      onItemMoved: this.props.onItemMoved,
+      renderItem: renderItem
+    })));
+  }
+  onDragItemStart = ({
+    itemData
+  }) => {
+    if (this.props.onDragItemStart) {
+      this.p.onDragItemStart({
+        itemData
+      });
+    }
+  };
+  onDragItemEnd = args => {
+    if (args.toPosition !== null) {
+      this.p.onReordered(args);
+    }
+    if (this.props.onDragItemEnd) {
+      this.p.onDragItemEnd(args);
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","Animated","PanResponder","shapeComponent","ShapeComponent","Controller","DraggableSortItem","EventEmitter","memo","PropTypes","propTypesExact","useEventEmitter","DraggableSort","defaultProps","horizontal","propTypes","cacheKeyExtractor","func","data","array","isRequired","dataSet","object","events","instanceOf","bool","keyExtractor","onDragItemEnd","onDragItemStart","onItemMoved","onReordered","renderItem","setup","p","props","controller","panResponder","create","onStartShouldSetPanResponder","e","initialDragPosition","x","nativeEvent","locationX","y","locationY","setInitialDragPosition","draggedItemData","onPanResponderMove","gestate","tt","onMove","onPanResponderRelease","draggedItem","onDragEnd","getEvents","render","actualDataSet","Object","assign","component","createElement","View","_extends","style","flexDirection","panHandlers","map","item","itemIndex","cacheKey","undefined","key","itemData","args","toPosition"],"sources":["../../src/draggable-sort/index.jsx"],"sourcesContent":["import React, {useMemo} from \"react\"\nimport {Animated, PanResponder} from \"react-native\"\nimport {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport Controller from \"./controller\"\nimport DraggableSortItem from \"./item\"\nimport EventEmitter from \"events\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"../use-event-emitter\"\n\nexport default memo(shapeComponent(class DraggableSort extends ShapeComponent {\n  static defaultProps = {\n    horizontal: false\n  }\n\n  static propTypes = propTypesExact({\n    cacheKeyExtractor: PropTypes.func,\n    data: PropTypes.array.isRequired,\n    dataSet: PropTypes.object,\n    events: PropTypes.instanceOf(EventEmitter),\n    horizontal: PropTypes.bool.isRequired,\n    keyExtractor: PropTypes.func.isRequired,\n    onDragItemEnd: PropTypes.func,\n    onDragItemStart: PropTypes.func,\n    onItemMoved: PropTypes.func,\n    onReordered: PropTypes.func.isRequired,\n    renderItem: PropTypes.func.isRequired\n  })\n\n  setup() {\n    const {data, keyExtractor} = this.p\n    const {events} = this.props\n\n    this.controller = useMemo(() => new Controller({data, events, keyExtractor}), [])\n    this.panResponder = useMemo(\n      () => PanResponder.create({\n        onStartShouldSetPanResponder: (e) => {\n          const initialDragPosition = {x: e.nativeEvent.locationX, y: e.nativeEvent.locationY}\n\n          this.controller.setInitialDragPosition(initialDragPosition)\n\n          if (this.controller.draggedItemData) {\n            return true\n          }\n        },\n        onPanResponderMove: (e, gestate) => {\n          this.tt.controller.onMove({gestate})\n        },\n        onPanResponderRelease: (e, gestate) => {\n          if (this.controller.draggedItem) {\n            this.tt.controller.onDragEnd()\n          }\n        }\n      }),\n      []\n    )\n\n    useEventEmitter(this.controller.getEvents(), \"onDragStart\", this.tt.onDragItemStart)\n    useEventEmitter(this.controller.getEvents(), \"onDragEnd\", this.tt.onDragItemEnd)\n  }\n\n  render() {\n    const {data, horizontal, keyExtractor, renderItem} = this.p\n    const {cacheKeyExtractor, dataSet} = this.props\n    const actualDataSet = useMemo(\n      () => Object.assign(\n        {\n          component: \"draggable-sort\"\n        },\n        dataSet\n      ),\n      [dataSet]\n    )\n\n    return (\n      <Animated.View dataSet={actualDataSet} style={{flexDirection: horizontal ? \"row\" : \"column\"}} {...this.tt.panResponder.panHandlers}>\n        {data.map((item, itemIndex) =>\n          <DraggableSortItem\n            cacheKey={cacheKeyExtractor ? cacheKeyExtractor(item) : undefined}\n            controller={this.tt.controller}\n            item={item}\n            itemIndex={itemIndex}\n            key={keyExtractor(item)}\n            onItemMoved={this.props.onItemMoved}\n            renderItem={renderItem}\n          />\n        )}\n      </Animated.View>\n    )\n  }\n\n  onDragItemStart = ({itemData}) => {\n    if (this.props.onDragItemStart) {\n      this.p.onDragItemStart({itemData})\n    }\n  }\n\n  onDragItemEnd = (args) => {\n    if (args.toPosition !== null) {\n      this.p.onReordered(args)\n    }\n\n    if (this.props.onDragItemEnd) {\n      this.p.onDragItemEnd(args)\n    }\n  }\n}))\n"],"mappings":";AAAA,OAAOA,KAAK,IAAGC,OAAO,QAAO,OAAO;AACpC,SAAQC,QAAQ,EAAEC,YAAY,QAAO,cAAc;AACnD,SAAQC,cAAc,EAAEC,cAAc,QAAO,uCAAuC;AACpF,OAAOC,UAAU,MAAM,cAAc;AACrC,OAAOC,iBAAiB,MAAM,QAAQ;AACtC,OAAOC,YAAY,MAAM,QAAQ;AACjC,OAAOC,IAAI,MAAM,4BAA4B;AAC7C,OAAOC,SAAS,MAAM,YAAY;AAClC,OAAOC,cAAc,MAAM,kBAAkB;AAC7C,OAAOC,eAAe,MAAM,sBAAsB;AAElD,eAAeH,IAAI,CAACL,cAAc,CAAC,MAAMS,aAAa,SAASR,cAAc,CAAC;EAC5E,OAAOS,YAAY,GAAG;IACpBC,UAAU,EAAE;EACd,CAAC;EAED,OAAOC,SAAS,GAAGL,cAAc,CAAC;IAChCM,iBAAiB,EAAEP,SAAS,CAACQ,IAAI;IACjCC,IAAI,EAAET,SAAS,CAACU,KAAK,CAACC,UAAU;IAChCC,OAAO,EAAEZ,SAAS,CAACa,MAAM;IACzBC,MAAM,EAAEd,SAAS,CAACe,UAAU,CAACjB,YAAY,CAAC;IAC1CO,UAAU,EAAEL,SAAS,CAACgB,IAAI,CAACL,UAAU;IACrCM,YAAY,EAAEjB,SAAS,CAACQ,IAAI,CAACG,UAAU;IACvCO,aAAa,EAAElB,SAAS,CAACQ,IAAI;IAC7BW,eAAe,EAAEnB,SAAS,CAACQ,IAAI;IAC/BY,WAAW,EAAEpB,SAAS,CAACQ,IAAI;IAC3Ba,WAAW,EAAErB,SAAS,CAACQ,IAAI,CAACG,UAAU;IACtCW,UAAU,EAAEtB,SAAS,CAACQ,IAAI,CAACG;EAC7B,CAAC,CAAC;EAEFY,KAAKA,CAAA,EAAG;IACN,MAAM;MAACd,IAAI;MAAEQ;IAAY,CAAC,GAAG,IAAI,CAACO,CAAC;IACnC,MAAM;MAACV;IAAM,CAAC,GAAG,IAAI,CAACW,KAAK;IAE3B,IAAI,CAACC,UAAU,GAAGnC,OAAO,CAAC,MAAM,IAAIK,UAAU,CAAC;MAACa,IAAI;MAAEK,MAAM;MAAEG;IAAY,CAAC,CAAC,EAAE,EAAE,CAAC;IACjF,IAAI,CAACU,YAAY,GAAGpC,OAAO,CACzB,MAAME,YAAY,CAACmC,MAAM,CAAC;MACxBC,4BAA4B,EAAGC,CAAC,IAAK;QACnC,MAAMC,mBAAmB,GAAG;UAACC,CAAC,EAAEF,CAAC,CAACG,WAAW,CAACC,SAAS;UAAEC,CAAC,EAAEL,CAAC,CAACG,WAAW,CAACG;QAAS,CAAC;QAEpF,IAAI,CAACV,UAAU,CAACW,sBAAsB,CAACN,mBAAmB,CAAC;QAE3D,IAAI,IAAI,CAACL,UAAU,CAACY,eAAe,EAAE;UACnC,OAAO,IAAI;QACb;MACF,CAAC;MACDC,kBAAkB,EAAEA,CAACT,CAAC,EAAEU,OAAO,KAAK;QAClC,IAAI,CAACC,EAAE,CAACf,UAAU,CAACgB,MAAM,CAAC;UAACF;QAAO,CAAC,CAAC;MACtC,CAAC;MACDG,qBAAqB,EAAEA,CAACb,CAAC,EAAEU,OAAO,KAAK;QACrC,IAAI,IAAI,CAACd,UAAU,CAACkB,WAAW,EAAE;UAC/B,IAAI,CAACH,EAAE,CAACf,UAAU,CAACmB,SAAS,CAAC,CAAC;QAChC;MACF;IACF,CAAC,CAAC,EACF,EACF,CAAC;IAED3C,eAAe,CAAC,IAAI,CAACwB,UAAU,CAACoB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAACL,EAAE,CAACtB,eAAe,CAAC;IACpFjB,eAAe,CAAC,IAAI,CAACwB,UAAU,CAACoB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAACL,EAAE,CAACvB,aAAa,CAAC;EAClF;EAEA6B,MAAMA,CAAA,EAAG;IACP,MAAM;MAACtC,IAAI;MAAEJ,UAAU;MAAEY,YAAY;MAAEK;IAAU,CAAC,GAAG,IAAI,CAACE,CAAC;IAC3D,MAAM;MAACjB,iBAAiB;MAAEK;IAAO,CAAC,GAAG,IAAI,CAACa,KAAK;IAC/C,MAAMuB,aAAa,GAAGzD,OAAO,CAC3B,MAAM0D,MAAM,CAACC,MAAM,CACjB;MACEC,SAAS,EAAE;IACb,CAAC,EACDvC,OACF,CAAC,EACD,CAACA,OAAO,CACV,CAAC;IAED,oBACEtB,KAAA,CAAA8D,aAAA,CAAC5D,QAAQ,CAAC6D,IAAI,EAAAC,QAAA;MAAC1C,OAAO,EAAEoC,aAAc;MAACO,KAAK,EAAE;QAACC,aAAa,EAAEnD,UAAU,GAAG,KAAK,GAAG;MAAQ;IAAE,GAAK,IAAI,CAACoC,EAAE,CAACd,YAAY,CAAC8B,WAAW,GAC/HhD,IAAI,CAACiD,GAAG,CAAC,CAACC,IAAI,EAAEC,SAAS,kBACxBtE,KAAA,CAAA8D,aAAA,CAACvD,iBAAiB;MAChBgE,QAAQ,EAAEtD,iBAAiB,GAAGA,iBAAiB,CAACoD,IAAI,CAAC,GAAGG,SAAU;MAClEpC,UAAU,EAAE,IAAI,CAACe,EAAE,CAACf,UAAW;MAC/BiC,IAAI,EAAEA,IAAK;MACXC,SAAS,EAAEA,SAAU;MACrBG,GAAG,EAAE9C,YAAY,CAAC0C,IAAI,CAAE;MACxBvC,WAAW,EAAE,IAAI,CAACK,KAAK,CAACL,WAAY;MACpCE,UAAU,EAAEA;IAAW,CACxB,CACH,CACa,CAAC;EAEpB;EAEAH,eAAe,GAAGA,CAAC;IAAC6C;EAAQ,CAAC,KAAK;IAChC,IAAI,IAAI,CAACvC,KAAK,CAACN,eAAe,EAAE;MAC9B,IAAI,CAACK,CAAC,CAACL,eAAe,CAAC;QAAC6C;MAAQ,CAAC,CAAC;IACpC;EACF,CAAC;EAED9C,aAAa,GAAI+C,IAAI,IAAK;IACxB,IAAIA,IAAI,CAACC,UAAU,KAAK,IAAI,EAAE;MAC5B,IAAI,CAAC1C,CAAC,CAACH,WAAW,CAAC4C,IAAI,CAAC;IAC1B;IAEA,IAAI,IAAI,CAACxC,KAAK,CAACP,aAAa,EAAE;MAC5B,IAAI,CAACM,CAAC,CAACN,aAAa,CAAC+C,IAAI,CAAC;IAC5B;EACF,CAAC;AACH,CAAC,CAAC,CAAC","ignoreList":[]}