@kaspernj/api-maker 1.0.2011 → 1.0.2012

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,78 @@
+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 React from "react";
+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,
+    dataSet: PropTypes.object,
+    defaultChecked: PropTypes.bool,
+    label: PropTypes.string,
+    onCheckedChange: PropTypes.func,
+    style: PropTypes.object
+  });
+  setup() {
+    this.useStates({
+      checked: this.props.defaultChecked
+    });
+    this.isChecked = this.calculateChecked();
+  }
+  calculateChecked() {
+    if ("checked" in this.props) {
+      return this.p.checked;
+    } else {
+      return this.s.checked;
+    }
+  }
+  render() {
+    const {
+      isChecked
+    } = this.tt;
+    const {
+      label
+    } = this.p;
+    const {
+      dataSet
+    } = this.props;
+    const actualStyle = Object.assign({
+      flexDirection: "row",
+      alignItems: "center"
+    }, this.props.style);
+    const actualDataSet = Object.assign({
+      checked: isChecked
+    }, dataSet);
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        component: "api-maker/utils/checkbox"
+      },
+      style: actualStyle
+    }, /*#__PURE__*/React.createElement(CheckBox, {
+      dataSet: actualDataSet,
+      onValueChange: this.tt.onValueChange,
+      value: isChecked
+    }), label && /*#__PURE__*/React.createElement(Pressable, {
+      onPress: this.tt.onLabelPressed
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: {
+        marginLeft: 3
+      }
+    }, label)));
+  }
+  onLabelPressed = () => this.p.onCheckedChange(!this.tt.isChecked);
+  onValueChange = e => {
+    if (this.props.onCheckedChange) {
+      this.p.onCheckedChange(e);
+    }
+    this.setState({
+      checked: !this.tt.isChecked
+    });
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/checkboxes.js

@@ -0,0 +1,163 @@
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import React, { useMemo } from "react";
+import Checkbox from "./checkbox";
+import { digs } from "diggerize";
+import { useForm } from "../form";
+import * as inflection from "inflection";
+import InvalidFeedback from "./invalid-feedback";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import Text from "./text";
+import useInput from "../use-input";
+import { View } from "react-native";
+const OptionElement = memo(shapeComponent(class OptionElement extends ShapeComponent {
+  static propTypes = propTypesExact({
+    checked: PropTypes.bool.isRequired,
+    inputName: PropTypes.string.isRequired,
+    onChange: PropTypes.func.isRequired,
+    option: PropTypes.array.isRequired
+  });
+  render() {
+    const {
+      checked,
+      inputName,
+      option
+    } = this.p;
+    return /*#__PURE__*/React.createElement(View, null, /*#__PURE__*/React.createElement(Checkbox, {
+      checked: checked,
+      dataSet: {
+        component: "api-maker/utils/checkboxes/option",
+        name: inputName,
+        value: option[1]
+      },
+      label: option[0],
+      onCheckedChange: this.tt.onChange
+    }));
+  }
+  onChange = checked => this.p.onChange({
+    checked,
+    option: this.p.option
+  });
+}));
+export default memo(shapeComponent(class ApiMakerUtilsCheckboxes extends ShapeComponent {
+  static propTypes = propTypesExact({
+    attribute: PropTypes.string,
+    defaultValue: PropTypes.array,
+    label: PropTypes.string,
+    labelClassName: PropTypes.string,
+    model: PropTypes.object,
+    name: PropTypes.string,
+    onChange: PropTypes.func,
+    options: PropTypes.array.isRequired
+  });
+  setup() {
+    const {
+      inputProps,
+      wrapperOpts
+    } = useInput({
+      props: this.props
+    });
+    this.generatedId = useMemo(() => Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15), []);
+    this.setInstance({
+      form: useForm(),
+      inputProps,
+      wrapperOpts
+    });
+    this.useStates({
+      checkedOptions: () => {
+        if (Array.isArray(this.props.defaultValue)) return this.props.defaultValue;
+        if (this.props.defaultValue) return [this.props.defaultValue];
+        return [];
+      }
+    });
+    useMemo(() => {
+      if (this.form && inputProps.name) {
+        this.form.setValue(inputProps.name, this.s.checkedOptions);
+      }
+    }, []);
+  }
+  render() {
+    const {
+      wrapperOpts
+    } = this.tt;
+    const {
+      errors
+    } = digs(wrapperOpts, "errors");
+    return /*#__PURE__*/React.createElement(View, {
+      dataSet: {
+        component: "api-maker/utils/checkboxes"
+      }
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: {
+        fontWeight: "bold"
+      }
+    }, this.tt.wrapperOpts.label), this.props.options.map(option => /*#__PURE__*/React.createElement(OptionElement, {
+      checked: this.isChecked(option),
+      inputName: this.inputName(),
+      key: option[1],
+      onChange: this.tt.onOptionChecked,
+      option: option
+    })), errors.length > 0 && /*#__PURE__*/React.createElement(InvalidFeedback, {
+      errors: errors
+    }));
+  }
+  inputDefaultValue() {
+    const {
+      attribute,
+      defaultValue,
+      model
+    } = this.props;
+    if (defaultValue) {
+      return defaultValue;
+    } else if (attribute && model) {
+      if (!model[attribute]) throw `No such attribute: ${attribute}`;
+      return this.props.model[attribute]();
+    }
+  }
+  inputName() {
+    if (this.props.name) {
+      return `${this.props.name}[]`;
+    } else if (this.props.model) {
+      return `${this.props.model.modelClassData().paramKey}[${inflection.underscore(this.props.attribute)}]`;
+    }
+  }
+  isChecked = option => this.s.checkedOptions.includes(option[1]);
+  onOptionChecked = ({
+    checked,
+    option
+  }) => {
+    const {
+      inputProps,
+      form
+    } = this.tt;
+    const {
+      name
+    } = inputProps;
+    let newOptions;
+    if (checked) {
+      newOptions = this.s.checkedOptions.concat([option[1]]);
+      this.setState({
+        checkedOptions: newOptions
+      });
+    } else {
+      newOptions = this.s.checkedOptions.filter(value => value != option[1]);
+      this.setState({
+        checkedOptions: newOptions
+      });
+    }
+    console.log({
+      checkedOptions: this.s.checkedOptions
+    });
+    if (this.props.onChange) {
+      this.p.onChange({
+        checked,
+        option
+      });
+    }
+    if (form && name) {
+      form.setValue(name, newOptions);
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shapeComponent","ShapeComponent","React","useMemo","Checkbox","digs","useForm","inflection","InvalidFeedback","memo","PropTypes","propTypesExact","Text","useInput","View","OptionElement","propTypes","checked","bool","isRequired","inputName","string","onChange","func","option","array","render","p","createElement","dataSet","component","name","value","label","onCheckedChange","tt","ApiMakerUtilsCheckboxes","attribute","defaultValue","labelClassName","model","object","options","setup","inputProps","wrapperOpts","props","generatedId","Math","random","toString","substring","setInstance","form","useStates","checkedOptions","Array","isArray","setValue","s","errors","style","fontWeight","map","isChecked","key","onOptionChecked","length","inputDefaultValue","modelClassData","paramKey","underscore","includes","newOptions","concat","setState","filter","console","log"],"sources":["../../src/utils/checkboxes.jsx"],"sourcesContent":["import {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport React, {useMemo} from \"react\"\nimport Checkbox from \"./checkbox\"\nimport {digs} from \"diggerize\"\nimport {useForm} from \"../form\"\nimport * as inflection from \"inflection\"\nimport InvalidFeedback from \"./invalid-feedback\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport Text from \"./text\"\nimport useInput from \"../use-input\"\nimport {View} from \"react-native\"\n\nconst OptionElement = memo(shapeComponent(class OptionElement extends ShapeComponent {\n  static propTypes = propTypesExact({\n    checked: PropTypes.bool.isRequired,\n    inputName: PropTypes.string.isRequired,\n    onChange: PropTypes.func.isRequired,\n    option: PropTypes.array.isRequired\n  })\n\n  render() {\n    const {checked, inputName, option} = this.p\n\n    return (\n      <View >\n        <Checkbox\n          checked={checked}\n          dataSet={{\n            component: \"api-maker/utils/checkboxes/option\",\n            name: inputName,\n            value: option[1]\n          }}\n          label={option[0]}\n          onCheckedChange={this.tt.onChange}\n        />\n      </View>\n    )\n  }\n\n  onChange = (checked) => this.p.onChange({checked, option: this.p.option})\n}))\n\nexport default memo(shapeComponent(class ApiMakerUtilsCheckboxes extends ShapeComponent {\n  static propTypes = propTypesExact({\n    attribute: PropTypes.string,\n    defaultValue: PropTypes.array,\n    label: PropTypes.string,\n    labelClassName: PropTypes.string,\n    model: PropTypes.object,\n    name: PropTypes.string,\n    onChange: PropTypes.func,\n    options: PropTypes.array.isRequired\n  })\n\n  setup() {\n    const {inputProps, wrapperOpts} = useInput({props: this.props})\n\n    this.generatedId = useMemo(\n      () => Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),\n      []\n    )\n\n    this.setInstance({\n      form: useForm(),\n      inputProps,\n      wrapperOpts\n    })\n    this.useStates({\n      checkedOptions: () => {\n        if (Array.isArray(this.props.defaultValue)) return this.props.defaultValue\n        if (this.props.defaultValue) return [this.props.defaultValue]\n\n        return []\n      }\n    })\n\n    useMemo(() => {\n      if (this.form && inputProps.name) {\n        this.form.setValue(inputProps.name, this.s.checkedOptions)\n      }\n    }, [])\n  }\n\n  render () {\n    const {wrapperOpts} = this.tt\n    const {errors} = digs(wrapperOpts, \"errors\")\n\n    return (\n      <View dataSet={{component: \"api-maker/utils/checkboxes\"}}>\n        <Text style={{fontWeight: \"bold\"}}>\n          {this.tt.wrapperOpts.label}\n        </Text>\n        {this.props.options.map((option) =>\n          <OptionElement\n            checked={this.isChecked(option)}\n            inputName={this.inputName()}\n            key={option[1]}\n            onChange={this.tt.onOptionChecked}\n            option={option}\n          />\n        )}\n        {errors.length > 0 &&\n          <InvalidFeedback errors={errors} />\n        }\n      </View>\n    )\n  }\n\n  inputDefaultValue () {\n    const {attribute, defaultValue, model} = this.props\n\n    if (defaultValue) {\n      return defaultValue\n    } else if (attribute && model) {\n      if (!model[attribute]) throw `No such attribute: ${attribute}`\n\n      return this.props.model[attribute]()\n    }\n  }\n\n  inputName () {\n    if (this.props.name) {\n      return `${this.props.name}[]`\n    } else if (this.props.model) {\n      return `${this.props.model.modelClassData().paramKey}[${inflection.underscore(this.props.attribute)}]`\n    }\n  }\n\n  isChecked = (option) => this.s.checkedOptions.includes(option[1])\n\n  onOptionChecked = ({checked, option}) => {\n    const {inputProps, form} = this.tt\n    const {name} = inputProps\n    let newOptions\n\n    if (checked) {\n      newOptions = this.s.checkedOptions.concat([option[1]])\n\n      this.setState({checkedOptions: newOptions})\n    } else {\n      newOptions = this.s.checkedOptions.filter((value) => value != option[1])\n\n      this.setState({checkedOptions: newOptions})\n    }\n\n    console.log({checkedOptions: this.s.checkedOptions})\n\n    if (this.props.onChange) {\n      this.p.onChange({checked, option})\n    }\n\n    if (form && name) {\n      form.setValue(name, newOptions)\n    }\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/utils/default-style.js

@@ -0,0 +1,18 @@
+import React, { 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/icon.js

@@ -0,0 +1,23 @@
+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 BaseComponent from "../base-component";
+import FontAwesomeIcon from "react-native-vector-icons/FontAwesome";
+import memo from "set-state-compare/src/memo";
+import React from "react";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+import { useDefaultStyle } from "./default-style";
+export default memo(shapeComponent(class ApiMakerUtilsIcon extends BaseComponent {
+  render() {
+    const defaultStyle = useDefaultStyle();
+    const {
+      style,
+      ...restProps
+    } = this.props;
+    const actualStyle = Object.assign({
+      color: defaultStyle.Text.color
+    }, style);
+    return /*#__PURE__*/React.createElement(FontAwesomeIcon, _extends({
+      style: actualStyle
+    }, restProps));
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/utils/invalid-feedback.js

@@ -0,0 +1,19 @@
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+import Text from "./text";
+export default memo(shapeComponent(class ApiMakerUtilsInvalidFeedback extends ShapeComponent {
+  static propTypes = propTypesExact({
+    message: PropTypes.string.isRequired
+  });
+  render() {
+    return /*#__PURE__*/React.createElement(Text, {
+      style: {
+        color: "red"
+      }
+    }, this.p.message);
+  }
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzaGFwZUNvbXBvbmVudCIsIlNoYXBlQ29tcG9uZW50IiwibWVtbyIsIlByb3BUeXBlcyIsInByb3BUeXBlc0V4YWN0IiwiUmVhY3QiLCJUZXh0IiwiQXBpTWFrZXJVdGlsc0ludmFsaWRGZWVkYmFjayIsInByb3BUeXBlcyIsIm1lc3NhZ2UiLCJzdHJpbmciLCJpc1JlcXVpcmVkIiwicmVuZGVyIiwiY3JlYXRlRWxlbWVudCIsInN0eWxlIiwiY29sb3IiLCJwIl0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2ludmFsaWQtZmVlZGJhY2suanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7c2hhcGVDb21wb25lbnQsIFNoYXBlQ29tcG9uZW50fSBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL3NoYXBlLWNvbXBvbmVudFwiXG5pbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL21lbW9cIlxuaW1wb3J0IFByb3BUeXBlcyBmcm9tIFwicHJvcC10eXBlc1wiXG5pbXBvcnQgcHJvcFR5cGVzRXhhY3QgZnJvbSBcInByb3AtdHlwZXMtZXhhY3RcIlxuaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiXG5pbXBvcnQgVGV4dCBmcm9tIFwiLi90ZXh0XCJcblxuZXhwb3J0IGRlZmF1bHQgbWVtbyhzaGFwZUNvbXBvbmVudChjbGFzcyBBcGlNYWtlclV0aWxzSW52YWxpZEZlZWRiYWNrIGV4dGVuZHMgU2hhcGVDb21wb25lbnQge1xuICBzdGF0aWMgcHJvcFR5cGVzID0gcHJvcFR5cGVzRXhhY3Qoe1xuICAgIG1lc3NhZ2U6IFByb3BUeXBlcy5zdHJpbmcuaXNSZXF1aXJlZFxuICB9KVxuXG4gIHJlbmRlcigpIHtcbiAgICByZXR1cm4gKFxuICAgICAgPFRleHQgc3R5bGU9e3tjb2xvcjogXCJyZWRcIn19PlxuICAgICAgICB7dGhpcy5wLm1lc3NhZ2V9XG4gICAgICA8L1RleHQ+XG4gICAgKVxuICB9XG59KSlcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUUEsY0FBYyxFQUFFQyxjQUFjLFFBQU8sdUNBQXVDO0FBQ3BGLE9BQU9DLElBQUksTUFBTSw0QkFBNEI7QUFDN0MsT0FBT0MsU0FBUyxNQUFNLFlBQVk7QUFDbEMsT0FBT0MsY0FBYyxNQUFNLGtCQUFrQjtBQUM3QyxPQUFPQyxLQUFLLE1BQU0sT0FBTztBQUN6QixPQUFPQyxJQUFJLE1BQU0sUUFBUTtBQUV6QixlQUFlSixJQUFJLENBQUNGLGNBQWMsQ0FBQyxNQUFNTyw0QkFBNEIsU0FBU04sY0FBYyxDQUFDO0VBQzNGLE9BQU9PLFNBQVMsR0FBR0osY0FBYyxDQUFDO0lBQ2hDSyxPQUFPLEVBQUVOLFNBQVMsQ0FBQ08sTUFBTSxDQUFDQztFQUM1QixDQUFDLENBQUM7RUFFRkMsTUFBTUEsQ0FBQSxFQUFHO0lBQ1Asb0JBQ0VQLEtBQUEsQ0FBQVEsYUFBQSxDQUFDUCxJQUFJO01BQUNRLEtBQUssRUFBRTtRQUFDQyxLQUFLLEVBQUU7TUFBSztJQUFFLEdBQ3pCLElBQUksQ0FBQ0MsQ0FBQyxDQUFDUCxPQUNKLENBQUM7RUFFWDtBQUNGLENBQUMsQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/build/utils/modal.js

@@ -0,0 +1,62 @@
+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 Icon from "../utils/icon";
+import memo from "set-state-compare/src/memo";
+import React from "react";
+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(Icon, {
+      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,19 @@
+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 React from "react";
+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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJtZW1vIiwiUmVhY3QiLCJUZXh0IiwidXNlRGVmYXVsdFN0eWxlIiwiV2l0aERlZmF1bHRTdHlsZSIsInByb3BzIiwic3R5bGUiLCJyZXN0UHJvcHMiLCJkZWZhdWx0U3R5bGUiLCJhY3R1YWxTdHlsZSIsIk9iamVjdCIsImFzc2lnbiIsImNyZWF0ZUVsZW1lbnQiLCJfZXh0ZW5kcyJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy90ZXh0LmpzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvc3JjL21lbW9cIlxuaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiXG5pbXBvcnQge1RleHR9IGZyb20gXCJyZWFjdC1uYXRpdmVcIlxuaW1wb3J0IHt1c2VEZWZhdWx0U3R5bGUsIFdpdGhEZWZhdWx0U3R5bGV9IGZyb20gXCIuL2RlZmF1bHQtc3R5bGVcIlxuXG5leHBvcnQgZGVmYXVsdCBtZW1vKChwcm9wcykgPT4ge1xuICBjb25zdCB7c3R5bGUsIC4uLnJlc3RQcm9wc30gPSBwcm9wc1xuICBjb25zdCBkZWZhdWx0U3R5bGUgPSB1c2VEZWZhdWx0U3R5bGUoKVxuICBjb25zdCBhY3R1YWxTdHlsZSA9IE9iamVjdC5hc3NpZ24oe30sIGRlZmF1bHRTdHlsZT8uVGV4dCwgc3R5bGUpXG5cbiAgcmV0dXJuIChcbiAgICA8V2l0aERlZmF1bHRTdHlsZSBzdHlsZT17YWN0dWFsU3R5bGV9PlxuICAgICAgPFRleHQgc3R5bGU9e2FjdHVhbFN0eWxlfSB7Li4ucmVzdFByb3BzfSAvPlxuICAgIDwvV2l0aERlZmF1bHRTdHlsZT5cbiAgKVxufSlcbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU9BLElBQUksTUFBTSw0QkFBNEI7QUFDN0MsT0FBT0MsS0FBSyxNQUFNLE9BQU87QUFDekIsU0FBUUMsSUFBSSxRQUFPLGNBQWM7QUFDakMsU0FBUUMsZUFBZSxFQUFFQyxnQkFBZ0IsUUFBTyxpQkFBaUI7QUFFakUsZUFBZUosSUFBSSxDQUFFSyxLQUFLLElBQUs7RUFDN0IsTUFBTTtJQUFDQyxLQUFLO0lBQUUsR0FBR0M7RUFBUyxDQUFDLEdBQUdGLEtBQUs7RUFDbkMsTUFBTUcsWUFBWSxHQUFHTCxlQUFlLENBQUMsQ0FBQztFQUN0QyxNQUFNTSxXQUFXLEdBQUdDLE1BQU0sQ0FBQ0MsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFSCxZQUFZLEVBQUVOLElBQUksRUFBRUksS0FBSyxDQUFDO0VBRWhFLG9CQUNFTCxLQUFBLENBQUFXLGFBQUEsQ0FBQ1IsZ0JBQWdCO0lBQUNFLEtBQUssRUFBRUc7RUFBWSxnQkFDbkNSLEtBQUEsQ0FBQVcsYUFBQSxDQUFDVixJQUFJLEVBQUFXLFFBQUE7SUFBQ1AsS0FBSyxFQUFFRztFQUFZLEdBQUtGLFNBQVMsQ0FBRyxDQUMxQixDQUFDO0FBRXZCLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

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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