@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/build/draggable-sort/item.js

@@ -0,0 +1,188 @@
+import React, { useMemo } from "react";
+import { Animated, Easing, PanResponder } from "react-native";
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import EventEmitter from "events";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import useEventEmitter from "../use-event-emitter";
+export default memo(shapeComponent(class DraggableSortItem extends ShapeComponent {
+  static propTypes = propTypesExact({
+    cacheKey: PropTypes.string,
+    controller: PropTypes.object.isRequired,
+    item: PropTypes.any.isRequired,
+    itemIndex: PropTypes.number.isRequired,
+    onItemMoved: PropTypes.func,
+    renderItem: PropTypes.func.isRequired
+  });
+  initialLayout = null;
+  setup() {
+    this.useStates({
+      active: false,
+      dragging: false
+    });
+    this.events = useMemo(() => new EventEmitter(), []);
+    this.position = useMemo(() => new Animated.ValueXY(), []);
+    this.panResponder = useMemo(() => PanResponder.create({
+      onStartShouldSetPanResponder: e => {
+        this.setState({
+          dragging: true
+        });
+        this.p.controller.onDragStart({
+          item: this.p.item,
+          itemIndex: this.p.itemIndex
+        });
+        return false;
+      }
+    }), []);
+    useEventEmitter(this.p.controller.getEvents(), "onDragStart", this.tt.onDragStart);
+    useEventEmitter(this.p.controller.getEvents(), "onDragEndAnimation", this.tt.onDragEndAnimation);
+    useEventEmitter(this.tt.events, "move", this.tt.onMove);
+    useEventEmitter(this.tt.events, "moveToPosition", this.tt.onMoveToPosition);
+    useEventEmitter(this.tt.events, "resetPosition", this.tt.onResetPosition);
+  }
+  render() {
+    const {
+      item,
+      renderItem
+    } = this.p;
+    const {
+      active
+    } = this.s;
+    const style = useMemo(() => {
+      const style = {
+        transform: this.tt.position.getTranslateTransform()
+      };
+      if (active) {
+        style.backgroundColor = "#fff";
+        style.elevation = 2;
+        style.zIndex = 99999;
+      }
+      return style;
+    }, [active]);
+    return /*#__PURE__*/React.createElement(Animated.View, {
+      dataSet: {
+        component: "draggable-sort/item"
+      },
+      onLayout: this.tt.onLayout,
+      style: style
+    }, renderItem({
+      isActive: active,
+      item,
+      touchProps: this.tt.panResponder.panHandlers
+    }));
+  }
+  onDragStart = ({
+    itemData
+  }) => {
+    const newState = {
+      dragging: true
+    };
+    if (itemData.index == this.p.itemIndex) {
+      newState.active = true;
+      this.baseXAtStartedDragging = this.getBaseX();
+    }
+    this.setState(newState);
+  };
+  onDragEndAnimation = () => this.setState({
+    active: false,
+    dragging: false
+  });
+  onLayout = e => {
+    const {
+      controller,
+      item,
+      itemIndex
+    } = this.p;
+    controller.onItemLayout({
+      events: this.tt.events,
+      index: itemIndex,
+      item,
+      layout: e.nativeEvent.layout
+    });
+    if (!this.tt.initialLayout) {
+      this.initialLayout = e.nativeEvent.layout;
+    }
+  };
+  onMove = ({
+    gestate
+  }) => {
+    const x = gestate.dx + this.tt.baseXAtStartedDragging - this.tt.initialLayout.x;
+    const y = this.tt.initialLayout.y;
+    this.tt.position.setValue({
+      x,
+      y
+    });
+    if (this.props.onItemMoved) {
+      this.p.onItemMoved({
+        itemIndex: this.p.itemIndex,
+        x,
+        y
+      });
+    }
+  };
+  onMoveToPosition = ({
+    x,
+    y
+  }) => {
+    const calculatedXFromStartingPosition = x - this.tt.initialLayout.x;
+    const animationArgs = {
+      duration: 200,
+      easing: Easing.inOut(Easing.linear),
+      toValue: {
+        x: calculatedXFromStartingPosition,
+        y
+      },
+      useNativeDriver: true
+    };
+    const animationEventArgs = {
+      animationArgs,
+      animationType: "moveToPosition",
+      item: this.p.item
+    };
+    this.p.controller.events.emit("onAnimationStart", animationEventArgs);
+    Animated.timing(this.tt.position, animationArgs).start(() => {
+      this.p.controller.events.emit("onAnimationEnd", animationEventArgs);
+    });
+    if (this.props.onItemMoved) {
+      this.p.onItemMoved({
+        animationArgs,
+        itemIndex: this.p.itemIndex,
+        x: calculatedXFromStartingPosition,
+        y
+      });
+    }
+  };
+  getBaseX = () => this.p.controller.getItemDataForIndex(this.p.itemIndex).baseX;
+  onResetPosition = args => {
+    const baseX = this.getBaseX() - this.tt.initialLayout.x;
+    const animationArgs = {
+      duration: 200,
+      easing: Easing.inOut(Easing.linear),
+      toValue: {
+        x: baseX,
+        y: 0
+      },
+      useNativeDriver: true
+    };
+    const animationEventArgs = {
+      animationArgs,
+      animationType: "resetPosition",
+      item: this.p.item
+    };
+    this.p.controller.events.emit("onAnimationStart", animationEventArgs);
+    Animated.timing(this.tt.position, animationArgs).start(() => {
+      this.p.controller.events.emit("onAnimationEnd", animationEventArgs);
+      if (args?.callback) args.callback();
+    });
+    if (this.props.onItemMoved) {
+      this.p.onItemMoved({
+        animationArgs,
+        itemIndex: this.p.itemIndex,
+        x: baseX,
+        y: 0
+      });
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","Animated","Easing","PanResponder","shapeComponent","ShapeComponent","EventEmitter","memo","PropTypes","propTypesExact","useEventEmitter","DraggableSortItem","propTypes","cacheKey","string","controller","object","isRequired","item","any","itemIndex","number","onItemMoved","func","renderItem","initialLayout","setup","useStates","active","dragging","events","position","ValueXY","panResponder","create","onStartShouldSetPanResponder","e","setState","p","onDragStart","getEvents","tt","onDragEndAnimation","onMove","onMoveToPosition","onResetPosition","render","s","style","transform","getTranslateTransform","backgroundColor","elevation","zIndex","createElement","View","dataSet","component","onLayout","isActive","touchProps","panHandlers","itemData","newState","index","baseXAtStartedDragging","getBaseX","onItemLayout","layout","nativeEvent","gestate","x","dx","y","setValue","props","calculatedXFromStartingPosition","animationArgs","duration","easing","inOut","linear","toValue","useNativeDriver","animationEventArgs","animationType","emit","timing","start","getItemDataForIndex","baseX","args","callback"],"sources":["../../src/draggable-sort/item.jsx"],"sourcesContent":["import React, {useMemo} from \"react\"\nimport {Animated, Easing, PanResponder} from \"react-native\"\nimport {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport EventEmitter from \"events\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"../use-event-emitter\"\n\nexport default memo(shapeComponent(class DraggableSortItem extends ShapeComponent {\n  static propTypes = propTypesExact({\n    cacheKey: PropTypes.string,\n    controller: PropTypes.object.isRequired,\n    item: PropTypes.any.isRequired,\n    itemIndex: PropTypes.number.isRequired,\n    onItemMoved: PropTypes.func,\n    renderItem: PropTypes.func.isRequired\n  })\n\n  initialLayout = null\n\n  setup() {\n    this.useStates({\n      active: false,\n      dragging: false\n    })\n\n    this.events = useMemo(() => new EventEmitter(), [])\n    this.position = useMemo(() => new Animated.ValueXY(), [])\n    this.panResponder = useMemo(\n      () => PanResponder.create({\n        onStartShouldSetPanResponder: (e, ) => {\n          this.setState({dragging: true})\n          this.p.controller.onDragStart({item: this.p.item, itemIndex: this.p.itemIndex})\n\n          return false\n        }\n      }),\n      []\n    )\n\n    useEventEmitter(this.p.controller.getEvents(), \"onDragStart\", this.tt.onDragStart)\n    useEventEmitter(this.p.controller.getEvents(), \"onDragEndAnimation\", this.tt.onDragEndAnimation)\n    useEventEmitter(this.tt.events, \"move\", this.tt.onMove)\n    useEventEmitter(this.tt.events, \"moveToPosition\", this.tt.onMoveToPosition)\n    useEventEmitter(this.tt.events, \"resetPosition\", this.tt.onResetPosition)\n  }\n\n  render() {\n    const {item, renderItem} = this.p\n    const {active} = this.s\n    const style = useMemo(\n      () => {\n        const style = {\n          transform: this.tt.position.getTranslateTransform()\n        }\n\n        if (active) {\n          style.backgroundColor = \"#fff\"\n          style.elevation = 2\n          style.zIndex = 99999\n        }\n\n        return style\n      },\n      [active]\n    )\n\n    return (\n      <Animated.View dataSet={{component: \"draggable-sort/item\"}} onLayout={this.tt.onLayout} style={style}>\n        {renderItem({isActive: active, item, touchProps: this.tt.panResponder.panHandlers})}\n      </Animated.View>\n    )\n  }\n\n  onDragStart = ({itemData}) => {\n    const newState = {dragging: true}\n\n    if (itemData.index == this.p.itemIndex) {\n      newState.active = true\n      this.baseXAtStartedDragging = this.getBaseX()\n    }\n\n    this.setState(newState)\n  }\n\n  onDragEndAnimation = () => this.setState({active: false, dragging: false})\n\n  onLayout = (e) => {\n    const {controller, item, itemIndex} = this.p\n\n    controller.onItemLayout({events: this.tt.events, index: itemIndex, item, layout: e.nativeEvent.layout})\n\n    if (!this.tt.initialLayout) {\n      this.initialLayout = e.nativeEvent.layout\n    }\n  }\n\n  onMove = ({gestate}) => {\n    const x = gestate.dx + this.tt.baseXAtStartedDragging - this.tt.initialLayout.x\n    const y = this.tt.initialLayout.y\n\n    this.tt.position.setValue({x, y})\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({itemIndex: this.p.itemIndex, x, y})\n    }\n  }\n\n  onMoveToPosition = ({x, y}) => {\n    const calculatedXFromStartingPosition = x - this.tt.initialLayout.x\n    const animationArgs = {\n      duration: 200,\n      easing: Easing.inOut(Easing.linear),\n      toValue: {\n        x: calculatedXFromStartingPosition,\n        y\n      },\n      useNativeDriver: true,\n    }\n    const animationEventArgs = {animationArgs, animationType: \"moveToPosition\", item: this.p.item}\n\n    this.p.controller.events.emit(\"onAnimationStart\", animationEventArgs)\n\n    Animated\n      .timing(this.tt.position, animationArgs)\n      .start(() => {\n        this.p.controller.events.emit(\"onAnimationEnd\", animationEventArgs)\n      })\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({\n        animationArgs,\n        itemIndex: this.p.itemIndex,\n        x: calculatedXFromStartingPosition,\n        y\n      })\n    }\n  }\n\n  getBaseX = () => this.p.controller.getItemDataForIndex(this.p.itemIndex).baseX\n\n  onResetPosition = (args) => {\n    const baseX = this.getBaseX() - this.tt.initialLayout.x\n    const animationArgs = {\n      duration: 200,\n      easing: Easing.inOut(Easing.linear),\n      toValue: {\n        x: baseX,\n        y: 0\n      },\n      useNativeDriver: true,\n    }\n    const animationEventArgs = {animationArgs, animationType: \"resetPosition\", item: this.p.item}\n\n    this.p.controller.events.emit(\"onAnimationStart\", animationEventArgs)\n\n    Animated\n      .timing(this.tt.position, animationArgs)\n      .start(() => {\n        this.p.controller.events.emit(\"onAnimationEnd\", animationEventArgs)\n        if (args?.callback) args.callback()\n      })\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({\n        animationArgs,\n        itemIndex: this.p.itemIndex,\n        x: baseX,\n        y: 0\n      })\n    }\n  }\n}))\n"],"mappings":"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","ignoreList":[]}

package/build/error-logger.js

@@ -0,0 +1,101 @@
+import { digg } from "diggerize";
+import SourceMapsLoader from "./source-maps-loader";
+export default class ErrorLogger {
+  constructor() {
+    this.debugging = false;
+    this.errorOccurred = false;
+    this.errors = [];
+    this.isHandlingError = false;
+    this.sourceMapsLoader = new SourceMapsLoader();
+    this.sourceMapsLoader.loadSourceMapsForScriptTags(script => {
+      const src = script.getAttribute("src");
+      const type = script.getAttribute("type");
+      if (src && (src.includes("/packs/") || src.includes("/packs-test/")) && (type == "text/javascript" || !type)) {
+        return src;
+      }
+    });
+  }
+  debug(...output) {
+    if (this.debugging) console.error(`ApiMaker ErrorLogger:`, ...output);
+  }
+  enable() {
+    this.debug("Enable called");
+    this.connectOnError();
+    this.connectUnhandledRejection();
+  }
+  getErrors = () => this.errors;
+  hasErrorOccurred() {
+    return digg(this, "errorOccurred");
+  }
+  isLoadingSourceMaps() {
+    return digg(this, "sourceMapsLoader", "isLoadingSourceMaps");
+  }
+  isWorkingOnError() {
+    return digg(this, "isHandlingError") || this.isLoadingSourceMaps();
+  }
+  connectOnError() {
+    window.addEventListener("error", event => {
+      if (this.debugging) this.debug(`Error:`, event.message);
+      this.errorOccurred = true;
+      if (!this.isHandlingError) {
+        this.isHandlingError = true;
+        this.onError(event).finally(() => {
+          this.isHandlingError = false;
+        });
+      }
+    });
+  }
+  connectUnhandledRejection() {
+    window.addEventListener("unhandledrejection", event => {
+      if (this.debugging) this.debug(`Unhandled rejection:`, event.reason.message);
+      this.errorOccurred = true;
+      if (!this.isHandlingError) {
+        this.isHandlingError = true;
+        this.onUnhandledRejection(event).finally(() => {
+          this.isHandlingError = false;
+        });
+      }
+    });
+  }
+  async onError(event) {
+    this.errorOccurred = true;
+    await this.sourceMapsLoader.loadSourceMaps(event.error);
+    if (event.error && event.error.stack) {
+      const backtrace = this.sourceMapsLoader.parseStackTrace(event.error.stack);
+      this.errors.push({
+        errorClass: event.error ? event.error.name : "No error class",
+        message: event.message || "Unknown error",
+        backtrace
+      });
+    } else {
+      this.errors.push({
+        errorClass: event.error ? event.error.name : "No error class",
+        message: event.message || "Unknown error",
+        backtrace: null
+      });
+    }
+  }
+  async onUnhandledRejection(event) {
+    await this.sourceMapsLoader.loadSourceMaps(event.reason);
+    if (event.reason.stack) {
+      const backtrace = this.sourceMapsLoader.parseStackTrace(event.reason.stack);
+      this.errors.push({
+        errorClass: "UnhandledRejection",
+        message: event.reason.message || "Unhandled promise rejection",
+        backtrace
+      });
+    } else {
+      this.errors.push({
+        errorClass: "UnhandledRejection",
+        message: event.reason.message || "Unhandled promise rejection",
+        backtrace: null
+      });
+    }
+  }
+  testPromiseError() {
+    return new Promise(_resolve => {
+      throw new Error("testPromiseError");
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digg","SourceMapsLoader","ErrorLogger","constructor","debugging","errorOccurred","errors","isHandlingError","sourceMapsLoader","loadSourceMapsForScriptTags","script","src","getAttribute","type","includes","debug","output","console","error","enable","connectOnError","connectUnhandledRejection","getErrors","hasErrorOccurred","isLoadingSourceMaps","isWorkingOnError","window","addEventListener","event","message","onError","finally","reason","onUnhandledRejection","loadSourceMaps","stack","backtrace","parseStackTrace","push","errorClass","name","testPromiseError","Promise","_resolve","Error"],"sources":["../src/error-logger.js"],"sourcesContent":["import {digg} from \"diggerize\"\nimport SourceMapsLoader from \"./source-maps-loader\"\n\nexport default class ErrorLogger {\n  constructor () {\n    this.debugging = false\n    this.errorOccurred = false\n    this.errors = []\n    this.isHandlingError = false\n    this.sourceMapsLoader = new SourceMapsLoader()\n    this.sourceMapsLoader.loadSourceMapsForScriptTags((script) => {\n      const src = script.getAttribute(\"src\")\n      const type = script.getAttribute(\"type\")\n\n      if (src && (src.includes(\"/packs/\") || src.includes(\"/packs-test/\")) && (type == \"text/javascript\" || !type)) {\n        return src\n      }\n    })\n  }\n\n  debug(...output) {\n    if (this.debugging) console.error(`ApiMaker ErrorLogger:`, ...output)\n  }\n\n  enable () {\n    this.debug(\"Enable called\")\n    this.connectOnError()\n    this.connectUnhandledRejection()\n  }\n\n  getErrors = () => this.errors\n\n  hasErrorOccurred() {\n    return digg(this, \"errorOccurred\")\n  }\n\n  isLoadingSourceMaps() {\n    return digg(this, \"sourceMapsLoader\", \"isLoadingSourceMaps\")\n  }\n\n  isWorkingOnError() {\n    return digg(this, \"isHandlingError\") || this.isLoadingSourceMaps()\n  }\n\n  connectOnError () {\n    window.addEventListener(\"error\", (event) => {\n      if (this.debugging) this.debug(`Error:`, event.message)\n      this.errorOccurred = true\n\n      if (!this.isHandlingError) {\n        this.isHandlingError = true\n        this.onError(event).finally(() => {\n          this.isHandlingError = false\n        })\n      }\n    })\n  }\n\n  connectUnhandledRejection () {\n    window.addEventListener(\"unhandledrejection\", (event) => {\n      if (this.debugging) this.debug(`Unhandled rejection:`, event.reason.message)\n      this.errorOccurred = true\n\n      if (!this.isHandlingError) {\n        this.isHandlingError = true\n        this.onUnhandledRejection(event).finally(() => {\n          this.isHandlingError = false\n        })\n      }\n    })\n  }\n\n  async onError (event) {\n    this.errorOccurred = true\n    await this.sourceMapsLoader.loadSourceMaps(event.error)\n\n    if (event.error && event.error.stack) {\n      const backtrace = this.sourceMapsLoader.parseStackTrace(event.error.stack)\n\n      this.errors.push({\n        errorClass: event.error ? event.error.name : \"No error class\",\n        message: event.message || \"Unknown error\",\n        backtrace\n      })\n    } else {\n      this.errors.push({\n        errorClass: event.error ? event.error.name : \"No error class\",\n        message: event.message || \"Unknown error\",\n        backtrace: null\n      })\n    }\n  }\n\n  async onUnhandledRejection (event) {\n    await this.sourceMapsLoader.loadSourceMaps(event.reason)\n\n    if (event.reason.stack) {\n      const backtrace = this.sourceMapsLoader.parseStackTrace(event.reason.stack)\n\n      this.errors.push({\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || \"Unhandled promise rejection\",\n        backtrace\n      })\n    } else {\n      this.errors.push({\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || \"Unhandled promise rejection\",\n        backtrace: null\n      })\n    }\n  }\n\n  testPromiseError () {\n    return new Promise((_resolve) => {\n      throw new Error(\"testPromiseError\")\n    })\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/error-messages.js

@@ -0,0 +1,13 @@
+import { digg } from "diggerize";
+const errorMessages = args => {
+  if (typeof args.response == "object") {
+    return digg(args, "response", "errors").map(error => {
+      if (typeof error == "string") {
+        return error;
+      }
+      return digg(error, "message");
+    });
+  }
+};
+export default errorMessages;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkaWdnIiwiZXJyb3JNZXNzYWdlcyIsImFyZ3MiLCJyZXNwb25zZSIsIm1hcCIsImVycm9yIl0sInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9yLW1lc3NhZ2VzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZGlnZ30gZnJvbSBcImRpZ2dlcml6ZVwiXG5cbmNvbnN0IGVycm9yTWVzc2FnZXMgPSAoYXJncykgPT4ge1xuICBpZiAodHlwZW9mIGFyZ3MucmVzcG9uc2UgPT0gXCJvYmplY3RcIikge1xuICAgIHJldHVybiBkaWdnKGFyZ3MsIFwicmVzcG9uc2VcIiwgXCJlcnJvcnNcIikubWFwKChlcnJvcikgPT4ge1xuICAgICAgaWYgKHR5cGVvZiBlcnJvciA9PSBcInN0cmluZ1wiKSB7XG4gICAgICAgIHJldHVybiBlcnJvclxuICAgICAgfVxuXG4gICAgICByZXR1cm4gZGlnZyhlcnJvciwgXCJtZXNzYWdlXCIpXG4gICAgfSlcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBlcnJvck1lc3NhZ2VzXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVFBLElBQUksUUFBTyxXQUFXO0FBRTlCLE1BQU1DLGFBQWEsR0FBSUMsSUFBSSxJQUFLO0VBQzlCLElBQUksT0FBT0EsSUFBSSxDQUFDQyxRQUFRLElBQUksUUFBUSxFQUFFO0lBQ3BDLE9BQU9ILElBQUksQ0FBQ0UsSUFBSSxFQUFFLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQ0UsR0FBRyxDQUFFQyxLQUFLLElBQUs7TUFDckQsSUFBSSxPQUFPQSxLQUFLLElBQUksUUFBUSxFQUFFO1FBQzVCLE9BQU9BLEtBQUs7TUFDZDtNQUVBLE9BQU9MLElBQUksQ0FBQ0ssS0FBSyxFQUFFLFNBQVMsQ0FBQztJQUMvQixDQUFDLENBQUM7RUFDSjtBQUNGLENBQUM7QUFFRCxlQUFlSixhQUFhIiwiaWdub3JlTGlzdCI6W119

package/build/event-connection.js

@@ -0,0 +1,32 @@
+import ModelEvents from "./model-events";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+export default class ApiMakerEventConnection extends React.PureComponent {
+  static defaultProps = {
+    active: true
+  };
+  static propTypes = propTypesExact({
+    active: PropTypes.bool.isRequired,
+    model: PropTypes.object.isRequired,
+    event: PropTypes.string.isRequired,
+    onCall: PropTypes.func.isRequired
+  });
+  componentDidMount() {
+    this.subscription = ModelEvents.connect(this.props.model, this.props.event, (...args) => this.onCall(...args));
+  }
+  componentWillUnmount() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+    }
+  }
+  render() {
+    return null;
+  }
+  onCall(...args) {
+    if (this.props.active) {
+      this.props.onCall(...args);
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/event-emitter-listener.js

@@ -0,0 +1,15 @@
+import useEventEmitter from "./use-event-emitter";
+const EventEmitterListener = ({
+  event,
+  events,
+  onCalled,
+  ...restProps
+}) => {
+  const restPropsKeys = Object.keys(restProps);
+  if (restPropsKeys.length > 0) {
+    throw new Error(`Unexpected props: ${restPropsKeys}`);
+  }
+  useEventEmitter(events, event, onCalled);
+};
+export default EventEmitterListener;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VFdmVudEVtaXR0ZXIiLCJFdmVudEVtaXR0ZXJMaXN0ZW5lciIsImV2ZW50IiwiZXZlbnRzIiwib25DYWxsZWQiLCJyZXN0UHJvcHMiLCJyZXN0UHJvcHNLZXlzIiwiT2JqZWN0Iiwia2V5cyIsImxlbmd0aCIsIkVycm9yIl0sInNvdXJjZXMiOlsiLi4vc3JjL2V2ZW50LWVtaXR0ZXItbGlzdGVuZXIuanN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB1c2VFdmVudEVtaXR0ZXIgZnJvbSBcIi4vdXNlLWV2ZW50LWVtaXR0ZXJcIlxuXG5jb25zdCBFdmVudEVtaXR0ZXJMaXN0ZW5lciA9ICh7ZXZlbnQsIGV2ZW50cywgb25DYWxsZWQsIC4uLnJlc3RQcm9wc30pID0+IHtcbiAgY29uc3QgcmVzdFByb3BzS2V5cyA9IE9iamVjdC5rZXlzKHJlc3RQcm9wcylcblxuICBpZiAocmVzdFByb3BzS2V5cy5sZW5ndGggPiAwKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBVbmV4cGVjdGVkIHByb3BzOiAke3Jlc3RQcm9wc0tleXN9YClcbiAgfVxuXG4gIHVzZUV2ZW50RW1pdHRlcihldmVudHMsIGV2ZW50LCBvbkNhbGxlZClcbn1cblxuZXhwb3J0IGRlZmF1bHQgRXZlbnRFbWl0dGVyTGlzdGVuZXJcbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsZUFBZSxNQUFNLHFCQUFxQjtBQUVqRCxNQUFNQyxvQkFBb0IsR0FBR0EsQ0FBQztFQUFDQyxLQUFLO0VBQUVDLE1BQU07RUFBRUMsUUFBUTtFQUFFLEdBQUdDO0FBQVMsQ0FBQyxLQUFLO0VBQ3hFLE1BQU1DLGFBQWEsR0FBR0MsTUFBTSxDQUFDQyxJQUFJLENBQUNILFNBQVMsQ0FBQztFQUU1QyxJQUFJQyxhQUFhLENBQUNHLE1BQU0sR0FBRyxDQUFDLEVBQUU7SUFDNUIsTUFBTSxJQUFJQyxLQUFLLENBQUMscUJBQXFCSixhQUFhLEVBQUUsQ0FBQztFQUN2RDtFQUVBTixlQUFlLENBQUNHLE1BQU0sRUFBRUQsS0FBSyxFQUFFRSxRQUFRLENBQUM7QUFDMUMsQ0FBQztBQUVELGVBQWVILG9CQUFvQiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/event-model-class.js

@@ -0,0 +1,24 @@
+import ModelEvents from "./model-events";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import React from "react";
+export default class ApiMakerEventModelClass extends React.PureComponent {
+  static propTypes = propTypesExact({
+    event: PropTypes.string.isRequired,
+    modelClass: PropTypes.func.isRequired,
+    onCall: PropTypes.func.isRequired
+  });
+  componentDidMount() {
+    this.connect();
+  }
+  componentWillUnmount() {
+    if (this.connection) {
+      this.connection.unsubscribe();
+    }
+  }
+  connect() {
+    this.connection = ModelEvents.connectModelClass(this.props.modelClass, this.props.event, this.props.onCall);
+  }
+  render = () => null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/events.js

@@ -0,0 +1,5 @@
+import EventEmitter from "events";
+const events = new EventEmitter();
+events.setMaxListeners(1000);
+export default events;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJFdmVudEVtaXR0ZXIiLCJldmVudHMiLCJzZXRNYXhMaXN0ZW5lcnMiXSwic291cmNlcyI6WyIuLi9zcmMvZXZlbnRzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBFdmVudEVtaXR0ZXIgZnJvbSBcImV2ZW50c1wiXG5cbmNvbnN0IGV2ZW50cyA9IG5ldyBFdmVudEVtaXR0ZXIoKVxuXG5ldmVudHMuc2V0TWF4TGlzdGVuZXJzKDEwMDApXG5cbmV4cG9ydCBkZWZhdWx0IGV2ZW50c1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxZQUFZLE1BQU0sUUFBUTtBQUVqQyxNQUFNQyxNQUFNLEdBQUcsSUFBSUQsWUFBWSxDQUFDLENBQUM7QUFFakNDLE1BQU0sQ0FBQ0MsZUFBZSxDQUFDLElBQUksQ0FBQztBQUU1QixlQUFlRCxNQUFNIiwiaWdub3JlTGlzdCI6W119

package/build/flash-message.js

@@ -0,0 +1,79 @@
+import CustomError from "@kaspernj/api-maker/build/custom-error";
+import I18nOnSteroids from "i18n-on-steroids";
+import ValidationError from "@kaspernj/api-maker/build/validation-error";
+import { digg } from "diggerize";
+export default class FlashMessage {
+  static alert(message) {
+    new FlashMessage({
+      type: "alert",
+      message
+    });
+  }
+  static error(message) {
+    new FlashMessage({
+      type: "error",
+      message
+    });
+  }
+  static errorResponse(error) {
+    if (error instanceof ValidationError) {
+      if (error.hasUnhandledErrors()) {
+        FlashMessage.error(error.message);
+      } else {
+        FlashMessage.error(I18nOnSteroids.getCurrent().t("js.flash_message.couldnt_submit_because_of_validation_errors"));
+      }
+    } else if (error instanceof CustomError) {
+      const errors = error.args.response.errors;
+      const errorMessages = errors.map(error => {
+        if (typeof error == "string") {
+          return error;
+        }
+        return digg(error, "message");
+      });
+      const errorMessage = errorMessages.join(". ");
+      FlashMessage.error(errorMessage);
+    } else {
+      console.error("Didnt know what to do with this", error);
+    }
+  }
+  static success(message) {
+    new FlashMessage({
+      type: "success",
+      message
+    });
+  }
+  constructor({
+    message,
+    type
+  }) {
+    if (!message) throw new Error("No message given");
+    if (!type) throw new Error("No type given");
+    let title;
+    if (type == "alert") {
+      title = I18nOnSteroids.getCurrent().t("js.flash_message.alert", {
+        defaultValue: "Alert"
+      });
+    } else if (type == "error") {
+      title = I18nOnSteroids.getCurrent().t("js.flash_message.error", {
+        defaultValue: "Error"
+      });
+    } else if (type == "success") {
+      title = I18nOnSteroids.getCurrent().t("js.flash_message.success", {
+        defaultValue: "Success"
+      });
+    } else {
+      title = I18nOnSteroids.getCurrent().t("js.flash_message.notification", {
+        defaultValue: "Notification"
+      });
+    }
+    const event = new CustomEvent("pushNotification", {
+      detail: {
+        message,
+        title,
+        type
+      }
+    });
+    globalThis.dispatchEvent(event);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDdXN0b21FcnJvciIsIkkxOG5PblN0ZXJvaWRzIiwiVmFsaWRhdGlvbkVycm9yIiwiZGlnZyIsIkZsYXNoTWVzc2FnZSIsImFsZXJ0IiwibWVzc2FnZSIsInR5cGUiLCJlcnJvciIsImVycm9yUmVzcG9uc2UiLCJoYXNVbmhhbmRsZWRFcnJvcnMiLCJnZXRDdXJyZW50IiwidCIsImVycm9ycyIsImFyZ3MiLCJyZXNwb25zZSIsImVycm9yTWVzc2FnZXMiLCJtYXAiLCJlcnJvck1lc3NhZ2UiLCJqb2luIiwiY29uc29sZSIsInN1Y2Nlc3MiLCJjb25zdHJ1Y3RvciIsIkVycm9yIiwidGl0bGUiLCJkZWZhdWx0VmFsdWUiLCJldmVudCIsIkN1c3RvbUV2ZW50IiwiZGV0YWlsIiwiZ2xvYmFsVGhpcyIsImRpc3BhdGNoRXZlbnQiXSwic291cmNlcyI6WyIuLi9zcmMvZmxhc2gtbWVzc2FnZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgQ3VzdG9tRXJyb3IgZnJvbSBcIkBrYXNwZXJuai9hcGktbWFrZXIvYnVpbGQvY3VzdG9tLWVycm9yXCJcbmltcG9ydCBJMThuT25TdGVyb2lkcyBmcm9tIFwiaTE4bi1vbi1zdGVyb2lkc1wiXG5pbXBvcnQgVmFsaWRhdGlvbkVycm9yIGZyb20gXCJAa2FzcGVybmovYXBpLW1ha2VyL2J1aWxkL3ZhbGlkYXRpb24tZXJyb3JcIlxuaW1wb3J0IHtkaWdnfSBmcm9tIFwiZGlnZ2VyaXplXCJcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgRmxhc2hNZXNzYWdlIHtcbiAgc3RhdGljIGFsZXJ0KG1lc3NhZ2UpIHtcbiAgICBuZXcgRmxhc2hNZXNzYWdlKHt0eXBlOiBcImFsZXJ0XCIsIG1lc3NhZ2V9KVxuICB9XG5cbiAgc3RhdGljIGVycm9yKG1lc3NhZ2UpIHtcbiAgICBuZXcgRmxhc2hNZXNzYWdlKHt0eXBlOiBcImVycm9yXCIsIG1lc3NhZ2V9KVxuICB9XG5cbiAgc3RhdGljIGVycm9yUmVzcG9uc2UoZXJyb3IpIHtcbiAgICBpZiAoZXJyb3IgaW5zdGFuY2VvZiBWYWxpZGF0aW9uRXJyb3IpIHtcbiAgICAgIGlmIChlcnJvci5oYXNVbmhhbmRsZWRFcnJvcnMoKSkge1xuICAgICAgICBGbGFzaE1lc3NhZ2UuZXJyb3IoZXJyb3IubWVzc2FnZSlcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIEZsYXNoTWVzc2FnZS5lcnJvcihJMThuT25TdGVyb2lkcy5nZXRDdXJyZW50KCkudChcImpzLmZsYXNoX21lc3NhZ2UuY291bGRudF9zdWJtaXRfYmVjYXVzZV9vZl92YWxpZGF0aW9uX2Vycm9yc1wiKSlcbiAgICAgIH1cbiAgICB9IGVsc2UgaWYgKGVycm9yIGluc3RhbmNlb2YgQ3VzdG9tRXJyb3IpIHtcbiAgICAgIGNvbnN0IGVycm9ycyA9IGVycm9yLmFyZ3MucmVzcG9uc2UuZXJyb3JzXG4gICAgICBjb25zdCBlcnJvck1lc3NhZ2VzID0gZXJyb3JzXG4gICAgICAgIC5tYXAoKGVycm9yKSA9PiB7XG4gICAgICAgICAgaWYgKHR5cGVvZiBlcnJvciA9PSBcInN0cmluZ1wiKSB7XG4gICAgICAgICAgICByZXR1cm4gZXJyb3JcbiAgICAgICAgICB9XG5cbiAgICAgICAgICByZXR1cm4gZGlnZyhlcnJvciwgXCJtZXNzYWdlXCIpXG4gICAgICAgIH0pXG4gICAgICBjb25zdCBlcnJvck1lc3NhZ2UgPSBlcnJvck1lc3NhZ2VzLmpvaW4oXCIuIFwiKVxuXG4gICAgICBGbGFzaE1lc3NhZ2UuZXJyb3IoZXJyb3JNZXNzYWdlKVxuICAgIH0gZWxzZSB7XG4gICAgICBjb25zb2xlLmVycm9yKFwiRGlkbnQga25vdyB3aGF0IHRvIGRvIHdpdGggdGhpc1wiLCBlcnJvcilcbiAgICB9XG4gIH1cblxuICBzdGF0aWMgc3VjY2VzcyhtZXNzYWdlKSB7XG4gICAgbmV3IEZsYXNoTWVzc2FnZSh7dHlwZTogXCJzdWNjZXNzXCIsIG1lc3NhZ2V9KVxuICB9XG5cbiAgY29uc3RydWN0b3Ioe21lc3NhZ2UsIHR5cGV9KSB7XG4gICAgaWYgKCFtZXNzYWdlKSB0aHJvdyBuZXcgRXJyb3IoXCJObyBtZXNzYWdlIGdpdmVuXCIpXG4gICAgaWYgKCF0eXBlKSB0aHJvdyBuZXcgRXJyb3IoXCJObyB0eXBlIGdpdmVuXCIpXG5cbiAgICBsZXQgdGl0bGVcblxuICAgIGlmICh0eXBlID09IFwiYWxlcnRcIikge1xuICAgICAgdGl0bGUgPSBJMThuT25TdGVyb2lkcy5nZXRDdXJyZW50KCkudChcImpzLmZsYXNoX21lc3NhZ2UuYWxlcnRcIiwge2RlZmF1bHRWYWx1ZTogXCJBbGVydFwifSlcbiAgICB9IGVsc2UgaWYgKHR5cGUgPT0gXCJlcnJvclwiKSB7XG4gICAgICB0aXRsZSA9IEkxOG5PblN0ZXJvaWRzLmdldEN1cnJlbnQoKS50KFwianMuZmxhc2hfbWVzc2FnZS5lcnJvclwiLCB7ZGVmYXVsdFZhbHVlOiBcIkVycm9yXCJ9KVxuICAgIH0gZWxzZSBpZiAodHlwZSA9PSBcInN1Y2Nlc3NcIikge1xuICAgICAgdGl0bGUgPSBJMThuT25TdGVyb2lkcy5nZXRDdXJyZW50KCkudChcImpzLmZsYXNoX21lc3NhZ2Uuc3VjY2Vzc1wiLCB7ZGVmYXVsdFZhbHVlOiBcIlN1Y2Nlc3NcIn0pXG4gICAgfSBlbHNlIHtcbiAgICAgIHRpdGxlID0gSTE4bk9uU3Rlcm9pZHMuZ2V0Q3VycmVudCgpLnQoXCJqcy5mbGFzaF9tZXNzYWdlLm5vdGlmaWNhdGlvblwiLCB7ZGVmYXVsdFZhbHVlOiBcIk5vdGlmaWNhdGlvblwifSlcbiAgICB9XG5cbiAgICBjb25zdCBldmVudCA9IG5ldyBDdXN0b21FdmVudChcInB1c2hOb3RpZmljYXRpb25cIiwge1xuICAgICAgZGV0YWlsOiB7XG4gICAgICAgIG1lc3NhZ2UsXG4gICAgICAgIHRpdGxlLFxuICAgICAgICB0eXBlXG4gICAgICB9XG4gICAgfSlcblxuICAgIGdsb2JhbFRoaXMuZGlzcGF0Y2hFdmVudChldmVudClcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxXQUFXLE1BQU0sd0NBQXdDO0FBQ2hFLE9BQU9DLGNBQWMsTUFBTSxrQkFBa0I7QUFDN0MsT0FBT0MsZUFBZSxNQUFNLDRDQUE0QztBQUN4RSxTQUFRQyxJQUFJLFFBQU8sV0FBVztBQUU5QixlQUFlLE1BQU1DLFlBQVksQ0FBQztFQUNoQyxPQUFPQyxLQUFLQSxDQUFDQyxPQUFPLEVBQUU7SUFDcEIsSUFBSUYsWUFBWSxDQUFDO01BQUNHLElBQUksRUFBRSxPQUFPO01BQUVEO0lBQU8sQ0FBQyxDQUFDO0VBQzVDO0VBRUEsT0FBT0UsS0FBS0EsQ0FBQ0YsT0FBTyxFQUFFO0lBQ3BCLElBQUlGLFlBQVksQ0FBQztNQUFDRyxJQUFJLEVBQUUsT0FBTztNQUFFRDtJQUFPLENBQUMsQ0FBQztFQUM1QztFQUVBLE9BQU9HLGFBQWFBLENBQUNELEtBQUssRUFBRTtJQUMxQixJQUFJQSxLQUFLLFlBQVlOLGVBQWUsRUFBRTtNQUNwQyxJQUFJTSxLQUFLLENBQUNFLGtCQUFrQixDQUFDLENBQUMsRUFBRTtRQUM5Qk4sWUFBWSxDQUFDSSxLQUFLLENBQUNBLEtBQUssQ0FBQ0YsT0FBTyxDQUFDO01BQ25DLENBQUMsTUFBTTtRQUNMRixZQUFZLENBQUNJLEtBQUssQ0FBQ1AsY0FBYyxDQUFDVSxVQUFVLENBQUMsQ0FBQyxDQUFDQyxDQUFDLENBQUMsOERBQThELENBQUMsQ0FBQztNQUNuSDtJQUNGLENBQUMsTUFBTSxJQUFJSixLQUFLLFlBQVlSLFdBQVcsRUFBRTtNQUN2QyxNQUFNYSxNQUFNLEdBQUdMLEtBQUssQ0FBQ00sSUFBSSxDQUFDQyxRQUFRLENBQUNGLE1BQU07TUFDekMsTUFBTUcsYUFBYSxHQUFHSCxNQUFNLENBQ3pCSSxHQUFHLENBQUVULEtBQUssSUFBSztRQUNkLElBQUksT0FBT0EsS0FBSyxJQUFJLFFBQVEsRUFBRTtVQUM1QixPQUFPQSxLQUFLO1FBQ2Q7UUFFQSxPQUFPTCxJQUFJLENBQUNLLEtBQUssRUFBRSxTQUFTLENBQUM7TUFDL0IsQ0FBQyxDQUFDO01BQ0osTUFBTVUsWUFBWSxHQUFHRixhQUFhLENBQUNHLElBQUksQ0FBQyxJQUFJLENBQUM7TUFFN0NmLFlBQVksQ0FBQ0ksS0FBSyxDQUFDVSxZQUFZLENBQUM7SUFDbEMsQ0FBQyxNQUFNO01BQ0xFLE9BQU8sQ0FBQ1osS0FBSyxDQUFDLGlDQUFpQyxFQUFFQSxLQUFLLENBQUM7SUFDekQ7RUFDRjtFQUVBLE9BQU9hLE9BQU9BLENBQUNmLE9BQU8sRUFBRTtJQUN0QixJQUFJRixZQUFZLENBQUM7TUFBQ0csSUFBSSxFQUFFLFNBQVM7TUFBRUQ7SUFBTyxDQUFDLENBQUM7RUFDOUM7RUFFQWdCLFdBQVdBLENBQUM7SUFBQ2hCLE9BQU87SUFBRUM7RUFBSSxDQUFDLEVBQUU7SUFDM0IsSUFBSSxDQUFDRCxPQUFPLEVBQUUsTUFBTSxJQUFJaUIsS0FBSyxDQUFDLGtCQUFrQixDQUFDO0lBQ2pELElBQUksQ0FBQ2hCLElBQUksRUFBRSxNQUFNLElBQUlnQixLQUFLLENBQUMsZUFBZSxDQUFDO0lBRTNDLElBQUlDLEtBQUs7SUFFVCxJQUFJakIsSUFBSSxJQUFJLE9BQU8sRUFBRTtNQUNuQmlCLEtBQUssR0FBR3ZCLGNBQWMsQ0FBQ1UsVUFBVSxDQUFDLENBQUMsQ0FBQ0MsQ0FBQyxDQUFDLHdCQUF3QixFQUFFO1FBQUNhLFlBQVksRUFBRTtNQUFPLENBQUMsQ0FBQztJQUMxRixDQUFDLE1BQU0sSUFBSWxCLElBQUksSUFBSSxPQUFPLEVBQUU7TUFDMUJpQixLQUFLLEdBQUd2QixjQUFjLENBQUNVLFVBQVUsQ0FBQyxDQUFDLENBQUNDLENBQUMsQ0FBQyx3QkFBd0IsRUFBRTtRQUFDYSxZQUFZLEVBQUU7TUFBTyxDQUFDLENBQUM7SUFDMUYsQ0FBQyxNQUFNLElBQUlsQixJQUFJLElBQUksU0FBUyxFQUFFO01BQzVCaUIsS0FBSyxHQUFHdkIsY0FBYyxDQUFDVSxVQUFVLENBQUMsQ0FBQyxDQUFDQyxDQUFDLENBQUMsMEJBQTBCLEVBQUU7UUFBQ2EsWUFBWSxFQUFFO01BQVMsQ0FBQyxDQUFDO0lBQzlGLENBQUMsTUFBTTtNQUNMRCxLQUFLLEdBQUd2QixjQUFjLENBQUNVLFVBQVUsQ0FBQyxDQUFDLENBQUNDLENBQUMsQ0FBQywrQkFBK0IsRUFBRTtRQUFDYSxZQUFZLEVBQUU7TUFBYyxDQUFDLENBQUM7SUFDeEc7SUFFQSxNQUFNQyxLQUFLLEdBQUcsSUFBSUMsV0FBVyxDQUFDLGtCQUFrQixFQUFFO01BQ2hEQyxNQUFNLEVBQUU7UUFDTnRCLE9BQU87UUFDUGtCLEtBQUs7UUFDTGpCO01BQ0Y7SUFDRixDQUFDLENBQUM7SUFFRnNCLFVBQVUsQ0FBQ0MsYUFBYSxDQUFDSixLQUFLLENBQUM7RUFDakM7QUFDRiIsImlnbm9yZUxpc3QiOltdfQ==

package/build/form.js

@@ -0,0 +1,83 @@
+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, { createContext, useContext, useMemo } from "react";
+import BaseComponent from "./base-component";
+import FormDataObjectizer from "form-data-objectizer";
+import memo from "set-state-compare/src/memo";
+import { Platform } from "react-native";
+import PropTypes from "prop-types";
+import { shapeComponent } from "set-state-compare/src/shape-component";
+const FormContext = /*#__PURE__*/createContext(null);
+const useForm = () => useContext(FormContext);
+class FormInputs {
+  constructor(props) {
+    this.inputs = {};
+    this.onSubmit = props?.onSubmit;
+  }
+  asObject() {
+    const result = {};
+    const formDataObjectizer = new FormDataObjectizer();
+    for (const key in this.inputs) {
+      const value = this.inputs[key];
+      formDataObjectizer.treatInitial(key, value, result);
+    }
+    return result;
+  }
+  setValue(name, value) {
+    if (!name) throw new Error("'name' is required");
+    this.inputs[name] = value;
+  }
+  setValueWithHidden(name, value) {
+    this.setValue(name, value);
+    if (Platform.OS == "web") {
+      return /*#__PURE__*/React.createElement("input", {
+        name: name,
+        type: "hidden",
+        value: value !== null && value !== undefined ? value : ""
+      });
+    }
+  }
+  submit() {
+    if (this.onSubmit) {
+      this.onSubmit();
+    }
+  }
+}
+const Form = memo(shapeComponent(class Form extends BaseComponent {
+  static propTypes = {
+    children: PropTypes.node,
+    formRef: PropTypes.object,
+    onSubmit: PropTypes.func,
+    setForm: PropTypes.func
+  };
+  render() {
+    const {
+      children,
+      formRef,
+      onSubmit,
+      setForm,
+      ...restProps
+    } = this.props;
+    const form = useMemo(() => new FormInputs({
+      onSubmit
+    }), []);
+    useMemo(() => {
+      if (setForm) {
+        setForm(form);
+      }
+    }, [setForm]);
+    return /*#__PURE__*/React.createElement(FormContext.Provider, {
+      value: form
+    }, Platform.OS == "web" && /*#__PURE__*/React.createElement("form", _extends({
+      ref: formRef,
+      onSubmit: this.tt.onFormSubmit
+    }, restProps), children), Platform.OS != "web" && this.props.children);
+  }
+  onFormSubmit = e => {
+    e.preventDefault();
+    if (this.props.onSubmit) {
+      this.props.onSubmit();
+    }
+  };
+}));
+export { Form, FormContext, FormInputs, useForm };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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