@kaspernj/api-maker 1.0.446 → 1.0.447

package/build/use-updated-event.js

@@ -0,0 +1,60 @@
+import { useCallback, useLayoutEffect, useMemo } from "react";
+import debounceFunction from "debounce";
+import ModelEvents from "./model-events";
+import useShape from "set-state-compare/src/use-shape";
+const apiMakerUseUpdatedEvent = (model, onUpdated, props = {}) => {
+  const {
+    active = true,
+    debounce,
+    onConnected,
+    ...restProps
+  } = props;
+  if (Object.keys(restProps).length > 0) {
+    throw new Error(`Unknown props given to useUpdatedEvent: ${Object.keys(restProps).join(", ")}`);
+  }
+  const s = useShape({
+    active,
+    debounce,
+    model,
+    onUpdated
+  });
+  const debounceCallback = useMemo(() => {
+    if (typeof debounce == "number") {
+      return debounceFunction(s.p.onUpdated, debounce);
+    } else {
+      return debounceFunction(s.p.onUpdated);
+    }
+  }, [debounce]);
+  s.updateMeta({
+    debounceCallback
+  });
+  const onUpdatedCallback = useCallback((...args) => {
+    if (!s.p.active) {
+      return;
+    }
+    if (s.p.debounce) {
+      s.m.debounceCallback(...args);
+    } else {
+      s.p.onUpdated(...args);
+    }
+  }, []);
+  useLayoutEffect(() => {
+    let connectUpdated, onConnectedListener;
+    if (model) {
+      connectUpdated = ModelEvents.connectUpdated(model, onUpdatedCallback);
+      if (onConnected) {
+        onConnectedListener = connectUpdated.events.addListener("connected", onConnected);
+      }
+    }
+    return () => {
+      if (onConnectedListener) {
+        connectUpdated.events.removeListener("connected", onConnected);
+      }
+      if (connectUpdated) {
+        connectUpdated.unsubscribe();
+      }
+    };
+  }, [model?.id()]);
+};
+export default apiMakerUseUpdatedEvent;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/use-validation-errors.js

@@ -0,0 +1,30 @@
+import events from "./events";
+import { useCallback } from "react";
+import useEventEmitter from "./use-event-emitter";
+import useShape from "set-state-compare/src/use-shape";
+const useValidationErrors = callback => {
+  const s = useShape({
+    callback
+  });
+  s.useStates({
+    validationErrors: []
+  });
+  const onValidationErrors = useCallback(validationErrors => {
+    const matchedValidationErrors = [];
+    for (const validationError of validationErrors.getValidationErrors()) {
+      if (s.p.callback(validationError)) {
+        validationError.setHandled();
+        matchedValidationErrors.push(validationError);
+      }
+    }
+    s.set({
+      validationErrors: matchedValidationErrors
+    });
+  }, []);
+  useEventEmitter(events, "onValidationErrors", onValidationErrors);
+  return {
+    validationErrors: s.s.validationErrors
+  };
+};
+export default useValidationErrors;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/card.js

@@ -0,0 +1,51 @@
+import BaseComponent from "../base-component";
+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 Text from "./text";
+export default memo(shapeComponent(class ApiMakerUtilsCard extends BaseComponent {
+  static propTypes = propTypesExact({
+    children: PropTypes.node,
+    controls: PropTypes.node,
+    dataSet: PropTypes.object,
+    header: PropTypes.string,
+    style: PropTypes.object
+  });
+  render() {
+    const {
+      children,
+      controls,
+      dataSet,
+      header,
+      style
+    } = this.props;
+    const {
+      component,
+      ...restDataSet
+    } = dataSet || {};
+    const actualDataSet = Object.assign({
+      component: classNames("api-maker/utils/card", component)
+    }, restDataSet);
+    const actualStyle = Object.assign({
+      backgroundColor: "#fff",
+      borderRadius: 15,
+      padding: 30
+    }, style);
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: actualDataSet,
+      style: actualStyle
+    }, controls && /*#__PURE__*/React.createElement(View, {
+      style: {
+        position: "absolute",
+        top: 15,
+        right: 15
+      }
+    }, controls), header && /*#__PURE__*/React.createElement(Text, {
+      style: {
+        fontSize: 24
+      }
+    }, header), children);
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/checkbox.js

@@ -0,0 +1,48 @@
+import BaseComponent from "../base-component";
+import { CheckBox, Pressable, View } from "react-native";
+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 Text from "./text";
+export default memo(shapeComponent(class ApiMakerUtilsCheckbox extends BaseComponent {
+  static defaultProps = {
+    label: undefined
+  };
+  static propTypes = propTypesExact({
+    checked: PropTypes.bool.isRequired,
+    dataSet: PropTypes.object,
+    label: PropTypes.string,
+    onCheckedChange: PropTypes.func.isRequired,
+    style: PropTypes.object
+  });
+  render() {
+    const {
+      checked,
+      label,
+      onCheckedChange
+    } = this.p;
+    const actualStyle = Object.assign({
+      flexDirection: "row",
+      alignItems: "center"
+    }, this.props.style);
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        component: "api-maker--utils--checkbox"
+      },
+      style: actualStyle
+    }, /*#__PURE__*/React.createElement(CheckBox, {
+      dataSet: this.props.dataSet,
+      onValueChange: onCheckedChange,
+      value: checked
+    }), label && /*#__PURE__*/React.createElement(Pressable, {
+      onPress: this.tt.onLabelPressed
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: {
+        marginLeft: 3
+      }
+    }, label)));
+  }
+  onLabelPressed = () => this.p.onCheckedChange(!this.p.checked);
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/default-style.js

@@ -0,0 +1,18 @@
+import { createContext, useContext } from "react";
+import memo from "set-state-compare/src/memo";
+const DefaultStyleContext = /*#__PURE__*/createContext({
+  Text: {}
+});
+const useDefaultStyle = () => {
+  const defaultStyle = useContext(DefaultStyleContext);
+  return defaultStyle;
+};
+const WithDefaultStyle = memo(props => {
+  const defaultStyle = useContext(DefaultStyleContext);
+  const newDefaultStyle = Object.assign({}, defaultStyle, props.style);
+  return /*#__PURE__*/React.createElement(DefaultStyleContext.Provider, {
+    value: newDefaultStyle
+  }, props.children);
+});
+export { useDefaultStyle, WithDefaultStyle };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/modal.js

@@ -0,0 +1,61 @@
+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 { Modal, Pressable, View } from "react-native";
+import BaseComponent from "../base-component";
+import Card from "./card";
+import FontAwesomeIcon from "react-native-vector-icons/FontAwesome";
+import memo from "set-state-compare/src/memo";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import useBreakpoint from "../use-breakpoint";
+export default memo(shapeComponent(class ApiMakerUtilsComponent extends BaseComponent {
+  render() {
+    const {
+      xs,
+      sm
+    } = useBreakpoint();
+    const {
+      children,
+      dataSet,
+      ...restProps
+    } = this.props;
+    const actualDataSet = Object.assign({
+      component: "api-maker/utils/modal"
+    }, dataSet);
+    let width, maxWidth;
+    if (xs || sm) {
+      width = "95%";
+    } else {
+      width = "80%";
+      maxWidth = 800;
+    }
+    return /*#__PURE__*/React.createElement(Modal, _extends({
+      dataSet: actualDataSet
+    }, restProps), /*#__PURE__*/React.createElement(View, {
+      style: {
+        alignItems: "center",
+        justifyContent: "center",
+        width: "100%",
+        height: "100%",
+        backgroundColor: "rgba(0, 0, 0, 0.8)"
+      }
+    }, /*#__PURE__*/React.createElement(Card, {
+      controls: this.cardHeaderControls(),
+      style: {
+        width,
+        maxWidth
+      }
+    }, children)));
+  }
+  cardHeaderControls() {
+    return /*#__PURE__*/React.createElement(Pressable, {
+      onPress: this.tt.onModalClosePress,
+      style: {
+        marginLeft: "auto",
+        padding: 5
+      }
+    }, /*#__PURE__*/React.createElement(FontAwesomeIcon, {
+      name: "remove"
+    }));
+  }
+  onModalClosePress = () => this.props.onRequestClose && this.props.onRequestClose();
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/text.js

@@ -0,0 +1,18 @@
+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 memo from "set-state-compare/src/memo";
+import { Text } from "react-native";
+import { useDefaultStyle, WithDefaultStyle } from "./default-style";
+export default memo(props => {
+  const {
+    style,
+    ...restProps
+  } = props;
+  const defaultStyle = useDefaultStyle();
+  const actualStyle = Object.assign({}, defaultStyle?.Text, style);
+  return /*#__PURE__*/React.createElement(WithDefaultStyle, {
+    style: actualStyle
+  }, /*#__PURE__*/React.createElement(Text, _extends({
+    style: actualStyle
+  }, restProps)));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJtZW1vIiwiVGV4dCIsInVzZURlZmF1bHRTdHlsZSIsIldpdGhEZWZhdWx0U3R5bGUiLCJwcm9wcyIsInN0eWxlIiwicmVzdFByb3BzIiwiZGVmYXVsdFN0eWxlIiwiYWN0dWFsU3R5bGUiLCJPYmplY3QiLCJhc3NpZ24iLCJSZWFjdCIsImNyZWF0ZUVsZW1lbnQiLCJfZXh0ZW5kcyJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy90ZXh0LmpzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL21lbW9cIlxuaW1wb3J0IHtUZXh0fSBmcm9tIFwicmVhY3QtbmF0aXZlXCJcbmltcG9ydCB7dXNlRGVmYXVsdFN0eWxlLCBXaXRoRGVmYXVsdFN0eWxlfSBmcm9tIFwiLi9kZWZhdWx0LXN0eWxlXCJcblxuZXhwb3J0IGRlZmF1bHQgbWVtbygocHJvcHMpID0+IHtcbiAgY29uc3Qge3N0eWxlLCAuLi5yZXN0UHJvcHN9ID0gcHJvcHNcbiAgY29uc3QgZGVmYXVsdFN0eWxlID0gdXNlRGVmYXVsdFN0eWxlKClcbiAgY29uc3QgYWN0dWFsU3R5bGUgPSBPYmplY3QuYXNzaWduKHt9LCBkZWZhdWx0U3R5bGU/LlRleHQsIHN0eWxlKVxuXG4gIHJldHVybiAoXG4gICAgPFdpdGhEZWZhdWx0U3R5bGUgc3R5bGU9e2FjdHVhbFN0eWxlfT5cbiAgICAgIDxUZXh0IHN0eWxlPXthY3R1YWxTdHlsZX0gey4uLnJlc3RQcm9wc30gLz5cbiAgICA8L1dpdGhEZWZhdWx0U3R5bGU+XG4gIClcbn0pXG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxJQUFJLE1BQU0sNEJBQTRCO0FBQzdDLFNBQVFDLElBQUksUUFBTyxjQUFjO0FBQ2pDLFNBQVFDLGVBQWUsRUFBRUMsZ0JBQWdCLFFBQU8saUJBQWlCO0FBRWpFLGVBQWVILElBQUksQ0FBRUksS0FBSyxJQUFLO0VBQzdCLE1BQU07SUFBQ0MsS0FBSztJQUFFLEdBQUdDO0VBQVMsQ0FBQyxHQUFHRixLQUFLO0VBQ25DLE1BQU1HLFlBQVksR0FBR0wsZUFBZSxDQUFDLENBQUM7RUFDdEMsTUFBTU0sV0FBVyxHQUFHQyxNQUFNLENBQUNDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRUgsWUFBWSxFQUFFTixJQUFJLEVBQUVJLEtBQUssQ0FBQztFQUVoRSxvQkFDRU0sS0FBQSxDQUFBQyxhQUFBLENBQUNULGdCQUFnQjtJQUFDRSxLQUFLLEVBQUVHO0VBQVksZ0JBQ25DRyxLQUFBLENBQUFDLGFBQUEsQ0FBQ1gsSUFBSSxFQUFBWSxRQUFBO0lBQUNSLEtBQUssRUFBRUc7RUFBWSxHQUFLRixTQUFTLENBQUcsQ0FDMUIsQ0FBQztBQUV2QixDQUFDLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/validation-error.js

@@ -0,0 +1,28 @@
+import BaseError from "./base-error";
+import * as inflection from "inflection";
+class ValidationError extends BaseError {
+  constructor(validationErrors, args) {
+    const errorMessage = validationErrors.getUnhandledErrorMessage() || validationErrors.getErrorMessage();
+    const forwardedArgs = {
+      addResponseErrorsToErrorMessage: false
+    };
+    const newArgs = Object.assign({}, args, forwardedArgs);
+    super(errorMessage, newArgs);
+    this.validationErrors = validationErrors;
+  }
+  getUnhandledErrors = () => this.validationErrors.getValidationErrors().filter(validationError => !validationError.getHandled());
+  getValidationErrors = () => digg(this, "validationErrors");
+  hasUnhandledErrors() {
+    const unhandledError = this.validationErrors.getValidationErrors().find(validationError => !validationError.getHandled());
+    return Boolean(unhandledError);
+  }
+  hasValidationErrorForAttribute(attributeName) {
+    const underscoredAttributeName = inflection.underscore(attributeName);
+    const foundAttribute = this.validationErrors.getValidationErrors().find(validationError => validationError.getAttributeName() == underscoredAttributeName);
+    if (foundAttribute) return true;
+    return false;
+  }
+}
+ValidationError.apiMakerType = "ValidationError";
+export default ValidationError;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/validation-errors.js

@@ -0,0 +1,98 @@
+import { digg, digs } from "diggerize";
+import * as inflection from "inflection";
+import modelClassRequire from "./model-class-require";
+class ValidationError {
+  constructor(args) {
+    this.attributeName = digg(args, "attribute_name");
+    this.attributeType = digg(args, "attribute_type");
+    this.errorMessages = digg(args, "error_messages");
+    this.errorTypes = digg(args, "error_types");
+    this.inputName = args.input_name;
+    this.handled = false;
+    this.modelName = digg(args, "model_name");
+  }
+  matchesAttributeAndInputName(attributeName, inputName) {
+    if (this.getInputName() == inputName) return true;
+    if (!attributeName) return false;
+
+    // A relationship column ends with "_id". We should try for validation errors on an attribute without the "_id" as well
+    const attributeNameIdMatch = attributeName.match(/^(.+)Id$/);
+    if (!attributeNameIdMatch) return false;
+    const attributeNameWithoutId = inflection.underscore(attributeNameIdMatch[1]);
+    const attributeUnderScoreName = inflection.underscore(attributeName);
+    const inputNameWithoutId = inputName.replace(`[${attributeUnderScoreName}]`, `[${attributeNameWithoutId}]`);
+    if (this.getInputName() == inputNameWithoutId) return true;
+    return false;
+  }
+  getAttributeName = () => digg(this, "attributeName");
+  getErrorMessages = () => digg(this, "errorMessages");
+  getFullErrorMessages() {
+    const {
+      attributeType
+    } = digs(this, "attributeType");
+    if (attributeType == "base") {
+      return this.getErrorMessages();
+    } else {
+      const fullErrorMessages = [];
+      for (const errorMessage of this.getErrorMessages()) {
+        const attributeHumanName = this.getModelClass().humanAttributeName(this.getAttributeName());
+        fullErrorMessages.push(`${attributeHumanName} ${errorMessage}`);
+      }
+      return fullErrorMessages;
+    }
+  }
+  getHandled = () => digg(this, "handled");
+  getInputName = () => digg(this, "inputName");
+  getModelClass() {
+    const modelName = inflection.classify(digg(this, "modelName"));
+    return modelClassRequire(modelName);
+  }
+  setHandled() {
+    this.handled = true;
+  }
+}
+class ValidationErrors {
+  constructor(args) {
+    this.rootModel = digg(args, "model");
+    this.validationErrors = digg(args, "validationErrors").map(validationError => new ValidationError(validationError));
+  }
+  getErrorMessage() {
+    const fullErrorMessages = [];
+    for (const validationError of this.validationErrors) {
+      for (const fullErrorMessage of validationError.getFullErrorMessages()) {
+        fullErrorMessages.push(fullErrorMessage);
+      }
+    }
+    return fullErrorMessages.join(". ");
+  }
+  getValidationErrors = () => this.validationErrors;
+  getValidationErrorsForInput({
+    attribute,
+    inputName,
+    onMatchValidationError
+  }) {
+    const validationErrors = this.validationErrors.filter(validationError => {
+      if (onMatchValidationError) {
+        return onMatchValidationError(validationError);
+      } else {
+        return validationError.matchesAttributeAndInputName(attribute, inputName);
+      }
+    });
+    validationErrors.map(validationError => validationError.setHandled());
+    return validationErrors;
+  }
+  getUnhandledErrorMessage() {
+    const unhandledValidationErrors = this.validationErrors.filter(validationError => !validationError.getHandled());
+    if (unhandledValidationErrors.length > 0) {
+      const unhandledValidationErrorMessages = [];
+      for (const unhandledValidationError of unhandledValidationErrors) {
+        for (const errorMessage of unhandledValidationError.getFullErrorMessages()) {
+          unhandledValidationErrorMessages.push(errorMessage);
+        }
+      }
+      return unhandledValidationErrorMessages.join(". ");
+    }
+  }
+}
+export { ValidationError, ValidationErrors };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digg","digs","inflection","modelClassRequire","ValidationError","constructor","args","attributeName","attributeType","errorMessages","errorTypes","inputName","input_name","handled","modelName","matchesAttributeAndInputName","getInputName","attributeNameIdMatch","match","attributeNameWithoutId","underscore","attributeUnderScoreName","inputNameWithoutId","replace","getAttributeName","getErrorMessages","getFullErrorMessages","fullErrorMessages","errorMessage","attributeHumanName","getModelClass","humanAttributeName","push","getHandled","classify","setHandled","ValidationErrors","rootModel","validationErrors","map","validationError","getErrorMessage","fullErrorMessage","join","getValidationErrors","getValidationErrorsForInput","attribute","onMatchValidationError","filter","getUnhandledErrorMessage","unhandledValidationErrors","length","unhandledValidationErrorMessages","unhandledValidationError"],"sources":["../src/validation-errors.js"],"sourcesContent":["import {digg, digs} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport modelClassRequire from \"./model-class-require\"\n\nclass ValidationError {\n  constructor(args) {\n    this.attributeName = digg(args, \"attribute_name\")\n    this.attributeType = digg(args, \"attribute_type\")\n    this.errorMessages = digg(args, \"error_messages\")\n    this.errorTypes = digg(args, \"error_types\")\n    this.inputName = args.input_name\n    this.handled = false\n    this.modelName = digg(args, \"model_name\")\n  }\n\n  matchesAttributeAndInputName(attributeName, inputName) {\n    if (this.getInputName() == inputName) return true\n    if (!attributeName) return false\n\n    // A relationship column ends with \"_id\". We should try for validation errors on an attribute without the \"_id\" as well\n    const attributeNameIdMatch = attributeName.match(/^(.+)Id$/)\n    if (!attributeNameIdMatch) return false\n\n    const attributeNameWithoutId = inflection.underscore(attributeNameIdMatch[1])\n    const attributeUnderScoreName = inflection.underscore(attributeName)\n    const inputNameWithoutId = inputName.replace(`[${attributeUnderScoreName}]`, `[${attributeNameWithoutId}]`)\n\n    if (this.getInputName() == inputNameWithoutId) return true\n\n    return false\n  }\n\n  getAttributeName = () => digg(this, \"attributeName\")\n  getErrorMessages = () => digg(this, \"errorMessages\")\n\n  getFullErrorMessages() {\n    const {attributeType} = digs(this, \"attributeType\")\n\n    if (attributeType == \"base\") {\n      return this.getErrorMessages()\n    } else {\n      const fullErrorMessages = []\n\n      for (const errorMessage of this.getErrorMessages()) {\n        const attributeHumanName = this.getModelClass().humanAttributeName(this.getAttributeName())\n        fullErrorMessages.push(`${attributeHumanName} ${errorMessage}`)\n      }\n\n      return fullErrorMessages\n    }\n  }\n\n  getHandled = () => digg(this, \"handled\")\n  getInputName = () => digg(this, \"inputName\")\n\n  getModelClass() {\n    const modelName = inflection.classify(digg(this, \"modelName\"))\n\n    return modelClassRequire(modelName)\n  }\n\n  setHandled() {\n    this.handled = true\n  }\n}\n\nclass ValidationErrors {\n  constructor(args) {\n    this.rootModel = digg(args, \"model\")\n    this.validationErrors = digg(args, \"validationErrors\").map((validationError) => new ValidationError(validationError))\n  }\n\n  getErrorMessage() {\n    const fullErrorMessages = []\n\n    for (const validationError of this.validationErrors) {\n      for (const fullErrorMessage of validationError.getFullErrorMessages()) {\n        fullErrorMessages.push(fullErrorMessage)\n      }\n    }\n\n    return fullErrorMessages.join(\". \")\n  }\n\n  getValidationErrors = () => this.validationErrors\n\n  getValidationErrorsForInput ({attribute, inputName, onMatchValidationError}) {\n    const validationErrors = this.validationErrors.filter((validationError) => {\n      if (onMatchValidationError) {\n        return onMatchValidationError(validationError)\n      } else {\n        return validationError.matchesAttributeAndInputName(attribute, inputName)\n      }\n    })\n\n    validationErrors.map((validationError) => validationError.setHandled())\n\n    return validationErrors\n  }\n\n  getUnhandledErrorMessage () {\n    const unhandledValidationErrors = this.validationErrors.filter((validationError) => !validationError.getHandled())\n\n    if (unhandledValidationErrors.length > 0) {\n      const unhandledValidationErrorMessages = []\n\n      for (const unhandledValidationError of unhandledValidationErrors) {\n        for (const errorMessage of unhandledValidationError.getFullErrorMessages()) {\n          unhandledValidationErrorMessages.push(errorMessage)\n        }\n      }\n\n      return unhandledValidationErrorMessages.join(\". \")\n    }\n  }\n}\n\nexport {\n  ValidationError,\n  ValidationErrors\n}\n"],"mappings":"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","ignoreList":[]}

package/build/with-collection.js

@@ -0,0 +1,13 @@
+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 { digg } from "diggerize";
+import memo from "set-state-compare/src/memo";
+import useCollection from "./use-collection";
+export default (WrappedComponent, withCollectionArgs) => memo(() => {
+  const useCollectionResult = useCollection(withCollectionArgs);
+  const models = digg(useCollectionResult, "models");
+  const modelsArgName = inflection.camelize(digg(withCollectionArgs.modelClass.modelClassData(), "pluralName"), true);
+  const forwardArgs = {};
+  forwardArgs[modelsArgName] = models;
+  return /*#__PURE__*/React.createElement(WrappedComponent, _extends({}, forwardArgs, this.props));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkaWdnIiwibWVtbyIsInVzZUNvbGxlY3Rpb24iLCJXcmFwcGVkQ29tcG9uZW50Iiwid2l0aENvbGxlY3Rpb25BcmdzIiwidXNlQ29sbGVjdGlvblJlc3VsdCIsIm1vZGVscyIsIm1vZGVsc0FyZ05hbWUiLCJpbmZsZWN0aW9uIiwiY2FtZWxpemUiLCJtb2RlbENsYXNzIiwibW9kZWxDbGFzc0RhdGEiLCJmb3J3YXJkQXJncyIsIlJlYWN0IiwiY3JlYXRlRWxlbWVudCIsIl9leHRlbmRzIiwicHJvcHMiXSwic291cmNlcyI6WyIuLi9zcmMvd2l0aC1jb2xsZWN0aW9uLmpzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2RpZ2d9IGZyb20gXCJkaWdnZXJpemVcIlxuaW1wb3J0IG1lbW8gZnJvbSBcInNldC1zdGF0ZS1jb21wYXJlL3NyYy9tZW1vXCJcbmltcG9ydCB1c2VDb2xsZWN0aW9uIGZyb20gXCIuL3VzZS1jb2xsZWN0aW9uXCJcblxuZXhwb3J0IGRlZmF1bHQgKFdyYXBwZWRDb21wb25lbnQsIHdpdGhDb2xsZWN0aW9uQXJncykgPT4gbWVtbygoKSA9PiB7XG4gIGNvbnN0IHVzZUNvbGxlY3Rpb25SZXN1bHQgPSB1c2VDb2xsZWN0aW9uKHdpdGhDb2xsZWN0aW9uQXJncylcbiAgY29uc3QgbW9kZWxzID0gZGlnZyh1c2VDb2xsZWN0aW9uUmVzdWx0LCBcIm1vZGVsc1wiKVxuICBjb25zdCBtb2RlbHNBcmdOYW1lID0gaW5mbGVjdGlvbi5jYW1lbGl6ZShkaWdnKHdpdGhDb2xsZWN0aW9uQXJncy5tb2RlbENsYXNzLm1vZGVsQ2xhc3NEYXRhKCksIFwicGx1cmFsTmFtZVwiKSwgdHJ1ZSlcbiAgY29uc3QgZm9yd2FyZEFyZ3MgPSB7fVxuXG4gIGZvcndhcmRBcmdzW21vZGVsc0FyZ05hbWVdID0gbW9kZWxzXG5cbiAgcmV0dXJuIChcbiAgICA8V3JhcHBlZENvbXBvbmVudCB7Li4uZm9yd2FyZEFyZ3N9IHsuLi50aGlzLnByb3BzfSAvPlxuICApXG59KVxuIl0sIm1hcHBpbmdzIjoiO0FBQUEsU0FBUUEsSUFBSSxRQUFPLFdBQVc7QUFDOUIsT0FBT0MsSUFBSSxNQUFNLDRCQUE0QjtBQUM3QyxPQUFPQyxhQUFhLE1BQU0sa0JBQWtCO0FBRTVDLGVBQWUsQ0FBQ0MsZ0JBQWdCLEVBQUVDLGtCQUFrQixLQUFLSCxJQUFJLENBQUMsTUFBTTtFQUNsRSxNQUFNSSxtQkFBbUIsR0FBR0gsYUFBYSxDQUFDRSxrQkFBa0IsQ0FBQztFQUM3RCxNQUFNRSxNQUFNLEdBQUdOLElBQUksQ0FBQ0ssbUJBQW1CLEVBQUUsUUFBUSxDQUFDO0VBQ2xELE1BQU1FLGFBQWEsR0FBR0MsVUFBVSxDQUFDQyxRQUFRLENBQUNULElBQUksQ0FBQ0ksa0JBQWtCLENBQUNNLFVBQVUsQ0FBQ0MsY0FBYyxDQUFDLENBQUMsRUFBRSxZQUFZLENBQUMsRUFBRSxJQUFJLENBQUM7RUFDbkgsTUFBTUMsV0FBVyxHQUFHLENBQUMsQ0FBQztFQUV0QkEsV0FBVyxDQUFDTCxhQUFhLENBQUMsR0FBR0QsTUFBTTtFQUVuQyxvQkFDRU8sS0FBQSxDQUFBQyxhQUFBLENBQUNYLGdCQUFnQixFQUFBWSxRQUFBLEtBQUtILFdBQVcsRUFBTSxJQUFJLENBQUNJLEtBQUssQ0FBRyxDQUFDO0FBRXpELENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/build/with-current-user.js

@@ -0,0 +1,9 @@
+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 useCurrentUser from "./use-current-user";
+export default WrappedComponent => props => {
+  const currentUser = useCurrentUser();
+  return /*#__PURE__*/React.createElement(WrappedComponent, _extends({}, props, {
+    currentUser: currentUser
+  }));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VDdXJyZW50VXNlciIsIldyYXBwZWRDb21wb25lbnQiLCJwcm9wcyIsImN1cnJlbnRVc2VyIiwiUmVhY3QiLCJjcmVhdGVFbGVtZW50IiwiX2V4dGVuZHMiXSwic291cmNlcyI6WyIuLi9zcmMvd2l0aC1jdXJyZW50LXVzZXIuanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB1c2VDdXJyZW50VXNlciBmcm9tIFwiLi91c2UtY3VycmVudC11c2VyXCJcblxuZXhwb3J0IGRlZmF1bHQgKFdyYXBwZWRDb21wb25lbnQpID0+IChwcm9wcykgPT4ge1xuICBjb25zdCBjdXJyZW50VXNlciA9IHVzZUN1cnJlbnRVc2VyKClcblxuICByZXR1cm4gKFxuICAgIDxXcmFwcGVkQ29tcG9uZW50IHsuLi5wcm9wc30gY3VycmVudFVzZXI9e2N1cnJlbnRVc2VyfSAvPlxuICApXG59XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPQSxjQUFjLE1BQU0sb0JBQW9CO0FBRS9DLGVBQWdCQyxnQkFBZ0IsSUFBTUMsS0FBSyxJQUFLO0VBQzlDLE1BQU1DLFdBQVcsR0FBR0gsY0FBYyxDQUFDLENBQUM7RUFFcEMsb0JBQ0VJLEtBQUEsQ0FBQUMsYUFBQSxDQUFDSixnQkFBZ0IsRUFBQUssUUFBQSxLQUFLSixLQUFLO0lBQUVDLFdBQVcsRUFBRUE7RUFBWSxFQUFFLENBQUM7QUFFN0QsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/build/with-model.js

@@ -0,0 +1,14 @@
+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 memo from "set-state-compare/src/memo";
+import useModel from "./use-model";
+export default (WrappedComponent, modelClass, givenArgs) => {
+  const ApiMakerWithModel = props => {
+    const args = Object.assign({
+      match: props.match
+    }, givenArgs);
+    const useModelResult = useModel(modelClass, args);
+    return /*#__PURE__*/React.createElement(WrappedComponent, _extends({}, useModelResult, props));
+  };
+  return memo(ApiMakerWithModel);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJtZW1vIiwidXNlTW9kZWwiLCJXcmFwcGVkQ29tcG9uZW50IiwibW9kZWxDbGFzcyIsImdpdmVuQXJncyIsIkFwaU1ha2VyV2l0aE1vZGVsIiwicHJvcHMiLCJhcmdzIiwiT2JqZWN0IiwiYXNzaWduIiwibWF0Y2giLCJ1c2VNb2RlbFJlc3VsdCIsIlJlYWN0IiwiY3JlYXRlRWxlbWVudCIsIl9leHRlbmRzIl0sInNvdXJjZXMiOlsiLi4vc3JjL3dpdGgtbW9kZWwuanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBtZW1vIGZyb20gXCJzZXQtc3RhdGUtY29tcGFyZS9zcmMvbWVtb1wiXG5pbXBvcnQgdXNlTW9kZWwgZnJvbSBcIi4vdXNlLW1vZGVsXCJcblxuZXhwb3J0IGRlZmF1bHQgKFdyYXBwZWRDb21wb25lbnQsIG1vZGVsQ2xhc3MsIGdpdmVuQXJncykgPT4ge1xuICBjb25zdCBBcGlNYWtlcldpdGhNb2RlbCA9IChwcm9wcykgPT4ge1xuICAgIGNvbnN0IGFyZ3MgPSBPYmplY3QuYXNzaWduKHttYXRjaDogcHJvcHMubWF0Y2h9LCBnaXZlbkFyZ3MpXG4gICAgY29uc3QgdXNlTW9kZWxSZXN1bHQgPSB1c2VNb2RlbChtb2RlbENsYXNzLCBhcmdzKVxuXG4gICAgcmV0dXJuIChcbiAgICAgIDxXcmFwcGVkQ29tcG9uZW50IHsuLi51c2VNb2RlbFJlc3VsdH0gey4uLnByb3BzfSAvPlxuICAgIClcbiAgfVxuXG4gIHJldHVybiBtZW1vKEFwaU1ha2VyV2l0aE1vZGVsKVxufVxuIl0sIm1hcHBpbmdzIjoiO0FBQUEsT0FBT0EsSUFBSSxNQUFNLDRCQUE0QjtBQUM3QyxPQUFPQyxRQUFRLE1BQU0sYUFBYTtBQUVsQyxlQUFlLENBQUNDLGdCQUFnQixFQUFFQyxVQUFVLEVBQUVDLFNBQVMsS0FBSztFQUMxRCxNQUFNQyxpQkFBaUIsR0FBSUMsS0FBSyxJQUFLO0lBQ25DLE1BQU1DLElBQUksR0FBR0MsTUFBTSxDQUFDQyxNQUFNLENBQUM7TUFBQ0MsS0FBSyxFQUFFSixLQUFLLENBQUNJO0lBQUssQ0FBQyxFQUFFTixTQUFTLENBQUM7SUFDM0QsTUFBTU8sY0FBYyxHQUFHVixRQUFRLENBQUNFLFVBQVUsRUFBRUksSUFBSSxDQUFDO0lBRWpELG9CQUNFSyxLQUFBLENBQUFDLGFBQUEsQ0FBQ1gsZ0JBQWdCLEVBQUFZLFFBQUEsS0FBS0gsY0FBYyxFQUFNTCxLQUFLLENBQUcsQ0FBQztFQUV2RCxDQUFDO0VBRUQsT0FBT04sSUFBSSxDQUFDSyxpQkFBaUIsQ0FBQztBQUNoQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/build/with-router.js

@@ -0,0 +1,21 @@
+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 useRouter from "./use-router";
+export default WrapperComponent => props => {
+  const {
+    path,
+    routes,
+    routeDefinitions,
+    ...restProps
+  } = props;
+  const {
+    match
+  } = useRouter({
+    path,
+    routes,
+    routeDefinitions
+  });
+  return /*#__PURE__*/React.createElement(WrapperComponent, _extends({
+    match: match
+  }, restProps));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VSb3V0ZXIiLCJXcmFwcGVyQ29tcG9uZW50IiwicHJvcHMiLCJwYXRoIiwicm91dGVzIiwicm91dGVEZWZpbml0aW9ucyIsInJlc3RQcm9wcyIsIm1hdGNoIiwiUmVhY3QiLCJjcmVhdGVFbGVtZW50IiwiX2V4dGVuZHMiXSwic291cmNlcyI6WyIuLi9zcmMvd2l0aC1yb3V0ZXIuanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB1c2VSb3V0ZXIgZnJvbSBcIi4vdXNlLXJvdXRlclwiXG5cbmV4cG9ydCBkZWZhdWx0IChXcmFwcGVyQ29tcG9uZW50KSA9PiAocHJvcHMpID0+IHtcbiAgY29uc3Qge3BhdGgsIHJvdXRlcywgcm91dGVEZWZpbml0aW9ucywgLi4ucmVzdFByb3BzfSA9IHByb3BzXG4gIGNvbnN0IHttYXRjaH0gPSB1c2VSb3V0ZXIoe3BhdGgsIHJvdXRlcywgcm91dGVEZWZpbml0aW9uc30pXG5cbiAgcmV0dXJuIChcbiAgICA8V3JhcHBlckNvbXBvbmVudCBtYXRjaD17bWF0Y2h9IHsuLi5yZXN0UHJvcHN9IC8+XG4gIClcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU9BLFNBQVMsTUFBTSxjQUFjO0FBRXBDLGVBQWdCQyxnQkFBZ0IsSUFBTUMsS0FBSyxJQUFLO0VBQzlDLE1BQU07SUFBQ0MsSUFBSTtJQUFFQyxNQUFNO0lBQUVDLGdCQUFnQjtJQUFFLEdBQUdDO0VBQVMsQ0FBQyxHQUFHSixLQUFLO0VBQzVELE1BQU07SUFBQ0s7RUFBSyxDQUFDLEdBQUdQLFNBQVMsQ0FBQztJQUFDRyxJQUFJO0lBQUVDLE1BQU07SUFBRUM7RUFBZ0IsQ0FBQyxDQUFDO0VBRTNELG9CQUNFRyxLQUFBLENBQUFDLGFBQUEsQ0FBQ1IsZ0JBQWdCLEVBQUFTLFFBQUE7SUFBQ0gsS0FBSyxFQUFFQTtFQUFNLEdBQUtELFNBQVMsQ0FBRyxDQUFDO0FBRXJELENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/expo-module.config.json

@@ -0,0 +1,17 @@
+{
+  "platforms": [
+    "apple",
+    "android",
+    "web"
+  ],
+  "apple": {
+    "modules": [
+      "ApiMakerModule"
+    ]
+  },
+  "android": {
+    "modules": [
+      "expo.modules.api_maker.ApiMakerModule"
+    ]
+  }
+}

package/ios/ApiMaker.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ApiMaker'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/kaspernj/api_maker' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end