@webority/mobile-ui 0.0.0-stage → 0.0.33

package/lib/commonjs/form/FormContext.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Form = void 0;
+exports.useFormContext = useFormContext;
+exports.useOptionalFormContext = useOptionalFormContext;
+var _react = _interopRequireWildcard(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+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 FormContext = /*#__PURE__*/(0, _react.createContext)(null);
+/**
+ * Provides a {@link useForm} instance to descendants so `<FormField name>`,
+ * {@link useField} and {@link useFieldArray} can bind by name.
+ *
+ * Generic in `Values`, and it has to be. `FormApi` is invariant in `Values`
+ * because `setValues` accepts a `(prev: Values) => Values`, so a
+ * `FormApi<MyValues>` is not assignable to a `FormApi<FormValues>`. While the
+ * prop was declared at the base type, `useForm<MyValues>()` could not be handed
+ * to `<Form>` by ANY consumer, which is most of the reason to type a form at
+ * all. Untyped callers are unaffected: `Values` defaults to `FormValues`.
+ */
+const Form = ({
+  form,
+  children
+}) =>
+/*#__PURE__*/
+// Stored at the base type on purpose: descendants bind by NAME through
+// useField and never observe Values, so widening here is safe and is what
+// lets a typed form be provided at all.
+(0, _jsxRuntime.jsx)(FormContext.Provider, {
+  value: form,
+  children: children
+});
+exports.Form = Form;
+Form.displayName = 'Form';
+
+/** Read the surrounding form. Throws if there is no `<Form>` ancestor. */
+function useFormContext() {
+  const ctx = (0, _react.useContext)(FormContext);
+  if (!ctx) {
+    throw new Error('useFormContext / useField / <FormField name> must be rendered inside a <Form> from @webority/mobile-ui.');
+  }
+  return ctx;
+}
+
+/** Read the surrounding form, or null when there is no `<Form>` ancestor. */
+function useOptionalFormContext() {
+  return (0, _react.useContext)(FormContext);
+}
+//# sourceMappingURL=FormContext.js.map

package/lib/commonjs/form/index.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Form", {
+  enumerable: true,
+  get: function () {
+    return _FormContext.Form;
+  }
+});
+Object.defineProperty(exports, "deletePath", {
+  enumerable: true,
+  get: function () {
+    return _path.deletePath;
+  }
+});
+Object.defineProperty(exports, "getPath", {
+  enumerable: true,
+  get: function () {
+    return _path.getPath;
+  }
+});
+Object.defineProperty(exports, "isFieldFilled", {
+  enumerable: true,
+  get: function () {
+    return _useFormCompletion.isFieldFilled;
+  }
+});
+exports.rules = void 0;
+Object.defineProperty(exports, "setPath", {
+  enumerable: true,
+  get: function () {
+    return _path.setPath;
+  }
+});
+Object.defineProperty(exports, "useField", {
+  enumerable: true,
+  get: function () {
+    return _useField.useField;
+  }
+});
+Object.defineProperty(exports, "useFieldArray", {
+  enumerable: true,
+  get: function () {
+    return _useField.useFieldArray;
+  }
+});
+Object.defineProperty(exports, "useForm", {
+  enumerable: true,
+  get: function () {
+    return _useForm.useForm;
+  }
+});
+Object.defineProperty(exports, "useFormCompletion", {
+  enumerable: true,
+  get: function () {
+    return _useFormCompletion.useFormCompletion;
+  }
+});
+Object.defineProperty(exports, "useFormContext", {
+  enumerable: true,
+  get: function () {
+    return _FormContext.useFormContext;
+  }
+});
+Object.defineProperty(exports, "useOptionalFormContext", {
+  enumerable: true,
+  get: function () {
+    return _FormContext.useOptionalFormContext;
+  }
+});
+var _FormContext = require("./FormContext.js");
+var _path = require("./path.js");
+var rules = _interopRequireWildcard(require("./rules.js"));
+exports.rules = rules;
+var _useField = require("./useField.js");
+var _useForm = require("./useForm.js");
+var _useFormCompletion = require("./useFormCompletion.js");
+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); }
+//# sourceMappingURL=index.js.map

package/lib/commonjs/form/path.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setPath = exports.getPath = exports.deletePath = void 0;
+/**
+ * Immutable get/set/delete for dot- and bracket-notation field paths
+ * ("address.city", "phones[0]", "items[2].qty"). Lets a single flat `name`
+ * string address nested values and array items, so the form engine can treat
+ * every field uniformly regardless of how deep it lives in the value tree.
+ */
+
+const tokenize = path => {
+  const tokens = [];
+  const re = /[^.[\]]+/g;
+  let m;
+  while ((m = re.exec(path)) !== null) {
+    const raw = m[0];
+    tokens.push(/^\d+$/.test(raw) ? Number(raw) : raw);
+  }
+  return tokens;
+};
+const getPath = (obj, path) => {
+  const tokens = tokenize(path);
+  let cur = obj;
+  for (const t of tokens) {
+    if (cur == null || typeof cur !== 'object') {
+      return undefined;
+    }
+    cur = cur[t];
+  }
+  return cur;
+};
+exports.getPath = getPath;
+const setPath = (obj, path, value) => {
+  const tokens = tokenize(path);
+  if (tokens.length === 0) {
+    return obj;
+  }
+  const root = Array.isArray(obj) ? [...obj] : {
+    ...obj
+  };
+  let cur = root;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const t = tokens[i];
+    const next = tokens[i + 1];
+    const child = cur[t];
+    // Clone the existing branch so we never mutate the previous value tree;
+    // create the right container shape when the branch is missing.
+    const cloned = child != null && typeof child === 'object' ? Array.isArray(child) ? [...child] : {
+      ...child
+    } : typeof next === 'number' ? [] : {};
+    cur[t] = cloned;
+    cur = cloned;
+  }
+  cur[tokens[tokens.length - 1]] = value;
+  return root;
+};
+exports.setPath = setPath;
+const deletePath = (obj, path) => {
+  const tokens = tokenize(path);
+  if (tokens.length === 0) {
+    return obj;
+  }
+  const root = Array.isArray(obj) ? [...obj] : {
+    ...obj
+  };
+  let cur = root;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const t = tokens[i];
+    const child = cur[t];
+    if (child == null || typeof child !== 'object') {
+      return root;
+    }
+    const cloned = Array.isArray(child) ? [...child] : {
+      ...child
+    };
+    cur[t] = cloned;
+    cur = cloned;
+  }
+  const last = tokens[tokens.length - 1];
+  if (Array.isArray(cur) && typeof last === 'number') {
+    cur.splice(last, 1);
+  } else {
+    delete cur[last];
+  }
+  return root;
+};
+exports.deletePath = deletePath;
+//# sourceMappingURL=path.js.map

package/lib/commonjs/form/rules.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.url = exports.strongPassword = exports.required = exports.pincode = exports.phone = exports.pattern = exports.pan = exports.oneOf = exports.numeric = exports.mobile = exports.minLength = exports.min = exports.maxLength = exports.max = exports.matches = exports.integer = exports.ifsc = exports.gstin = exports.email = exports.custom = exports.alphanumeric = exports.aadhaar = void 0;
+var _mobileCore = require("@webority/mobile-core");
+var _path = require("./path.js");
+/**
+ * Validation rule presets — the dependency-free replacement for Yup chains.
+ * Each factory returns a {@link ValidationRule}. Rules built on the project's
+ * `validators` module skip empty values (so `required()` owns emptiness and you
+ * don't get duplicate errors), and accept an optional custom message.
+ */
+
+const isEmptyValue = v => v == null || v === '' || Array.isArray(v) && v.length === 0;
+const fromPredicate = (predicate, defaultMsg) => message => value => isEmptyValue(value) || predicate(value) ? undefined : message ?? defaultMsg;
+const required = (message = 'This field is required') => value => {
+  // A required boolean (e.g. "accept terms" checkbox) must be true.
+  if (typeof value === 'boolean') {
+    return value ? undefined : message;
+  }
+  return isEmptyValue(value) ? message : undefined;
+};
+exports.required = required;
+const email = exports.email = fromPredicate(_mobileCore.isEmail, 'Enter a valid email');
+const mobile = exports.mobile = fromPredicate(_mobileCore.isIndianMobile, 'Enter a valid mobile number');
+const phone = exports.phone = fromPredicate(_mobileCore.isPhone, 'Enter a valid phone number');
+const url = exports.url = fromPredicate(_mobileCore.isUrl, 'Enter a valid URL');
+const numeric = exports.numeric = fromPredicate(_mobileCore.isNumeric, 'Enter a valid number');
+const integer = exports.integer = fromPredicate(_mobileCore.isInteger, 'Enter a whole number');
+const alphanumeric = exports.alphanumeric = fromPredicate(_mobileCore.isAlphanumeric, 'Use letters and numbers only');
+const pincode = exports.pincode = fromPredicate(_mobileCore.isIndianPincode, 'Enter a valid 6-digit PIN code');
+const pan = exports.pan = fromPredicate(_mobileCore.isPan, 'Enter a valid PAN');
+const gstin = exports.gstin = fromPredicate(_mobileCore.isGstin, 'Enter a valid GSTIN');
+const aadhaar = exports.aadhaar = fromPredicate(_mobileCore.isAadhaar, 'Enter a valid Aadhaar number');
+const ifsc = exports.ifsc = fromPredicate(_mobileCore.isIfsc, 'Enter a valid IFSC code');
+const minLength = (length, message) => value => isEmptyValue(value) || String(value).length >= length ? undefined : message ?? `Must be at least ${length} characters`;
+exports.minLength = minLength;
+const maxLength = (length, message) => value => value == null || String(value).length <= length ? undefined : message ?? `Must be at most ${length} characters`;
+exports.maxLength = maxLength;
+const min = (n, message) => value => isEmptyValue(value) || Number(value) >= n ? undefined : message ?? `Must be at least ${n}`;
+exports.min = min;
+const max = (n, message) => value => isEmptyValue(value) || Number(value) <= n ? undefined : message ?? `Must be at most ${n}`;
+exports.max = max;
+const pattern = (regex, message = 'Invalid format') => value => isEmptyValue(value) || regex.test(String(value)) ? undefined : message;
+exports.pattern = pattern;
+const oneOf = (allowed, message = 'Invalid selection') => value => isEmptyValue(value) || allowed.includes(value) ? undefined : message;
+
+/** Cross-field equality (e.g. confirm-password). `otherField` is a field path. */
+exports.oneOf = oneOf;
+const matches = (otherField, message = 'Values do not match') => (value, allValues) => value === (0, _path.getPath)(allValues, otherField) ? undefined : message;
+exports.matches = matches;
+const strongPassword = (rules, message = 'Password is too weak') => value => isEmptyValue(value) || (0, _mobileCore.isStrongPassword)(value, rules) ? undefined : message;
+
+/**
+ * Wrap any custom check. Return `true` (valid), `false` (invalid → default
+ * message), or a string (invalid → that message). Async is supported — return
+ * a Promise of the same.
+ */
+exports.strongPassword = strongPassword;
+const custom = (fn, message = 'Invalid value') => async (value, allValues) => {
+  const result = await fn(value, allValues);
+  if (result === true) {
+    return undefined;
+  }
+  if (result === false) {
+    return message;
+  }
+  return result;
+};
+exports.custom = custom;
+//# sourceMappingURL=rules.js.map

package/lib/commonjs/form/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/commonjs/form/useField.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useField = useField;
+exports.useFieldArray = useFieldArray;
+var _FormContext = require("./FormContext.js");
+var _path = require("./path.js");
+/**
+ * Bind a single field by name. Returns everything an input needs; pick the
+ * handler your control uses:
+ *   const email = useField('email');
+ *   <Input value={email.value} onChangeText={email.onChangeText} onBlur={email.onBlur} error={email.error} />
+ *   <Select value={country.value} onChange={country.onChange} error={country.error} />
+ *   <Switch value={!!agree.value} onChange={agree.onChange} />
+ */
+function useField(name) {
+  const form = (0, _FormContext.useFormContext)();
+  return form.getFieldProps(name);
+}
+/**
+ * Manage a repeating list field (phone numbers, line items, etc.) by name.
+ * Each helper writes the whole array back through the form so validation and
+ * dirty-tracking stay correct.
+ */
+function useFieldArray(name) {
+  const form = (0, _FormContext.useFormContext)();
+  const fields = (0, _path.getPath)(form.values, name) ?? [];
+  const set = next => form.setFieldValue(name, next);
+  return {
+    fields,
+    length: fields.length,
+    push: item => set([...fields, item]),
+    remove: index => set(fields.filter((_, i) => i !== index)),
+    insert: (index, item) => {
+      const copy = [...fields];
+      copy.splice(index, 0, item);
+      set(copy);
+    },
+    // `move` and `replace` index into the array directly, so an out-of-range
+    // index corrupts it rather than failing: splice(9, 1) on a 3-item array
+    // yields `undefined`, which then gets spliced back IN, and `copy[9] = item`
+    // grows the array with six holes. Either one puts nulls into the submitted
+    // payload of a repeating field. `insert` and `remove` need no guard —
+    // splice clamps and filter no-ops.
+    move: (from, to) => {
+      if (from < 0 || from >= fields.length) {
+        return;
+      }
+      const copy = [...fields];
+      const [moved] = copy.splice(from, 1);
+      copy.splice(Math.max(0, Math.min(to, copy.length)), 0, moved);
+      set(copy);
+    },
+    replace: (index, item) => {
+      if (index < 0 || index >= fields.length) {
+        return;
+      }
+      const copy = [...fields];
+      copy[index] = item;
+      set(copy);
+    }
+  };
+}
+//# sourceMappingURL=useField.js.map