@kaspernj/api-maker 1.0.446 → 1.0.448

package/build/table/use-sorting.js

@@ -0,0 +1,34 @@
+import { camelize } from "inflection";
+import useQueryParams from "on-location-changed/src/use-query-params";
+const calculateQParams = (defaultParams, queryParams, searchKey) => {
+  if (searchKey in queryParams) {
+    return JSON.parse(queryParams[searchKey]);
+  } else if (defaultParams) {
+    return {
+      ...defaultParams
+    };
+  }
+  return {};
+};
+const useSorting = ({
+  defaultParams,
+  query
+}) => {
+  const queryParams = useQueryParams();
+  const searchKey = query.queryArgs.searchKey || "q";
+  const qParams = calculateQParams(defaultParams, queryParams, searchKey);
+  let matchSortParam;
+  if (typeof qParams.s == "string") {
+    matchSortParam = qParams.s?.match(/^(.+?)( asc| desc|)$/);
+  }
+  const sortAttribute = matchSortParam ? camelize(matchSortParam[1], true) : null;
+  const sortMode = matchSortParam ? matchSortParam[2].trim() : null;
+  return {
+    qParams,
+    searchKey,
+    sortAttribute,
+    sortMode
+  };
+};
+export default useSorting;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/table/widths.js

@@ -0,0 +1,75 @@
+import { Animated, Easing } from "react-native";
+import { digg } from "diggerize";
+export default class TableWidths {
+  constructor({
+    columns,
+    table,
+    width
+  }) {
+    this.columns = columns;
+    this.tableWidth = width;
+    this.table = table;
+    this.setWidths();
+  }
+  setWidths() {
+    this.columnsWidths = {};
+    let widthLeft = this.tableWidth;
+    const updateData = [];
+
+    // Set widths that are defined
+    for (const columnIndex in this.columns) {
+      const column = this.columns[columnIndex];
+      const tableSettingColumn = column.tableSettingColumn;
+      if (column.animatedPosition) throw new Error("Column already had an animated position");
+      column.animatedPosition = new Animated.ValueXY();
+      column.animatedZIndex = new Animated.Value(0);
+      if (tableSettingColumn.hasWidth()) {
+        if (column.animatedWidth) throw new Error("Column already had an animated width");
+        column.animatedWidth = new Animated.Value(tableSettingColumn.width());
+        column.width = tableSettingColumn.width();
+        widthLeft -= tableSettingColumn.width();
+      }
+    }
+
+    // Calculate how many columns are shown
+    const columnsWithoutWidth = this.columns.filter(column => !column.tableSettingColumn.hasWidth());
+    let amountOfColumns = columnsWithoutWidth.length;
+    amountOfColumns++; // Actions column
+
+    if (this.table.p.workplace) amountOfColumns++;
+
+    // Set widths of columns without
+    for (const columnIndex in this.columns) {
+      const column = this.columns[columnIndex];
+      const tableSettingColumn = column.tableSettingColumn;
+      if (!tableSettingColumn.hasWidth()) {
+        let newWidth = widthLeft / amountOfColumns;
+        if (newWidth < 200) newWidth = 200;
+        column.animatedWidth = new Animated.Value(newWidth);
+        column.width = newWidth;
+        updateData << {
+          id: tableSettingColumn.id(),
+          width: newWidth
+        };
+      }
+    }
+    if (updateData.length > 0) {
+      // FIXME: Should update the columns on the backend if anything changed
+    }
+  }
+  getWidthOfColumn(identifier) {
+    const column = this.columns.find(column => column.tableSettingColumn.identifier() == identifier);
+    if (!column) throw new Error(`No such column: ${identifier}`);
+    return digg(column, "width");
+  }
+  setWidthOfColumn({
+    identifier,
+    width
+  }) {
+    const column = this.columns.find(column => column.tableSettingColumn.identifier() == identifier);
+    if (!column) throw new Error(`No such column: ${identifier}`);
+    column.width = width;
+    column.animatedWidth.setValue(width);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/table/worker-plugins-check-all-checkbox.js

@@ -0,0 +1,125 @@
+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 { useEffect, useMemo, useRef } from "react";
+import BaseComponent from "../base-component";
+import classNames from "classnames";
+import Collection from "../collection";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import { simpleObjectDifferent } from "set-state-compare/src/diff-utils";
+import useModelEvent from "../use-model-event";
+const Checkbox = memo(shapeComponent(class Checkbox extends BaseComponent {
+  render() {
+    const {
+      indeterminate,
+      ...restProps
+    } = this.props;
+    const checkboxRef = useRef();
+    useEffect(() => {
+      checkboxRef.current.indeterminate = indeterminate;
+    });
+    return /*#__PURE__*/React.createElement("input", _extends({
+      ref: checkboxRef,
+      type: "checkbox"
+    }, restProps));
+  }
+}));
+export default memo(shapeComponent(class ApiMakerTableWorkerPluginsCheckAllCheckbox extends BaseComponent {
+  static propTypes = propTypesExact({
+    currentWorkplace: PropTypes.object,
+    query: PropTypes.instanceOf(Collection),
+    style: PropTypes.object
+  });
+  setup() {
+    this.useStates({
+      checked: false,
+      indeterminate: false
+    });
+    useMemo(() => {
+      this.updateAllChecked();
+    }, []);
+    useModelEvent(this.props.currentWorkplace, "workplace_links_created", this.tt.onLinksCreated);
+    useModelEvent(this.props.currentWorkplace, "workplace_links_destroyed", this.tt.onLinksDestroyed);
+  }
+  componentDidUpdate(prevProps) {
+    const previousParams = prevProps.query.params();
+    const currentParams = this.props.query.params();
+    if (simpleObjectDifferent(previousParams, currentParams)) {
+      this.updateAllChecked();
+    }
+  }
+  async updateAllChecked() {
+    const {
+      query,
+      currentWorkplace
+    } = this.props;
+    const queryLinksStatusResult = await currentWorkplace.queryLinksStatus({
+      query
+    });
+    const allChecked = queryLinksStatusResult.all_checked;
+    const someChecked = queryLinksStatusResult.some_checked;
+    this.setState({
+      checked: allChecked,
+      indeterminate: someChecked
+    });
+  }
+  render() {
+    const {
+      className,
+      style
+    } = this.props;
+    const {
+      checked,
+      indeterminate
+    } = this.state;
+    return /*#__PURE__*/React.createElement(Checkbox, {
+      checked: checked,
+      className: classNames("api-maker--table--worker-plugins-check-all-checkbox", className),
+      indeterminate: indeterminate,
+      onChange: this.onCheckedChanged,
+      style: style
+    });
+  }
+  modelClassName = () => this.props.query.modelClass().modelClassData().name;
+  onCheckedChanged = async e => {
+    e.preventDefault();
+    const {
+      currentWorkplace,
+      query
+    } = this.props;
+    const checkbox = e.target;
+    if (checkbox.checked) {
+      await currentWorkplace.addQuery({
+        query
+      });
+      this.setState({
+        checked: true,
+        indeterminate: false
+      });
+    } else {
+      await currentWorkplace.removeQuery({
+        query
+      });
+      this.setState({
+        checked: false,
+        indeterminate: false
+      });
+    }
+  };
+  onLinksCreated = ({
+    args
+  }) => {
+    if (args.created[this.modelClassName()]) {
+      this.updateAllChecked();
+    }
+  };
+  onLinksDestroyed = ({
+    args
+  }) => {
+    if (args.destroyed[this.modelClassName()]) {
+      this.updateAllChecked();
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useEffect","useMemo","useRef","BaseComponent","classNames","Collection","memo","PropTypes","propTypesExact","shapeComponent","simpleObjectDifferent","useModelEvent","Checkbox","render","indeterminate","restProps","props","checkboxRef","current","React","createElement","_extends","ref","type","ApiMakerTableWorkerPluginsCheckAllCheckbox","propTypes","currentWorkplace","object","query","instanceOf","style","setup","useStates","checked","updateAllChecked","tt","onLinksCreated","onLinksDestroyed","componentDidUpdate","prevProps","previousParams","params","currentParams","queryLinksStatusResult","queryLinksStatus","allChecked","all_checked","someChecked","some_checked","setState","className","state","onChange","onCheckedChanged","modelClassName","modelClass","modelClassData","name","e","preventDefault","checkbox","target","addQuery","removeQuery","args","created","destroyed"],"sources":["../../src/table/worker-plugins-check-all-checkbox.jsx"],"sourcesContent":["import {useEffect, useMemo, useRef} from \"react\"\nimport BaseComponent from \"../base-component\"\nimport classNames from \"classnames\"\nimport Collection from \"../collection\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport {simpleObjectDifferent} from \"set-state-compare/src/diff-utils\"\nimport useModelEvent from \"../use-model-event\"\n\nconst Checkbox = memo(shapeComponent(class Checkbox extends BaseComponent {\n  render() {\n    const {indeterminate, ...restProps} = this.props\n    const checkboxRef = useRef()\n\n    useEffect(() => {\n      checkboxRef.current.indeterminate = indeterminate\n    })\n\n    return (\n      <input ref={checkboxRef} type=\"checkbox\" {...restProps} />\n    )\n  }\n}))\n\nexport default memo(shapeComponent(class ApiMakerTableWorkerPluginsCheckAllCheckbox extends BaseComponent {\n  static propTypes = propTypesExact({\n    currentWorkplace: PropTypes.object,\n    query: PropTypes.instanceOf(Collection),\n    style: PropTypes.object\n  })\n\n  setup() {\n    this.useStates({\n      checked: false,\n      indeterminate: false\n    })\n\n    useMemo(() => {\n      this.updateAllChecked()\n    }, [])\n\n    useModelEvent(this.props.currentWorkplace, \"workplace_links_created\", this.tt.onLinksCreated)\n    useModelEvent(this.props.currentWorkplace, \"workplace_links_destroyed\", this.tt.onLinksDestroyed)\n  }\n\n  componentDidUpdate(prevProps) {\n    const previousParams = prevProps.query.params()\n    const currentParams = this.props.query.params()\n\n    if (simpleObjectDifferent(previousParams, currentParams)) {\n      this.updateAllChecked()\n    }\n  }\n\n  async updateAllChecked() {\n    const {query, currentWorkplace} = this.props\n    const queryLinksStatusResult = await currentWorkplace.queryLinksStatus({query})\n    const allChecked = queryLinksStatusResult.all_checked\n    const someChecked = queryLinksStatusResult.some_checked\n\n    this.setState({\n      checked: allChecked,\n      indeterminate: someChecked\n    })\n  }\n\n  render() {\n    const {className, style} = this.props\n    const {checked, indeterminate} = this.state\n\n    return (\n      <Checkbox\n        checked={checked}\n        className={classNames(\"api-maker--table--worker-plugins-check-all-checkbox\", className)}\n        indeterminate={indeterminate}\n        onChange={this.onCheckedChanged}\n        style={style}\n      />\n    )\n  }\n\n  modelClassName = () => this.props.query.modelClass().modelClassData().name\n\n  onCheckedChanged = async (e) => {\n    e.preventDefault()\n\n    const {currentWorkplace, query} = this.props\n    const checkbox = e.target\n\n    if (checkbox.checked) {\n      await currentWorkplace.addQuery({query})\n      this.setState({checked: true, indeterminate: false})\n    } else {\n      await currentWorkplace.removeQuery({query})\n      this.setState({checked: false, indeterminate: false})\n    }\n  }\n\n  onLinksCreated = ({args}) => {\n    if (args.created[this.modelClassName()]) {\n      this.updateAllChecked()\n    }\n  }\n\n  onLinksDestroyed = ({args}) => {\n    if (args.destroyed[this.modelClassName()]) {\n      this.updateAllChecked()\n    }\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/table/worker-plugins-checkbox.js

@@ -0,0 +1,115 @@
+import BaseComponent from "../base-component";
+import classNames from "classnames";
+import { digg } from "diggerize";
+import memo from "set-state-compare/src/memo";
+import modelClassRequire from "../model-class-require";
+import PropTypes from "prop-types";
+import PropTypesExact from "prop-types-exact";
+import { useMemo } from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import useModelEvent from "../use-model-event";
+const Workplace = modelClassRequire("Workplace");
+export default memo(shapeComponent(class ApiMakerTableWorkerPluginsCheckbox extends BaseComponent {
+  static propTypes = PropTypesExact({
+    currentWorkplace: PropTypes.object,
+    model: PropTypes.object.isRequired,
+    style: PropTypes.object
+  });
+  setup() {
+    this.useStates({
+      checked: false,
+      linkLoaded: false
+    });
+    useMemo(() => {
+      this.loadCurrentLink();
+    }, []);
+    useModelEvent(this.p.currentWorkplace, "workplace_links_created", this.tt.onLinksCreated);
+    useModelEvent(this.p.currentWorkplace, "workplace_links_destroyed", this.tt.onLinksDestroyed);
+  }
+  async loadCurrentLink() {
+    const {
+      model
+    } = this.props;
+    const response = await Workplace.linkFor({
+      model_class: model.modelClassData().name,
+      model_id: model.id()
+    });
+    const link = digg(response, "link");
+    this.setState({
+      checked: Boolean(link),
+      linkLoaded: true
+    });
+  }
+  render() {
+    const {
+      className,
+      model,
+      style
+    } = this.props;
+    const {
+      checked,
+      linkLoaded
+    } = this.state;
+    if (!linkLoaded) {
+      return null;
+    }
+    return /*#__PURE__*/React.createElement("input", {
+      checked: checked,
+      className: classNames("api-maker--table--worker-plugins-checkbox", className),
+      "data-checked": checked,
+      "data-model-id": model.id(),
+      onChange: this.tt.onCheckedChanged,
+      style: style,
+      type: "checkbox"
+    });
+  }
+  onCheckedChanged = e => {
+    e.preventDefault();
+    const {
+      model
+    } = this.props;
+    const checked = e.target.checked;
+    if (checked) {
+      Workplace.createLink({
+        model_class: model.modelClassData().name,
+        model_id: model.id()
+      });
+    } else {
+      const modelClassName = model.modelClassData().name;
+      const params = {
+        models: {}
+      };
+      params.models[modelClassName] = [model.id()];
+      Workplace.destroyLinks(params);
+    }
+  };
+  onLinksCreated = ({
+    args
+  }) => {
+    const {
+      model
+    } = digs(this.props, "model");
+    const id = model.id();
+    const modelClassName = model.modelClassData().name;
+    if (args.created[modelClassName] && args.created[modelClassName].includes(id)) {
+      this.setState({
+        checked: true
+      });
+    }
+  };
+  onLinksDestroyed = ({
+    args
+  }) => {
+    const {
+      model
+    } = digs(this.props, "model");
+    const id = model.id();
+    const modelClassName = model.modelClassData().name;
+    if (args.destroyed[modelClassName] && args.destroyed[modelClassName].includes(id)) {
+      this.setState({
+        checked: false
+      });
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BaseComponent","classNames","digg","memo","modelClassRequire","PropTypes","PropTypesExact","useMemo","shapeComponent","useModelEvent","Workplace","ApiMakerTableWorkerPluginsCheckbox","propTypes","currentWorkplace","object","model","isRequired","style","setup","useStates","checked","linkLoaded","loadCurrentLink","p","tt","onLinksCreated","onLinksDestroyed","props","response","linkFor","model_class","modelClassData","name","model_id","id","link","setState","Boolean","render","className","state","React","createElement","onChange","onCheckedChanged","type","e","preventDefault","target","createLink","modelClassName","params","models","destroyLinks","args","digs","created","includes","destroyed"],"sources":["../../src/table/worker-plugins-checkbox.jsx"],"sourcesContent":["import BaseComponent from \"../base-component\"\nimport classNames from \"classnames\"\nimport {digg} from \"diggerize\"\nimport memo from \"set-state-compare/src/memo\"\nimport modelClassRequire from \"../model-class-require\"\nimport PropTypes from \"prop-types\"\nimport PropTypesExact from \"prop-types-exact\"\nimport {useMemo} from \"react\"\nimport {shapeComponent} from \"set-state-compare/src/shape-component\"\nimport useModelEvent from \"../use-model-event\"\n\nconst Workplace = modelClassRequire(\"Workplace\")\n\nexport default memo(shapeComponent(class ApiMakerTableWorkerPluginsCheckbox extends BaseComponent {\n  static propTypes = PropTypesExact({\n    currentWorkplace: PropTypes.object,\n    model: PropTypes.object.isRequired,\n    style: PropTypes.object\n  })\n\n  setup() {\n    this.useStates({\n      checked: false,\n      linkLoaded: false\n    })\n\n    useMemo(() => {\n      this.loadCurrentLink()\n    }, [])\n\n    useModelEvent(this.p.currentWorkplace, \"workplace_links_created\", this.tt.onLinksCreated)\n    useModelEvent(this.p.currentWorkplace, \"workplace_links_destroyed\", this.tt.onLinksDestroyed)\n  }\n\n  async loadCurrentLink() {\n    const {model} = this.props\n    const response = await Workplace.linkFor({model_class: model.modelClassData().name, model_id: model.id()})\n    const link = digg(response, \"link\")\n\n    this.setState({\n      checked: Boolean(link),\n      linkLoaded: true\n    })\n  }\n\n  render() {\n    const {className, model, style} = this.props\n    const {checked, linkLoaded} = this.state\n\n    if (!linkLoaded) {\n      return null\n    }\n\n    return (\n      <input\n        checked={checked}\n        className={classNames(\"api-maker--table--worker-plugins-checkbox\", className)}\n        data-checked={checked}\n        data-model-id={model.id()}\n        onChange={this.tt.onCheckedChanged}\n        style={style}\n        type=\"checkbox\"\n      />\n    )\n  }\n\n  onCheckedChanged = (e) => {\n    e.preventDefault()\n\n    const {model} = this.props\n    const checked = e.target.checked\n\n    if (checked) {\n      Workplace.createLink({model_class: model.modelClassData().name, model_id: model.id()})\n    } else {\n      const modelClassName = model.modelClassData().name\n      const params = {models: {}}\n\n      params.models[modelClassName] = [model.id()]\n\n      Workplace.destroyLinks(params)\n    }\n  }\n\n  onLinksCreated = ({args}) => {\n    const {model} = digs(this.props, \"model\")\n    const id = model.id()\n    const modelClassName = model.modelClassData().name\n\n    if (args.created[modelClassName] && args.created[modelClassName].includes(id)) {\n      this.setState({checked: true})\n    }\n  }\n\n  onLinksDestroyed = ({args}) => {\n    const {model} = digs(this.props, \"model\")\n    const id = model.id()\n    const modelClassName = model.modelClassData().name\n\n    if (args.destroyed[modelClassName] && args.destroyed[modelClassName].includes(id)) {\n      this.setState({checked: false})\n    }\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/translated-attributes.js

@@ -0,0 +1,10 @@
+export default function apiMakerTranslatedAttributes(attributeNames, availableLocales) {
+  translatedAttributes = [];
+  for (const attribute of attributeNames) {
+    for (const locale of availableLocales) {
+      translatedAttributes.push(`${attribute}${locale.substring(0, 1).toUpperCase()}${locale.substring(1, 99)}`);
+    }
+  }
+  return translatedAttributes;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcGlNYWtlclRyYW5zbGF0ZWRBdHRyaWJ1dGVzIiwiYXR0cmlidXRlTmFtZXMiLCJhdmFpbGFibGVMb2NhbGVzIiwidHJhbnNsYXRlZEF0dHJpYnV0ZXMiLCJhdHRyaWJ1dGUiLCJsb2NhbGUiLCJwdXNoIiwic3Vic3RyaW5nIiwidG9VcHBlckNhc2UiXSwic291cmNlcyI6WyIuLi9zcmMvdHJhbnNsYXRlZC1hdHRyaWJ1dGVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGFwaU1ha2VyVHJhbnNsYXRlZEF0dHJpYnV0ZXMoYXR0cmlidXRlTmFtZXMsIGF2YWlsYWJsZUxvY2FsZXMpIHtcbiAgdHJhbnNsYXRlZEF0dHJpYnV0ZXMgPSBbXVxuXG4gIGZvciAoY29uc3QgYXR0cmlidXRlIG9mIGF0dHJpYnV0ZU5hbWVzKSB7XG4gICAgZm9yIChjb25zdCBsb2NhbGUgb2YgYXZhaWxhYmxlTG9jYWxlcykge1xuICAgICAgdHJhbnNsYXRlZEF0dHJpYnV0ZXMucHVzaChgJHthdHRyaWJ1dGV9JHtsb2NhbGUuc3Vic3RyaW5nKDAsIDEpLnRvVXBwZXJDYXNlKCl9JHtsb2NhbGUuc3Vic3RyaW5nKDEsIDk5KX1gKVxuICAgIH1cbiAgfVxuXG4gIHJldHVybiB0cmFuc2xhdGVkQXR0cmlidXRlc1xufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxlQUFlLFNBQVNBLDRCQUE0QkEsQ0FBQ0MsY0FBYyxFQUFFQyxnQkFBZ0IsRUFBRTtFQUNyRkMsb0JBQW9CLEdBQUcsRUFBRTtFQUV6QixLQUFLLE1BQU1DLFNBQVMsSUFBSUgsY0FBYyxFQUFFO0lBQ3RDLEtBQUssTUFBTUksTUFBTSxJQUFJSCxnQkFBZ0IsRUFBRTtNQUNyQ0Msb0JBQW9CLENBQUNHLElBQUksQ0FBQyxHQUFHRixTQUFTLEdBQUdDLE1BQU0sQ0FBQ0UsU0FBUyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQ0MsV0FBVyxDQUFDLENBQUMsR0FBR0gsTUFBTSxDQUFDRSxTQUFTLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUM7SUFDNUc7RUFDRjtFQUVBLE9BQU9KLG9CQUFvQjtBQUM3QiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/translated-collections.js

@@ -0,0 +1,11 @@
+import { digg } from "diggerize";
+import translatedCollectionsData from "../src/translated-collections-data.js.erb";
+export default class ApiMakerTranslatedCollections {
+  static get(modelClass, collectionName) {
+    const locale = I18n.locale;
+    const modelClassName = digg(modelClass.modelClassData(), "name");
+    const collection = digg(translatedCollectionsData, modelClassName, collectionName, locale, "collection_array");
+    return collection;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkaWdnIiwidHJhbnNsYXRlZENvbGxlY3Rpb25zRGF0YSIsIkFwaU1ha2VyVHJhbnNsYXRlZENvbGxlY3Rpb25zIiwiZ2V0IiwibW9kZWxDbGFzcyIsImNvbGxlY3Rpb25OYW1lIiwibG9jYWxlIiwiSTE4biIsIm1vZGVsQ2xhc3NOYW1lIiwibW9kZWxDbGFzc0RhdGEiLCJjb2xsZWN0aW9uIl0sInNvdXJjZXMiOlsiLi4vc3JjL3RyYW5zbGF0ZWQtY29sbGVjdGlvbnMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtkaWdnfSBmcm9tIFwiZGlnZ2VyaXplXCJcbmltcG9ydCB0cmFuc2xhdGVkQ29sbGVjdGlvbnNEYXRhIGZyb20gXCIuLi9zcmMvdHJhbnNsYXRlZC1jb2xsZWN0aW9ucy1kYXRhLmpzLmVyYlwiXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyVHJhbnNsYXRlZENvbGxlY3Rpb25zIHtcbiAgc3RhdGljIGdldCAobW9kZWxDbGFzcywgY29sbGVjdGlvbk5hbWUpIHtcbiAgICBjb25zdCBsb2NhbGUgPSBJMThuLmxvY2FsZVxuICAgIGNvbnN0IG1vZGVsQ2xhc3NOYW1lID0gZGlnZyhtb2RlbENsYXNzLm1vZGVsQ2xhc3NEYXRhKCksIFwibmFtZVwiKVxuICAgIGNvbnN0IGNvbGxlY3Rpb24gPSBkaWdnKHRyYW5zbGF0ZWRDb2xsZWN0aW9uc0RhdGEsIG1vZGVsQ2xhc3NOYW1lLCBjb2xsZWN0aW9uTmFtZSwgbG9jYWxlLCBcImNvbGxlY3Rpb25fYXJyYXlcIilcblxuICAgIHJldHVybiBjb2xsZWN0aW9uXG4gIH1cbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUUEsSUFBSSxRQUFPLFdBQVc7QUFDOUIsT0FBT0MseUJBQXlCLE1BQU0sMkNBQTJDO0FBRWpGLGVBQWUsTUFBTUMsNkJBQTZCLENBQUM7RUFDakQsT0FBT0MsR0FBR0EsQ0FBRUMsVUFBVSxFQUFFQyxjQUFjLEVBQUU7SUFDdEMsTUFBTUMsTUFBTSxHQUFHQyxJQUFJLENBQUNELE1BQU07SUFDMUIsTUFBTUUsY0FBYyxHQUFHUixJQUFJLENBQUNJLFVBQVUsQ0FBQ0ssY0FBYyxDQUFDLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDaEUsTUFBTUMsVUFBVSxHQUFHVixJQUFJLENBQUNDLHlCQUF5QixFQUFFTyxjQUFjLEVBQUVILGNBQWMsRUFBRUMsTUFBTSxFQUFFLGtCQUFrQixDQUFDO0lBRTlHLE9BQU9JLFVBQVU7RUFDbkI7QUFDRiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/updated-attribute.js

@@ -0,0 +1,76 @@
+import { digg } from "diggerize";
+import ModelEvents from "./model-events";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+export default class ApiMakerUpdatedAttribute extends React.PureComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.string,
+    model: PropTypes.object.isRequired,
+    onValue: PropTypes.func
+  });
+  constructor(props) {
+    super(props);
+    this.state = {
+      model: this.props.model
+    };
+  }
+  componentDidMount() {
+    this.setAttribute();
+    this.connect();
+  }
+  componentWillUnmount() {
+    // Apparently 'componentWillUnmount' can be called without 'componentDidMount' was called. Several bug reports on this.
+    if (this.connectUpdated) {
+      this.connectUpdated.unsubscribe();
+    }
+  }
+  connect() {
+    this.connectUpdated = ModelEvents.connectUpdated(this.props.model, args => {
+      if (!this.props.attribute || args.model.isAttributeLoaded(this.props.attribute)) {
+        this.setState({
+          model: args.model
+        }, () => this.setAttribute());
+      } else {
+        this.loadModelWithAttribute();
+      }
+    });
+  }
+
+  // This loads the model from the backend with the primary key and the attribute and calls setAttribute
+  async loadModelWithAttribute() {
+    const id = this.props.model.primaryKey();
+    const modelClass = this.props.model.modelClass();
+    const modelName = digg(modelClass.modelClassData(), "name");
+    const primaryKey = digg(modelClass.modelClassData(), "primaryKey");
+    const args = {};
+    args[`${primaryKey}_eq`] = id;
+    const select = {};
+    select[modelName] = [primaryKey, this.props.attribute];
+    const model = await modelClass.ransack(args).select(select).first();
+    this.setState({
+      model
+    }, () => this.setAttribute());
+  }
+  setAttribute() {
+    let newValue;
+    if (this.props.onValue) {
+      newValue = this.props.onValue.apply(null, [{
+        model: this.state.model
+      }]);
+    } else {
+      if (!this.state.model[this.props.attribute]) {
+        throw new Error(`No such method: ${digg(this.state.model.modelClassData(), "name")}#${this.props.attribute}()`);
+      }
+      newValue = this.state.model[this.props.attribute].apply(this.state.model);
+    }
+    this.setState({
+      value: newValue
+    });
+  }
+  render() {
+    if (this.state.value === undefined) return null;
+    return this.state.value;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/url-encode.js

@@ -0,0 +1,15 @@
+import escapeStringRegexp from "escape-string-regexp";
+const replaces = {
+  " ": "+",
+  "&": "%26",
+  "#": "%23",
+  "+": "%2B",
+  "/": "%2F",
+  "?": "%3F"
+};
+const regexp = new RegExp(`(${Object.keys(replaces).map(escapeStringRegexp).join("|")})`, "g");
+const urlEncode = string => {
+  return String(string).replaceAll(regexp, character => replaces[character]);
+};
+export default urlEncode;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJlc2NhcGVTdHJpbmdSZWdleHAiLCJyZXBsYWNlcyIsInJlZ2V4cCIsIlJlZ0V4cCIsIk9iamVjdCIsImtleXMiLCJtYXAiLCJqb2luIiwidXJsRW5jb2RlIiwic3RyaW5nIiwiU3RyaW5nIiwicmVwbGFjZUFsbCIsImNoYXJhY3RlciJdLCJzb3VyY2VzIjpbIi4uL3NyYy91cmwtZW5jb2RlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBlc2NhcGVTdHJpbmdSZWdleHAgZnJvbSBcImVzY2FwZS1zdHJpbmctcmVnZXhwXCJcblxuY29uc3QgcmVwbGFjZXMgPSB7XG4gIFwiIFwiOiBcIitcIixcbiAgXCImXCI6IFwiJTI2XCIsXG4gIFwiI1wiOiBcIiUyM1wiLFxuICBcIitcIjogXCIlMkJcIixcbiAgXCIvXCI6IFwiJTJGXCIsXG4gIFwiP1wiOiBcIiUzRlwiXG59XG5cbmNvbnN0IHJlZ2V4cCA9IG5ldyBSZWdFeHAoYCgke09iamVjdC5rZXlzKHJlcGxhY2VzKS5tYXAoZXNjYXBlU3RyaW5nUmVnZXhwKS5qb2luKFwifFwiKX0pYCwgXCJnXCIpXG5cbmNvbnN0IHVybEVuY29kZSA9IChzdHJpbmcpID0+IHtcbiAgcmV0dXJuIFN0cmluZyhzdHJpbmcpLnJlcGxhY2VBbGwocmVnZXhwLCAoY2hhcmFjdGVyKSA9PiByZXBsYWNlc1tjaGFyYWN0ZXJdKVxufVxuXG5leHBvcnQgZGVmYXVsdCB1cmxFbmNvZGVcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0Esa0JBQWtCLE1BQU0sc0JBQXNCO0FBRXJELE1BQU1DLFFBQVEsR0FBRztFQUNmLEdBQUcsRUFBRSxHQUFHO0VBQ1IsR0FBRyxFQUFFLEtBQUs7RUFDVixHQUFHLEVBQUUsS0FBSztFQUNWLEdBQUcsRUFBRSxLQUFLO0VBQ1YsR0FBRyxFQUFFLEtBQUs7RUFDVixHQUFHLEVBQUU7QUFDUCxDQUFDO0FBRUQsTUFBTUMsTUFBTSxHQUFHLElBQUlDLE1BQU0sQ0FBQyxJQUFJQyxNQUFNLENBQUNDLElBQUksQ0FBQ0osUUFBUSxDQUFDLENBQUNLLEdBQUcsQ0FBQ04sa0JBQWtCLENBQUMsQ0FBQ08sSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDO0FBRTlGLE1BQU1DLFNBQVMsR0FBSUMsTUFBTSxJQUFLO0VBQzVCLE9BQU9DLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDLENBQUNFLFVBQVUsQ0FBQ1QsTUFBTSxFQUFHVSxTQUFTLElBQUtYLFFBQVEsQ0FBQ1csU0FBUyxDQUFDLENBQUM7QUFDOUUsQ0FBQztBQUVELGVBQWVKLFNBQVMiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/use-breakpoint.js

@@ -0,0 +1,44 @@
+import { useCallback, useLayoutEffect } from "react";
+import apiMakerConfig from "@kaspernj/api-maker/build/config";
+import { Dimensions } from "react-native";
+import useShape from "set-state-compare/src/use-shape";
+const calculateBreakPoint = window => {
+  const windowWidth = window.width;
+  const result = {};
+  for (const breakpointData of apiMakerConfig.getBreakPoints()) {
+    const breakpoint = breakpointData[0];
+    const width = breakpointData[1];
+    if (!result.name && windowWidth >= width) {
+      result.name = breakpoint;
+    }
+    result[`${breakpoint}Down`] = !result.name;
+    result[`${breakpoint}Up`] = Boolean(result.name);
+  }
+  if (result.name) {
+    return result;
+  }
+  throw new Error(`Couldn't not find breakpoint from window width: ${windowWidth}`);
+};
+const useBreakpoint = () => {
+  const s = useShape();
+  const onCalled = useCallback(({
+    window
+  }) => {
+    const breakpoint = calculateBreakPoint(window);
+    if (breakpoint.name != s.s.breakpoint.name) {
+      s.set({
+        breakpoint
+      });
+    }
+  }, []);
+  s.useStates({
+    breakpoint: () => calculateBreakPoint(Dimensions.get("window"))
+  });
+  useLayoutEffect(() => {
+    const subscription = Dimensions.addEventListener("change", onCalled);
+    return () => subscription?.remove();
+  });
+  return s.s.breakpoint;
+};
+export default useBreakpoint;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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