react-native-system-ui 0.0.1-beta0 → 0.0.2

package/dist/cjs/flex/Flex.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Flex = void 0;
+function _react() {
+  const data = _interopRequireDefault(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _reactNative() {
+  const data = require("react-native");
+  _reactNative = function () {
+    return data;
+  };
+  return data;
+}
+var _FlexContext = require("./FlexContext");
+var _tokens = require("./tokens");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const alignMap = {
+  start: 'flex-start',
+  center: 'center',
+  end: 'flex-end',
+  baseline: 'baseline',
+  stretch: 'stretch'
+};
+const justifyMap = {
+  start: 'flex-start',
+  end: 'flex-end',
+  center: 'center',
+  around: 'space-around',
+  between: 'space-between'
+};
+const Flex = props => {
+  const {
+    tokensOverride,
+    children,
+    direction: directionProp,
+    wrap: wrapProp,
+    gutter: gutterProp,
+    align: alignProp,
+    justify: justifyProp,
+    style,
+    columns: columnsProp
+  } = props;
+  const tokens = (0, _tokens.useFlexTokens)(tokensOverride);
+  const direction = directionProp ?? tokens.defaults.direction;
+  const wrap = wrapProp ?? tokens.defaults.wrap;
+  const gutter = gutterProp ?? tokens.defaults.gutter;
+  const align = alignProp ?? tokens.defaults.align;
+  const justify = justifyProp ?? tokens.defaults.justify;
+  const columns = columnsProp ?? tokens.defaults.columns;
+  const resolvedColumns = Math.max(1, columns);
+  const [hRaw, vRaw] = Array.isArray(gutter) ? gutter : [gutter, 0];
+  const horizontalGap = Math.max(0, hRaw ?? 0);
+  const verticalGap = Math.max(0, vRaw ?? 0);
+  const supportsGap = _reactNative().Platform.OS === 'web';
+  return /*#__PURE__*/_react().default.createElement(_FlexContext.FlexContext.Provider, {
+    value: {
+      horizontalGap,
+      verticalGap,
+      columns: resolvedColumns
+    }
+  }, /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: [tokens.layout.container, {
+      flexDirection: direction,
+      flexWrap: wrap,
+      alignItems: alignMap[align],
+      justifyContent: justifyMap[justify],
+      marginHorizontal: !supportsGap && horizontalGap ? -horizontalGap / 2 : undefined,
+      marginVertical: !supportsGap && verticalGap ? -verticalGap / 2 : undefined,
+      columnGap: supportsGap ? horizontalGap : undefined,
+      rowGap: supportsGap ? verticalGap : undefined
+    }, style]
+  }, children));
+};
+exports.Flex = Flex;

package/dist/cjs/flex/FlexContext.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FlexContext = void 0;
+function _react() {
+  const data = _interopRequireDefault(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const FlexContext = exports.FlexContext = /*#__PURE__*/_react().default.createContext({
+  horizontalGap: 0,
+  verticalGap: 0,
+  columns: 24
+});

package/dist/cjs/flex/FlexItem.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FlexItem = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _reactNative() {
+  const data = require("react-native");
+  _reactNative = function () {
+    return data;
+  };
+  return data;
+}
+var _FlexContext = require("./FlexContext");
+var _utils = require("../../utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const parseFlex = value => {
+  if ((0, _utils.isNumber)(value)) return {
+    flex: value
+  };
+  if (!value) return undefined;
+  const str = value.trim();
+  if (!str) return undefined;
+  if (str === 'auto') return {
+    flexGrow: 1,
+    flexShrink: 1,
+    flexBasis: 'auto'
+  };
+  if (str === 'none') return {
+    flexGrow: 0,
+    flexShrink: 0,
+    flexBasis: 'auto'
+  };
+  const num = Number(str);
+  if ((0, _utils.isNumber)(num)) return {
+    flex: num
+  };
+  const parts = str.split(/\s+/);
+  if (parts.length >= 2) {
+    const [grow, shrink] = parts.map(Number);
+    if ((0, _utils.isNumber)(grow) && (0, _utils.isNumber)(shrink)) {
+      const basisStr = parts.slice(2).join(' ');
+      let flexBasis;
+      if (basisStr === 'auto') flexBasis = 'auto';else if (basisStr) {
+        const pxMatch = basisStr.match(/^(-?\d+(?:\.\d+)?)px$/);
+        const basisNum = pxMatch ? Number(pxMatch[1]) : Number(basisStr);
+        if ((0, _utils.isNumber)(basisNum)) {
+          flexBasis = basisNum;
+        }
+      }
+      return {
+        flexGrow: grow,
+        flexShrink: shrink,
+        flexBasis
+      };
+    }
+  }
+  return undefined;
+};
+const FlexItem = ({
+  span,
+  flex,
+  style,
+  children
+}) => {
+  const {
+    horizontalGap,
+    verticalGap,
+    columns
+  } = (0, _react().useContext)(_FlexContext.FlexContext);
+  const supportsGap = _reactNative().Platform.OS === 'web';
+  if ((0, _utils.isNumber)(span) && span <= 0) return null;
+  const widthStyle = {};
+  if ((0, _utils.isNumber)(span)) {
+    const safeColumns = Math.max(1, columns);
+    const percent = Math.min(Math.max(span, 0), safeColumns) / safeColumns;
+    widthStyle.width = `${percent * 100}%`;
+    widthStyle.flexGrow = 0;
+    widthStyle.flexShrink = 0;
+  }
+  return /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: [supportsGap ? null : {
+      paddingHorizontal: horizontalGap / 2,
+      paddingVertical: verticalGap / 2
+    }, widthStyle, parseFlex(flex), style]
+  }, children);
+};
+exports.FlexItem = FlexItem;

package/dist/cjs/flex/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Flex = void 0;
+Object.defineProperty(exports, "FlexItem", {
+  enumerable: true,
+  get: function () {
+    return _FlexItem.FlexItem;
+  }
+});
+exports.default = void 0;
+var _Flex = require("./Flex");
+var _FlexItem = require("./FlexItem");
+const Flex = exports.Flex = Object.assign(_Flex.Flex, {
+  Item: _FlexItem.FlexItem
+});
+var _default = exports.default = Flex;

package/dist/cjs/flex/tokens.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFlexTokens = void 0;
+var _designSystem = require("../../design-system");
+const createFlexTokens = _foundations => ({
+  defaults: {
+    direction: 'row',
+    wrap: 'nowrap',
+    gutter: 0,
+    align: 'start',
+    justify: 'start',
+    columns: 24
+  },
+  layout: {
+    container: {}
+  }
+});
+const useFlexTokens = exports.useFlexTokens = (0, _designSystem.createComponentTokensHook)('flex', createFlexTokens);

package/dist/cjs/form/Form.js

@@ -0,0 +1,372 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useWatch = exports.default = exports.FormSubscribe = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _reactNative() {
+  const data = require("react-native");
+  _reactNative = function () {
+    return data;
+  };
+  return data;
+}
+var _promise = require("../../utils/promise");
+var _validate = require("../../utils/validate");
+var _FormContext = require("./FormContext");
+var _utils = require("./utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+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); }
+const runRuleValidation = (rule, value, values) => {
+  const message = rule.message ?? '表单验证未通过';
+  const empty = value == null || value === '' || Array.isArray(value) && value.length === 0;
+  if (rule.required && (empty || rule.whitespace && (0, _validate.isString)(value) && value.trim().length === 0)) {
+    return message;
+  }
+  if (empty) return null;
+  if (rule.pattern && (0, _validate.isString)(value) && !rule.pattern.test(value)) return message;
+  if (rule.len !== undefined || rule.min !== undefined || rule.max !== undefined) {
+    const length = (0, _validate.isNumber)(value) ? value : (0, _validate.isString)(value) || Array.isArray(value) ? value.length : 0;
+    if (rule.len !== undefined && length !== rule.len) return message;
+    if (rule.min !== undefined && length < rule.min) return message;
+    if (rule.max !== undefined && length > rule.max) return message;
+  }
+  if (!rule.validator) return null;
+  const handle = result => (0, _validate.isString)(result) ? result : result === false ? message : null;
+  const result = rule.validator(value, values);
+  return (0, _promise.isPromiseLike)(result) ? result.then(handle) : handle(result);
+};
+const shallowEqual = (prev, next) => {
+  if (prev === next) return true;
+  if (!prev || !next) return false;
+  const prevKeys = Object.keys(prev);
+  const nextKeys = Object.keys(next);
+  if (prevKeys.length !== nextKeys.length) {
+    return false;
+  }
+  for (const key of prevKeys) {
+    if (prev[key] !== next[key]) {
+      return false;
+    }
+  }
+  return true;
+};
+const InternalForm = /*#__PURE__*/_react().default.forwardRef((props, ref) => {
+  const {
+    initialValues: initialValuesProp,
+    colon,
+    labelWidth,
+    showValidateMessage = true,
+    onValuesChange,
+    onFinish,
+    style,
+    footer,
+    children,
+    ...rest
+  } = props;
+  const defaultInitialValuesRef = (0, _react().useRef)({});
+  const mergedInitialValues = initialValuesProp ?? defaultInitialValuesRef.current;
+  const [values, setValues] = (0, _react().useState)(mergedInitialValues);
+  const [errors, setErrors] = (0, _react().useState)({});
+  const lastInitialValuesRef = (0, _react().useRef)(mergedInitialValues);
+  const fieldsRef = (0, _react().useRef)({});
+  const dependencyGraphRef = (0, _react().useRef)(new Map());
+  const valuesRef = (0, _react().useRef)(values);
+  const errorsRef = (0, _react().useRef)(errors);
+  const validationSeqRef = (0, _react().useRef)({});
+  const subscribersRef = (0, _react().useRef)(new Set());
+  (0, _react().useEffect)(() => {
+    if (shallowEqual(lastInitialValuesRef.current, mergedInitialValues)) {
+      return;
+    }
+    lastInitialValuesRef.current = mergedInitialValues;
+    valuesRef.current = mergedInitialValues;
+    errorsRef.current = {};
+    setValues(mergedInitialValues);
+    setErrors({});
+  }, [mergedInitialValues]);
+  const setFieldErrors = (0, _react().useCallback)((name, nextErrors) => {
+    const key = (0, _utils.serializeNamePath)(name);
+    setErrors(prev => {
+      const prevErrors = prev[key];
+      if (!nextErrors.length) {
+        if (!prevErrors) return prev;
+        const clone = {
+          ...prev
+        };
+        delete clone[key];
+        errorsRef.current = clone;
+        return clone;
+      }
+      if (prevErrors?.[0] === nextErrors[0] && prevErrors.length === nextErrors.length) {
+        return prev;
+      }
+      const clone = {
+        ...prev,
+        [key]: nextErrors
+      };
+      errorsRef.current = clone;
+      return clone;
+    });
+  }, []);
+  const registerField = (0, _react().useCallback)((name, options) => {
+    const key = (0, _utils.serializeNamePath)(name);
+    const prev = fieldsRef.current[key];
+    if (prev?.dependencies?.length) {
+      for (const dep of prev.dependencies) {
+        const depKey = (0, _utils.serializeNamePath)(dep);
+        const set = dependencyGraphRef.current.get(depKey);
+        if (!set) continue;
+        set.delete(key);
+        if (!set.size) dependencyGraphRef.current.delete(depKey);
+      }
+    }
+    fieldsRef.current[key] = {
+      ...options,
+      name
+    };
+    if (options.dependencies?.length) {
+      for (const dep of options.dependencies) {
+        const depKey = (0, _utils.serializeNamePath)(dep);
+        const set = dependencyGraphRef.current.get(depKey);
+        if (set) {
+          set.add(key);
+        } else {
+          dependencyGraphRef.current.set(depKey, new Set([key]));
+        }
+      }
+    }
+    if (options.initialValue !== undefined) {
+      const existsInInitial = (0, _utils.getValueByName)(lastInitialValuesRef.current, name);
+      if (existsInInitial === undefined) {
+        lastInitialValuesRef.current = (0, _utils.setValueByName)(lastInitialValuesRef.current, name, options.initialValue);
+      }
+      const existsInState = (0, _utils.getValueByName)(valuesRef.current, name);
+      if (existsInState === undefined) {
+        setValues(prev => {
+          if ((0, _utils.getValueByName)(prev, name) !== undefined) return prev;
+          const next = (0, _utils.setValueByName)(prev, name, options.initialValue);
+          valuesRef.current = next;
+          return next;
+        });
+      }
+    }
+    return () => {
+      const current = fieldsRef.current[key];
+      delete fieldsRef.current[key];
+      if (current?.dependencies?.length) {
+        for (const dep of current.dependencies) {
+          const depKey = (0, _utils.serializeNamePath)(dep);
+          const set = dependencyGraphRef.current.get(depKey);
+          if (!set) continue;
+          set.delete(key);
+          if (!set.size) dependencyGraphRef.current.delete(depKey);
+        }
+      }
+      setFieldErrors(name, []);
+    };
+  }, [setFieldErrors]);
+  const notify = (0, _react().useCallback)((changedValues, nextValues) => {
+    subscribersRef.current.forEach(listener => listener(changedValues, nextValues));
+  }, []);
+  const runFieldValidation = (0, _react().useCallback)(async (name, trigger, valueOverride, valuesOverride) => {
+    const key = (0, _utils.serializeNamePath)(name);
+    const validationSeq = (validationSeqRef.current[key] ?? 0) + 1;
+    validationSeqRef.current[key] = validationSeq;
+    const fieldOptions = fieldsRef.current[key];
+    const fieldRules = fieldOptions?.rules ?? [];
+    if (!fieldRules.length) {
+      setFieldErrors(name, []);
+      return true;
+    }
+    let activeRules = trigger ? fieldRules.filter(rule => {
+      const ruleTrigger = rule.validateTrigger ?? fieldOptions.validateTrigger;
+      return !ruleTrigger || (0, _utils.normalizeTrigger)(ruleTrigger).includes(trigger);
+    }) : fieldRules;
+    if (!activeRules.length) {
+      if (!errorsRef.current[key]?.length) return true;
+      activeRules = fieldRules;
+    }
+    const currentValues = valuesOverride ?? valuesRef.current;
+    const value = valueOverride ?? (0, _utils.getValueByName)(currentValues, name);
+    for (const rule of activeRules) {
+      const result = runRuleValidation(rule, value, currentValues);
+      const error = (0, _promise.isPromiseLike)(result) ? await result : result;
+      if (validationSeqRef.current[key] !== validationSeq) {
+        return true;
+      }
+      if (error) {
+        setFieldErrors(name, [error]);
+        return false;
+      }
+    }
+    if (validationSeqRef.current[key] !== validationSeq) {
+      return true;
+    }
+    setFieldErrors(name, []);
+    return true;
+  }, [setFieldErrors]);
+  const validateFields = (0, _react().useCallback)(async names => {
+    const fieldNames = names ?? Object.values(fieldsRef.current).map(item => item.name);
+    const results = await Promise.all(fieldNames.map(name => runFieldValidation(name)));
+    const hasError = results.some(result => !result);
+    if (hasError) {
+      throw errorsRef.current;
+    }
+    return valuesRef.current;
+  }, [runFieldValidation]);
+  const setFieldValue = (0, _react().useCallback)((name, value, trigger) => {
+    const nameKey = (0, _utils.serializeNamePath)(name);
+    setValues(prev => {
+      const prevValue = (0, _utils.getValueByName)(prev, name);
+      if (prevValue === value) return prev;
+      const next = (0, _utils.setValueByName)(prev, name, value);
+      valuesRef.current = next;
+      onValuesChange?.(next, nameKey, value);
+      runFieldValidation(name, trigger, value, next);
+      const dependents = dependencyGraphRef.current.get(nameKey);
+      if (dependents?.size) {
+        for (const dependentKey of dependents) {
+          const meta = fieldsRef.current[dependentKey];
+          if (!meta) continue;
+          runFieldValidation(meta.name, trigger, (0, _utils.getValueByName)(next, meta.name), next);
+        }
+      }
+      notify({
+        [nameKey]: value
+      }, next);
+      return next;
+    });
+  }, [notify, onValuesChange, runFieldValidation]);
+  const formApi = (0, _react().useMemo)(() => ({
+    submit: async () => {
+      try {
+        const result = await validateFields();
+        onFinish?.(result);
+        return result;
+      } catch (error) {
+        return undefined;
+      }
+    },
+    getFieldsValue: () => valuesRef.current,
+    setFieldsValue: next => {
+      setValues(prev => {
+        let merged = prev;
+        const changed = {};
+        Object.keys(next).forEach(key => {
+          const newVal = next[key];
+          if ((0, _utils.getValueByName)(merged, key) === newVal) return;
+          changed[key] = newVal;
+          merged = (0, _utils.setValueByName)(merged, key, newVal);
+          onValuesChange?.(merged, key, newVal);
+          runFieldValidation(key, undefined, newVal, merged);
+          const dependents = dependencyGraphRef.current.get(key);
+          if (dependents?.size) {
+            for (const dependentKey of dependents) {
+              const meta = fieldsRef.current[dependentKey];
+              if (!meta) continue;
+              runFieldValidation(meta.name, undefined, (0, _utils.getValueByName)(merged, meta.name), merged);
+            }
+          }
+        });
+        if (merged === prev) return prev;
+        valuesRef.current = merged;
+        notify(changed, merged);
+        return merged;
+      });
+    },
+    resetFields: () => {
+      let next = lastInitialValuesRef.current;
+      Object.values(fieldsRef.current).forEach(meta => {
+        if (meta.initialValue === undefined) return;
+        if ((0, _utils.getValueByName)(next, meta.name) !== undefined) return;
+        next = (0, _utils.setValueByName)(next, meta.name, meta.initialValue);
+      });
+      valuesRef.current = next;
+      errorsRef.current = {};
+      setValues(next);
+      setErrors({});
+      notify(next, next);
+    },
+    validateFields,
+    getFieldError: name => errorsRef.current[(0, _utils.serializeNamePath)(name)] ?? []
+  }), [notify, onFinish, onValuesChange, validateFields, runFieldValidation]);
+  (0, _react().useImperativeHandle)(ref, () => formApi, [formApi]);
+  const getFieldError = (0, _react().useCallback)(name => errors[(0, _utils.serializeNamePath)(name)], [errors]);
+  const getFieldValue = (0, _react().useCallback)(name => (0, _utils.getValueByName)(values, name), [values]);
+  const contextValidateField = (0, _react().useCallback)((name, trigger) => runFieldValidation(name, trigger), [runFieldValidation]);
+  const contextValue = (0, _react().useMemo)(() => ({
+    values,
+    getFieldValue,
+    setFieldValue,
+    registerField,
+    getFieldError,
+    validateField: contextValidateField,
+    getFieldsValue: () => values,
+    subscribe: listener => {
+      subscribersRef.current.add(listener);
+      return () => subscribersRef.current.delete(listener);
+    },
+    form: formApi,
+    colon,
+    labelWidth,
+    showValidateMessage
+  }), [values, setFieldValue, registerField, getFieldError, contextValidateField, formApi, colon, labelWidth, showValidateMessage]);
+  return /*#__PURE__*/_react().default.createElement(_FormContext.FormContext.Provider, {
+    value: contextValue
+  }, /*#__PURE__*/_react().default.createElement(_reactNative().View, _extends({
+    style: style
+  }, rest), children, footer));
+});
+InternalForm.displayName = 'Form';
+const useWatch = (name, formRef) => {
+  const context = (0, _react().useContext)(_FormContext.FormContext);
+  const names = (0, _react().useMemo)(() => {
+    if (name === undefined) return undefined;
+    if (!Array.isArray(name)) return [name];
+    return name.length && (0, _validate.isText)(name[0]) ? [name] : name;
+  }, [name]);
+  const getSnapshot = (0, _react().useCallback)(allValues => {
+    const source = allValues ?? context?.getFieldsValue?.() ?? formRef?.current?.getFieldsValue?.() ?? {};
+    if (!names) return source;
+    if (names.length === 1) return (0, _utils.getValueByName)(source, names[0]);
+    const picked = {};
+    for (const key of names) picked[(0, _utils.serializeNamePath)(key)] = (0, _utils.getValueByName)(source, key);
+    return picked;
+  }, [context, formRef, names]);
+  const [value, setValue] = (0, _react().useState)(() => getSnapshot());
+  (0, _react().useEffect)(() => {
+    if (!context?.subscribe) return undefined;
+    return context.subscribe((changed, all) => {
+      if (!names || names.some(key => (0, _utils.serializeNamePath)(key) in changed)) {
+        setValue(getSnapshot(all));
+      }
+    });
+  }, [context, getSnapshot, names]);
+  return value;
+};
+exports.useWatch = useWatch;
+const FormSubscribe = ({
+  to,
+  children
+}) => {
+  const context = (0, _react().useContext)(_FormContext.FormContext);
+  const [changed, setChanged] = (0, _react().useState)({});
+  (0, _react().useEffect)(() => {
+    if (!context?.subscribe) return undefined;
+    return context.subscribe(next => {
+      if (to && !Object.keys(next).some(key => to.includes(key))) return;
+      setChanged(next);
+    });
+  }, [context, to]);
+  return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children(changed, context?.form || null));
+};
+exports.FormSubscribe = FormSubscribe;
+var _default = exports.default = InternalForm;

package/dist/cjs/form/FormContext.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormContext = void 0;
+function _react() {
+  const data = _interopRequireDefault(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const FormContext = exports.FormContext = /*#__PURE__*/_react().default.createContext(null);