@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/table/use-sorting.js

@@ -0,0 +1,34 @@
+import { camelize } from "inflection";
+import useQueryParams from "on-location-changed/build/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 React, { 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":["React","useEffect","useMemo","useRef","BaseComponent","classNames","Collection","memo","PropTypes","propTypesExact","shapeComponent","simpleObjectDifferent","useModelEvent","Checkbox","render","indeterminate","restProps","props","checkboxRef","current","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 React, {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":";AAAA,OAAOA,KAAK,IAAGC,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAO,OAAO;AACvD,OAAOC,aAAa,MAAM,mBAAmB;AAC7C,OAAOC,UAAU,MAAM,YAAY;AACnC,OAAOC,UAAU,MAAM,eAAe;AACtC,OAAOC,IAAI,MAAM,4BAA4B;AAC7C,OAAOC,SAAS,MAAM,YAAY;AAClC,OAAOC,cAAc,MAAM,kBAAkB;AAC7C,SAAQC,cAAc,QAAO,uCAAuC;AACpE,SAAQC,qBAAqB,QAAO,kCAAkC;AACtE,OAAOC,aAAa,MAAM,oBAAoB;AAE9C,MAAMC,QAAQ,GAAGN,IAAI,CAACG,cAAc,CAAC,MAAMG,QAAQ,SAAST,aAAa,CAAC;EACxEU,MAAMA,CAAA,EAAG;IACP,MAAM;MAACC,aAAa;MAAE,GAAGC;IAAS,CAAC,GAAG,IAAI,CAACC,KAAK;IAChD,MAAMC,WAAW,GAAGf,MAAM,CAAC,CAAC;IAE5BF,SAAS,CAAC,MAAM;MACdiB,WAAW,CAACC,OAAO,CAACJ,aAAa,GAAGA,aAAa;IACnD,CAAC,CAAC;IAEF,oBACEf,KAAA,CAAAoB,aAAA,UAAAC,QAAA;MAAOC,GAAG,EAAEJ,WAAY;MAACK,IAAI,EAAC;IAAU,GAAKP,SAAS,CAAG,CAAC;EAE9D;AACF,CAAC,CAAC,CAAC;AAEH,eAAeT,IAAI,CAACG,cAAc,CAAC,MAAMc,0CAA0C,SAASpB,aAAa,CAAC;EACxG,OAAOqB,SAAS,GAAGhB,cAAc,CAAC;IAChCiB,gBAAgB,EAAElB,SAAS,CAACmB,MAAM;IAClCC,KAAK,EAAEpB,SAAS,CAACqB,UAAU,CAACvB,UAAU,CAAC;IACvCwB,KAAK,EAAEtB,SAAS,CAACmB;EACnB,CAAC,CAAC;EAEFI,KAAKA,CAAA,EAAG;IACN,IAAI,CAACC,SAAS,CAAC;MACbC,OAAO,EAAE,KAAK;MACdlB,aAAa,EAAE;IACjB,CAAC,CAAC;IAEFb,OAAO,CAAC,MAAM;MACZ,IAAI,CAACgC,gBAAgB,CAAC,CAAC;IACzB,CAAC,EAAE,EAAE,CAAC;IAENtB,aAAa,CAAC,IAAI,CAACK,KAAK,CAACS,gBAAgB,EAAE,yBAAyB,EAAE,IAAI,CAACS,EAAE,CAACC,cAAc,CAAC;IAC7FxB,aAAa,CAAC,IAAI,CAACK,KAAK,CAACS,gBAAgB,EAAE,2BAA2B,EAAE,IAAI,CAACS,EAAE,CAACE,gBAAgB,CAAC;EACnG;EAEAC,kBAAkBA,CAACC,SAAS,EAAE;IAC5B,MAAMC,cAAc,GAAGD,SAAS,CAACX,KAAK,CAACa,MAAM,CAAC,CAAC;IAC/C,MAAMC,aAAa,GAAG,IAAI,CAACzB,KAAK,CAACW,KAAK,CAACa,MAAM,CAAC,CAAC;IAE/C,IAAI9B,qBAAqB,CAAC6B,cAAc,EAAEE,aAAa,CAAC,EAAE;MACxD,IAAI,CAACR,gBAAgB,CAAC,CAAC;IACzB;EACF;EAEA,MAAMA,gBAAgBA,CAAA,EAAG;IACvB,MAAM;MAACN,KAAK;MAAEF;IAAgB,CAAC,GAAG,IAAI,CAACT,KAAK;IAC5C,MAAM0B,sBAAsB,GAAG,MAAMjB,gBAAgB,CAACkB,gBAAgB,CAAC;MAAChB;IAAK,CAAC,CAAC;IAC/E,MAAMiB,UAAU,GAAGF,sBAAsB,CAACG,WAAW;IACrD,MAAMC,WAAW,GAAGJ,sBAAsB,CAACK,YAAY;IAEvD,IAAI,CAACC,QAAQ,CAAC;MACZhB,OAAO,EAAEY,UAAU;MACnB9B,aAAa,EAAEgC;IACjB,CAAC,CAAC;EACJ;EAEAjC,MAAMA,CAAA,EAAG;IACP,MAAM;MAACoC,SAAS;MAAEpB;IAAK,CAAC,GAAG,IAAI,CAACb,KAAK;IACrC,MAAM;MAACgB,OAAO;MAAElB;IAAa,CAAC,GAAG,IAAI,CAACoC,KAAK;IAE3C,oBACEnD,KAAA,CAAAoB,aAAA,CAACP,QAAQ;MACPoB,OAAO,EAAEA,OAAQ;MACjBiB,SAAS,EAAE7C,UAAU,CAAC,qDAAqD,EAAE6C,SAAS,CAAE;MACxFnC,aAAa,EAAEA,aAAc;MAC7BqC,QAAQ,EAAE,IAAI,CAACC,gBAAiB;MAChCvB,KAAK,EAAEA;IAAM,CACd,CAAC;EAEN;EAEAwB,cAAc,GAAGA,CAAA,KAAM,IAAI,CAACrC,KAAK,CAACW,KAAK,CAAC2B,UAAU,CAAC,CAAC,CAACC,cAAc,CAAC,CAAC,CAACC,IAAI;EAE1EJ,gBAAgB,GAAG,MAAOK,CAAC,IAAK;IAC9BA,CAAC,CAACC,cAAc,CAAC,CAAC;IAElB,MAAM;MAACjC,gBAAgB;MAAEE;IAAK,CAAC,GAAG,IAAI,CAACX,KAAK;IAC5C,MAAM2C,QAAQ,GAAGF,CAAC,CAACG,MAAM;IAEzB,IAAID,QAAQ,CAAC3B,OAAO,EAAE;MACpB,MAAMP,gBAAgB,CAACoC,QAAQ,CAAC;QAAClC;MAAK,CAAC,CAAC;MACxC,IAAI,CAACqB,QAAQ,CAAC;QAAChB,OAAO,EAAE,IAAI;QAAElB,aAAa,EAAE;MAAK,CAAC,CAAC;IACtD,CAAC,MAAM;MACL,MAAMW,gBAAgB,CAACqC,WAAW,CAAC;QAACnC;MAAK,CAAC,CAAC;MAC3C,IAAI,CAACqB,QAAQ,CAAC;QAAChB,OAAO,EAAE,KAAK;QAAElB,aAAa,EAAE;MAAK,CAAC,CAAC;IACvD;EACF,CAAC;EAEDqB,cAAc,GAAGA,CAAC;IAAC4B;EAAI,CAAC,KAAK;IAC3B,IAAIA,IAAI,CAACC,OAAO,CAAC,IAAI,CAACX,cAAc,CAAC,CAAC,CAAC,EAAE;MACvC,IAAI,CAACpB,gBAAgB,CAAC,CAAC;IACzB;EACF,CAAC;EAEDG,gBAAgB,GAAGA,CAAC;IAAC2B;EAAI,CAAC,KAAK;IAC7B,IAAIA,IAAI,CAACE,SAAS,CAAC,IAAI,CAACZ,cAAc,CAAC,CAAC,CAAC,EAAE;MACzC,IAAI,CAACpB,gBAAgB,CAAC,CAAC;IACzB;EACF,CAAC;AACH,CAAC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,115 @@
+import React, { useMemo } from "react";
+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 { 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
+    } = this.p;
+    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
+    } = this.p;
+    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":["React","useMemo","BaseComponent","classNames","digg","memo","modelClassRequire","PropTypes","PropTypesExact","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","createElement","onChange","onCheckedChanged","type","e","preventDefault","target","createLink","modelClassName","params","models","destroyLinks","args","created","includes","destroyed"],"sources":["../../src/table/worker-plugins-checkbox.jsx"],"sourcesContent":["import React, {useMemo} from \"react\"\nimport 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 {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} = this.p\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} = this.p\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) {
+  const 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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhcGlNYWtlclRyYW5zbGF0ZWRBdHRyaWJ1dGVzIiwiYXR0cmlidXRlTmFtZXMiLCJhdmFpbGFibGVMb2NhbGVzIiwidHJhbnNsYXRlZEF0dHJpYnV0ZXMiLCJhdHRyaWJ1dGUiLCJsb2NhbGUiLCJwdXNoIiwic3Vic3RyaW5nIiwidG9VcHBlckNhc2UiXSwic291cmNlcyI6WyIuLi9zcmMvdHJhbnNsYXRlZC1hdHRyaWJ1dGVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGFwaU1ha2VyVHJhbnNsYXRlZEF0dHJpYnV0ZXMoYXR0cmlidXRlTmFtZXMsIGF2YWlsYWJsZUxvY2FsZXMpIHtcbiAgY29uc3QgdHJhbnNsYXRlZEF0dHJpYnV0ZXMgPSBbXVxuXG4gIGZvciAoY29uc3QgYXR0cmlidXRlIG9mIGF0dHJpYnV0ZU5hbWVzKSB7XG4gICAgZm9yIChjb25zdCBsb2NhbGUgb2YgYXZhaWxhYmxlTG9jYWxlcykge1xuICAgICAgdHJhbnNsYXRlZEF0dHJpYnV0ZXMucHVzaChgJHthdHRyaWJ1dGV9JHtsb2NhbGUuc3Vic3RyaW5nKDAsIDEpLnRvVXBwZXJDYXNlKCl9JHtsb2NhbGUuc3Vic3RyaW5nKDEsIDk5KX1gKVxuICAgIH1cbiAgfVxuXG4gIHJldHVybiB0cmFuc2xhdGVkQXR0cmlidXRlc1xufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxlQUFlLFNBQVNBLDRCQUE0QkEsQ0FBQ0MsY0FBYyxFQUFFQyxnQkFBZ0IsRUFBRTtFQUNyRixNQUFNQyxvQkFBb0IsR0FBRyxFQUFFO0VBRS9CLEtBQUssTUFBTUMsU0FBUyxJQUFJSCxjQUFjLEVBQUU7SUFDdEMsS0FBSyxNQUFNSSxNQUFNLElBQUlILGdCQUFnQixFQUFFO01BQ3JDQyxvQkFBb0IsQ0FBQ0csSUFBSSxDQUFDLEdBQUdGLFNBQVMsR0FBR0MsTUFBTSxDQUFDRSxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDQyxXQUFXLENBQUMsQ0FBQyxHQUFHSCxNQUFNLENBQUNFLFNBQVMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQztJQUM1RztFQUNGO0VBRUEsT0FBT0osb0JBQW9CO0FBQzdCIiwiaWdub3JlTGlzdCI6W119

package/build/translated-collections.js

@@ -0,0 +1,12 @@
+import { digg } from "diggerize";
+import I18nOnSteroids from "i18n-on-steroids";
+import translatedCollectionsData from "translated-collections-data.json";
+export default class ApiMakerTranslatedCollections {
+  static get(modelClass, collectionName) {
+    const locale = I18nOnSteroids.getCurrent().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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkaWdnIiwiSTE4bk9uU3Rlcm9pZHMiLCJ0cmFuc2xhdGVkQ29sbGVjdGlvbnNEYXRhIiwiQXBpTWFrZXJUcmFuc2xhdGVkQ29sbGVjdGlvbnMiLCJnZXQiLCJtb2RlbENsYXNzIiwiY29sbGVjdGlvbk5hbWUiLCJsb2NhbGUiLCJnZXRDdXJyZW50IiwibW9kZWxDbGFzc05hbWUiLCJtb2RlbENsYXNzRGF0YSIsImNvbGxlY3Rpb24iXSwic291cmNlcyI6WyIuLi9zcmMvdHJhbnNsYXRlZC1jb2xsZWN0aW9ucy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2RpZ2d9IGZyb20gXCJkaWdnZXJpemVcIlxuaW1wb3J0IEkxOG5PblN0ZXJvaWRzIGZyb20gXCJpMThuLW9uLXN0ZXJvaWRzXCJcbmltcG9ydCB0cmFuc2xhdGVkQ29sbGVjdGlvbnNEYXRhIGZyb20gXCJ0cmFuc2xhdGVkLWNvbGxlY3Rpb25zLWRhdGEuanNvblwiXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyVHJhbnNsYXRlZENvbGxlY3Rpb25zIHtcbiAgc3RhdGljIGdldCAobW9kZWxDbGFzcywgY29sbGVjdGlvbk5hbWUpIHtcbiAgICBjb25zdCBsb2NhbGUgPSBJMThuT25TdGVyb2lkcy5nZXRDdXJyZW50KCkubG9jYWxlXG4gICAgY29uc3QgbW9kZWxDbGFzc05hbWUgPSBkaWdnKG1vZGVsQ2xhc3MubW9kZWxDbGFzc0RhdGEoKSwgXCJuYW1lXCIpXG4gICAgY29uc3QgY29sbGVjdGlvbiA9IGRpZ2codHJhbnNsYXRlZENvbGxlY3Rpb25zRGF0YSwgbW9kZWxDbGFzc05hbWUsIGNvbGxlY3Rpb25OYW1lLCBsb2NhbGUsIFwiY29sbGVjdGlvbl9hcnJheVwiKVxuXG4gICAgcmV0dXJuIGNvbGxlY3Rpb25cbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFRQSxJQUFJLFFBQU8sV0FBVztBQUM5QixPQUFPQyxjQUFjLE1BQU0sa0JBQWtCO0FBQzdDLE9BQU9DLHlCQUF5QixNQUFNLGtDQUFrQztBQUV4RSxlQUFlLE1BQU1DLDZCQUE2QixDQUFDO0VBQ2pELE9BQU9DLEdBQUdBLENBQUVDLFVBQVUsRUFBRUMsY0FBYyxFQUFFO0lBQ3RDLE1BQU1DLE1BQU0sR0FBR04sY0FBYyxDQUFDTyxVQUFVLENBQUMsQ0FBQyxDQUFDRCxNQUFNO0lBQ2pELE1BQU1FLGNBQWMsR0FBR1QsSUFBSSxDQUFDSyxVQUFVLENBQUNLLGNBQWMsQ0FBQyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2hFLE1BQU1DLFVBQVUsR0FBR1gsSUFBSSxDQUFDRSx5QkFBeUIsRUFBRU8sY0FBYyxFQUFFSCxjQUFjLEVBQUVDLE1BQU0sRUFBRSxrQkFBa0IsQ0FBQztJQUU5RyxPQUFPSSxVQUFVO0VBQ25CO0FBQ0YiLCJpZ25vcmVMaXN0IjpbXX0=

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,71 @@
+import { useCallback, useLayoutEffect } from "react";
+import config from "./config";
+import { Dimensions } from "react-native";
+import * as inflection from "inflection";
+import isExpo from "./is-expo";
+import useShape from "set-state-compare/src/use-shape";
+const calculateBreakPoint = windowObject => {
+  let windowWidth;
+  if (isExpo) {
+    windowWidth = windowObject.width;
+  } else {
+    // Use 'window.innerWidth' outside Expo because sometimes window width excludes scroll
+    windowWidth = window.innerWidth;
+  }
+  const result = {};
+  for (const breakpointData of config.getBreakPoints()) {
+    const breakpoint = breakpointData[0];
+    const width = breakpointData[1];
+    if (!result.name && windowWidth >= width) {
+      result.name = breakpoint;
+      result[`${breakpoint}Down`] = true;
+    } else {
+      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 sizeTypes = ["down", "up"];
+const useBreakpoint = () => {
+  const s = useShape();
+  const onCalled = useCallback(({
+    window: windowObject
+  }) => {
+    const breakpoint = calculateBreakPoint(windowObject);
+    if (breakpoint.name != s.s.breakpoint.name) {
+      s.set({
+        breakpoint
+      });
+    }
+  }, []);
+  s.useStates({
+    breakpoint: () => calculateBreakPoint(Dimensions.get("window"))
+  });
+  const styling = useCallback(args => {
+    const style = Object.assign({}, args.base);
+    for (const breakpointData of apiMakerConfig.getBreakPoints()) {
+      const breakpoint = breakpointData[0];
+      for (const sizeType of sizeTypes) {
+        const breakpointWithSizeType = `${breakpoint}${inflection.camelize(sizeType)}`;
+        if (args[breakpointWithSizeType] && s.s.breakpoint[breakpointWithSizeType]) {
+          Object.assign(style, args[breakpointWithSizeType]);
+        }
+      }
+    }
+    return style;
+  }, []);
+  useLayoutEffect(() => {
+    const subscription = Dimensions.addEventListener("change", onCalled);
+    return () => subscription?.remove();
+  });
+  return {
+    styling,
+    ...s.s.breakpoint
+  };
+};
+export default useBreakpoint;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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