@valfuse-node/form 0.2.0

package/dist/index.js

@@ -0,0 +1,641 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  clearFieldErrors: () => clearFieldErrors,
+  computeDirtyFields: () => computeDirtyFields,
+  computeIsDirty: () => computeIsDirty,
+  createErrorsState: () => createErrorsState,
+  createSchema: () => createSchema,
+  createSubmissionState: () => createSubmissionState,
+  createTouchedState: () => createTouchedState,
+  createValuesState: () => createValuesState,
+  endSubmitFailure: () => endSubmitFailure,
+  endSubmitSuccess: () => endSubmitSuccess,
+  getFieldError: () => getFieldError,
+  getValue: () => getValue,
+  getValues: () => getValues,
+  hasErrors: () => hasErrors,
+  isFieldDirty: () => isFieldDirty,
+  isTouched: () => isTouched,
+  markTouched: () => markTouched,
+  markUntouched: () => markUntouched,
+  normalizeError: () => normalizeError,
+  resetErrors: () => resetErrors,
+  resetSubmission: () => resetSubmission,
+  resetTouched: () => resetTouched,
+  resetValues: () => resetValues,
+  setErrors: () => setErrors,
+  setFieldError: () => setFieldError,
+  startSubmit: () => startSubmit,
+  t: () => t,
+  toFormErrors: () => toFormErrors,
+  toTouchedFieldsRecord: () => toTouchedFieldsRecord,
+  transformValues: () => transformValues,
+  updateValue: () => updateValue,
+  validateSchema: () => validateSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema/create-schema.ts
+function createSchema(definition) {
+  return definition;
+}
+
+// src/rules/string.rule.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var URL_REGEX = /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&/=]*)$/;
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function toRegExp(regexValue) {
+  if (regexValue instanceof RegExp) {
+    return regexValue;
+  }
+  return new RegExp(regexValue.pattern, regexValue.flags);
+}
+function validateStringRule(value, rule) {
+  const stringValue = typeof value === "string" ? value : "";
+  switch (rule.name) {
+    case "required":
+      if (!value || stringValue.trim() === "") {
+        return rule.error;
+      }
+      break;
+    case "min":
+      if (stringValue.length < rule.value) {
+        return rule.error;
+      }
+      break;
+    case "max":
+      if (stringValue.length > rule.value) {
+        return rule.error;
+      }
+      break;
+    case "length":
+      if (stringValue.length !== rule.value) {
+        return rule.error;
+      }
+      break;
+    case "email":
+      if (!EMAIL_REGEX.test(stringValue)) {
+        return rule.error;
+      }
+      break;
+    case "url":
+      if (!URL_REGEX.test(stringValue)) {
+        return rule.error;
+      }
+      break;
+    case "uuid":
+      if (!UUID_REGEX.test(stringValue)) {
+        return rule.error;
+      }
+      break;
+    case "regex": {
+      const builtRegex = toRegExp(rule.value);
+      if (!builtRegex.test(stringValue)) {
+        return rule.error;
+      }
+      break;
+    }
+    case "includes":
+      if (!stringValue.includes(rule.value)) {
+        return rule.error;
+      }
+      break;
+    case "startsWith":
+      if (!stringValue.startsWith(rule.value)) {
+        return rule.error;
+      }
+      break;
+    case "endsWith":
+      if (!stringValue.endsWith(rule.value)) {
+        return rule.error;
+      }
+      break;
+  }
+  return null;
+}
+
+// src/rules/number.rule.ts
+function validateNumberRule(value, rule) {
+  const numericValue = typeof value === "number" ? value : NaN;
+  const hasNumericValue = value !== null && value !== void 0 && value !== "" && !isNaN(numericValue);
+  switch (rule.name) {
+    case "required":
+      if (value === null || value === void 0 || value === "" || isNaN(numericValue)) {
+        return rule.error;
+      }
+      break;
+    case "min":
+      if (hasNumericValue && numericValue < rule.value) {
+        return rule.error;
+      }
+      break;
+    case "max":
+      if (hasNumericValue && numericValue > rule.value) {
+        return rule.error;
+      }
+      break;
+    case "gt":
+      if (hasNumericValue && numericValue <= rule.value) {
+        return rule.error;
+      }
+      break;
+    case "gte":
+      if (hasNumericValue && numericValue < rule.value) {
+        return rule.error;
+      }
+      break;
+    case "lt":
+      if (hasNumericValue && numericValue >= rule.value) {
+        return rule.error;
+      }
+      break;
+    case "lte":
+      if (hasNumericValue && numericValue > rule.value) {
+        return rule.error;
+      }
+      break;
+    case "int":
+      if (hasNumericValue && !Number.isInteger(numericValue)) {
+        return rule.error;
+      }
+      break;
+    case "positive":
+      if (hasNumericValue && numericValue <= 0) {
+        return rule.error;
+      }
+      break;
+    case "nonnegative":
+      if (hasNumericValue && numericValue < 0) {
+        return rule.error;
+      }
+      break;
+    case "negative":
+      if (hasNumericValue && numericValue >= 0) {
+        return rule.error;
+      }
+      break;
+    case "nonpositive":
+      if (hasNumericValue && numericValue > 0) {
+        return rule.error;
+      }
+      break;
+    case "multipleOf":
+      if (hasNumericValue && numericValue % rule.value !== 0) {
+        return rule.error;
+      }
+      break;
+  }
+  return null;
+}
+
+// src/rules/boolean.rule.ts
+function validateBooleanRule(value, rule) {
+  const isValuePresent = value !== null && value !== void 0;
+  switch (rule.name) {
+    case "required":
+      if (!isValuePresent) {
+        return rule.error;
+      }
+      break;
+    case "literal":
+      if (isValuePresent && value !== rule.value) {
+        return rule.error;
+      }
+      break;
+    case "accepted":
+      if (!value) {
+        return rule.error;
+      }
+      break;
+  }
+  return null;
+}
+
+// src/rules/array.rule.ts
+function validateArrayRule(value, rule) {
+  const parsedArray = Array.isArray(value) ? value : null;
+  const isValuePresent = value !== null && value !== void 0;
+  switch (rule.name) {
+    case "required":
+      if (!isValuePresent || !parsedArray) {
+        return rule.error;
+      }
+      break;
+    case "min":
+      if (parsedArray && parsedArray.length < rule.value) {
+        return rule.error;
+      }
+      break;
+    case "max":
+      if (parsedArray && parsedArray.length > rule.value) {
+        return rule.error;
+      }
+      break;
+    case "length":
+      if (parsedArray && parsedArray.length !== rule.value) {
+        return rule.error;
+      }
+      break;
+    case "nonempty":
+      if (!parsedArray || parsedArray.length === 0) {
+        return rule.error;
+      }
+      break;
+  }
+  return null;
+}
+
+// src/rules/object.rule.ts
+function validateObjectRule(value, rule) {
+  switch (rule.name) {
+    case "required":
+      if (value === null || value === void 0) {
+        return rule.error;
+      }
+      break;
+    case "shape":
+      if (value !== null && value !== void 0) {
+        if (typeof value !== "object" || Array.isArray(value)) {
+          return rule.error;
+        }
+        const obj = value;
+        for (const [k, expected] of Object.entries(rule.value)) {
+          if (obj[k] !== expected) {
+            return rule.error;
+          }
+        }
+      }
+      break;
+  }
+  return null;
+}
+
+// src/rules/generic.rule.ts
+var GENERIC_RULE_NAMES = /* @__PURE__ */ new Set([
+  "custom",
+  "refine",
+  "matchField",
+  "oneOf",
+  "notOneOf"
+]);
+function isGenericRule(rule) {
+  return GENERIC_RULE_NAMES.has(rule.name);
+}
+function validateGenericRule(value, rule, allValues) {
+  switch (rule.name) {
+    case "custom":
+    case "refine":
+      if (!rule.validate(value, allValues)) return rule.error;
+      break;
+    case "matchField":
+      if (value !== allValues[rule.value]) return rule.error;
+      break;
+    case "oneOf":
+      if (!rule.value.includes(value)) return rule.error;
+      break;
+    case "notOneOf":
+      if (rule.value.includes(value)) return rule.error;
+      break;
+  }
+  return null;
+}
+
+// src/validation/validate-schema.ts
+function validateSchema(schema, values) {
+  const fieldErrors = {};
+  for (const [fieldName, fieldSchema] of Object.entries(schema)) {
+    const fieldValue = values[fieldName];
+    for (const rule of fieldSchema.rules) {
+      let ruleError = null;
+      if (isGenericRule(rule)) {
+        ruleError = validateGenericRule(fieldValue, rule, values);
+      } else {
+        switch (fieldSchema.type) {
+          case "string":
+            ruleError = validateStringRule(fieldValue, rule);
+            break;
+          case "number":
+            ruleError = validateNumberRule(fieldValue, rule);
+            break;
+          case "boolean":
+            ruleError = validateBooleanRule(fieldValue, rule);
+            break;
+          case "array":
+            ruleError = validateArrayRule(fieldValue, rule);
+            break;
+          case "object":
+            ruleError = validateObjectRule(fieldValue, rule);
+            break;
+        }
+      }
+      if (ruleError) {
+        fieldErrors[fieldName] = ruleError;
+        break;
+      }
+    }
+  }
+  return fieldErrors;
+}
+
+// src/transformation/transform-values.ts
+function transformValues(schema, values) {
+  const result = { ...values };
+  for (const [field, fieldSchema] of Object.entries(schema)) {
+    if (typeof fieldSchema.transform === "function" && field in result) {
+      result[field] = fieldSchema.transform(result[field]);
+    }
+  }
+  return result;
+}
+
+// src/errors/normalize-error.ts
+function normalizeError(error) {
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  return error;
+}
+
+// src/shared/transformers.ts
+var trim = (v) => typeof v === "string" ? v.trim() : v;
+var trimStart = (v) => typeof v === "string" ? v.trimStart() : v;
+var trimEnd = (v) => typeof v === "string" ? v.trimEnd() : v;
+var toLowerCase = (v) => typeof v === "string" ? v.toLowerCase() : v;
+var toUpperCase = (v) => typeof v === "string" ? v.toUpperCase() : v;
+var toTitleCase = (v) => typeof v === "string" ? v.replace(/\b\w/g, (c) => c.toUpperCase()) : v;
+var toSentenceCase = (v) => typeof v === "string" && v.length > 0 ? v.charAt(0).toUpperCase() + v.slice(1).toLowerCase() : v;
+var collapseSpaces = (v) => typeof v === "string" ? v.replace(/\s+/g, " ") : v;
+var toNumber = (v) => {
+  const coerced = Number(v);
+  return Number.isNaN(coerced) ? v : coerced;
+};
+var toInteger = (v) => {
+  const coerced = parseInt(String(v), 10);
+  return Number.isNaN(coerced) ? v : coerced;
+};
+var toFloat = (v) => {
+  const coerced = parseFloat(String(v));
+  return Number.isNaN(coerced) ? v : coerced;
+};
+var toBoolean = (v) => v === true || v === "true" || v === 1 || v === "1";
+function pipe(...fns) {
+  return (v) => fns.reduce((acc, fn) => fn(acc), v);
+}
+var t = {
+  // String
+  trim,
+  trimStart,
+  trimEnd,
+  toLowerCase,
+  toUpperCase,
+  toTitleCase,
+  toSentenceCase,
+  collapseSpaces,
+  // Coercion
+  toNumber,
+  toInteger,
+  toFloat,
+  toBoolean,
+  // Composition
+  pipe
+};
+
+// src/state/values.ts
+function createValuesState(defaultValues) {
+  return {
+    values: { ...defaultValues },
+    defaultValues: { ...defaultValues }
+  };
+}
+function updateValue(state, key, value) {
+  return {
+    ...state,
+    values: { ...state.values, [key]: value }
+  };
+}
+function resetValues(state, newValues) {
+  return {
+    values: { ...state.defaultValues, ...newValues },
+    defaultValues: state.defaultValues
+  };
+}
+function computeIsDirty(state) {
+  return Object.keys(state.defaultValues).some(
+    (key) => state.values[key] !== state.defaultValues[key]
+  );
+}
+function computeDirtyFields(state) {
+  const dirty = {};
+  for (const key of Object.keys(state.defaultValues)) {
+    if (state.values[key] !== state.defaultValues[key]) {
+      dirty[key] = true;
+    }
+  }
+  return dirty;
+}
+function isFieldDirty(state, key) {
+  return state.values[key] !== state.defaultValues[key];
+}
+function getValue(state, name) {
+  return state.values[name];
+}
+function getValues(state) {
+  return { ...state.values };
+}
+
+// src/state/touched.ts
+function createTouchedState() {
+  return {
+    touchedFields: /* @__PURE__ */ new Set()
+  };
+}
+function markTouched(state, name) {
+  if (state.touchedFields.has(name)) {
+    return state;
+  }
+  const newTouched = new Set(state.touchedFields);
+  newTouched.add(name);
+  return { touchedFields: newTouched };
+}
+function markUntouched(state, name) {
+  if (!state.touchedFields.has(name)) {
+    return state;
+  }
+  const newTouched = new Set(state.touchedFields);
+  newTouched.delete(name);
+  return { touchedFields: newTouched };
+}
+function resetTouched() {
+  return { touchedFields: /* @__PURE__ */ new Set() };
+}
+function isTouched(state, name) {
+  return state.touchedFields.has(name);
+}
+function toTouchedFieldsRecord(state) {
+  const record = {};
+  for (const field of state.touchedFields) {
+    record[field] = true;
+  }
+  return record;
+}
+
+// src/state/errors.ts
+function createErrorsState() {
+  return { errors: {} };
+}
+function setErrors(state, fieldErrors) {
+  const newErrors = { ...state.errors };
+  let changed = false;
+  for (const [field, error] of Object.entries(fieldErrors)) {
+    if (error === void 0) {
+      if (field in newErrors) {
+        delete newErrors[field];
+        changed = true;
+      }
+    } else {
+      if (newErrors[field]?.message !== error.message || newErrors[field]?.type !== error.type || newErrors[field]?.code !== error.code) {
+        newErrors[field] = error;
+        changed = true;
+      }
+    }
+  }
+  return changed ? { errors: newErrors } : state;
+}
+function setFieldError(state, name, error) {
+  if (error === null) {
+    if (!(name in state.errors)) {
+      return state;
+    }
+    const newErrors = { ...state.errors };
+    delete newErrors[name];
+    return { errors: newErrors };
+  }
+  const existing = state.errors[name];
+  if (existing?.message === error.message && existing?.type === error.type && existing?.code === error.code) {
+    return state;
+  }
+  return { errors: { ...state.errors, [name]: error } };
+}
+function clearFieldErrors(state, names) {
+  if (names === void 0) {
+    return Object.keys(state.errors).length > 0 ? { errors: {} } : state;
+  }
+  const fieldsToClear = Array.isArray(names) ? names : [names];
+  const newErrors = { ...state.errors };
+  let changed = false;
+  for (const name of fieldsToClear) {
+    if (name in newErrors) {
+      delete newErrors[name];
+      changed = true;
+    }
+  }
+  return changed ? { errors: newErrors } : state;
+}
+function resetErrors() {
+  return { errors: {} };
+}
+function hasErrors(state) {
+  return Object.keys(state.errors).length > 0;
+}
+function getFieldError(state, name) {
+  return state.errors[name];
+}
+function toFormErrors(state) {
+  return state.errors;
+}
+
+// src/state/submitting.ts
+function createSubmissionState() {
+  return {
+    isSubmitting: false,
+    isSubmitted: false,
+    isSubmitSuccessful: false,
+    submitCount: 0
+  };
+}
+function startSubmit(state) {
+  return {
+    ...state,
+    isSubmitting: true
+  };
+}
+function endSubmitSuccess(state) {
+  return {
+    isSubmitting: false,
+    isSubmitted: true,
+    isSubmitSuccessful: true,
+    submitCount: state.submitCount + 1
+  };
+}
+function endSubmitFailure(state) {
+  return {
+    ...state,
+    isSubmitting: false,
+    isSubmitted: true,
+    isSubmitSuccessful: false,
+    submitCount: state.submitCount + 1
+  };
+}
+function resetSubmission() {
+  return {
+    isSubmitting: false,
+    isSubmitted: false,
+    isSubmitSuccessful: false,
+    submitCount: 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearFieldErrors,
+  computeDirtyFields,
+  computeIsDirty,
+  createErrorsState,
+  createSchema,
+  createSubmissionState,
+  createTouchedState,
+  createValuesState,
+  endSubmitFailure,
+  endSubmitSuccess,
+  getFieldError,
+  getValue,
+  getValues,
+  hasErrors,
+  isFieldDirty,
+  isTouched,
+  markTouched,
+  markUntouched,
+  normalizeError,
+  resetErrors,
+  resetSubmission,
+  resetTouched,
+  resetValues,
+  setErrors,
+  setFieldError,
+  startSubmit,
+  t,
+  toFormErrors,
+  toTouchedFieldsRecord,
+  transformValues,
+  updateValue,
+  validateSchema
+});