elementdrawing 1.0.0

package/src/js/validator.js

@@ -0,0 +1,529 @@
+/**
+ * Form/Data Validation
+ * ElementDrawing Framework - Validation rules, composition, async validation,
+ * form/field validation, error messages, sanitization, schemas, type coercion,
+ * conditional and cross-field validation.
+ */
+
+'use strict';
+
+// ─── Validation Rules ─────────────────────────────────────────────────────────
+
+const rules = {
+  required: function (value) {
+    if (value === null || value === undefined) return false;
+    if (typeof value === 'string' && value.trim() === '') return false;
+    if (Array.isArray(value) && value.length === 0) return false;
+    return true;
+  },
+
+  minLength: function (value, min) {
+    if (value === null || value === undefined) return false;
+    return String(value).length >= min;
+  },
+
+  maxLength: function (value, max) {
+    if (value === null || value === undefined) return true;
+    return String(value).length <= max;
+  },
+
+  min: function (value, minVal) {
+    return Number(value) >= minVal;
+  },
+
+  max: function (value, maxVal) {
+    return Number(value) <= maxVal;
+  },
+
+  email: function (value) {
+    if (!value) return true;
+    return /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(value);
+  },
+
+  url: function (value) {
+    if (!value) return true;
+    try { new URL(value); return true; } catch (e) { return false; }
+  },
+
+  pattern: function (value, regex) {
+    if (!value) return true;
+    return regex.test(String(value));
+  },
+
+  numeric: function (value) {
+    if (!value && value !== 0) return true;
+    return !isNaN(Number(value));
+  },
+
+  integer: function (value) {
+    if (!value && value !== 0) return true;
+    return Number.isInteger(Number(value));
+  },
+
+  alpha: function (value) {
+    if (!value) return true;
+    return /^[a-zA-Z]+$/.test(value);
+  },
+
+  alphaNumeric: function (value) {
+    if (!value) return true;
+    return /^[a-zA-Z0-9]+$/.test(value);
+  },
+
+  date: function (value) {
+    if (!value) return true;
+    const d = new Date(value);
+    return !isNaN(d.getTime());
+  },
+
+  phone: function (value) {
+    if (!value) return true;
+    return /^[+]?[\d\s()-]{7,20}$/.test(value);
+  },
+
+  creditCard: function (value) {
+    if (!value) return true;
+    const cleaned = String(value).replace(/\D/g, '');
+    if (cleaned.length < 13 || cleaned.length > 19) return false;
+    // Luhn algorithm
+    let sum = 0, alternate = false;
+    for (let i = cleaned.length - 1; i >= 0; i--) {
+      let n = parseInt(cleaned[i], 10);
+      if (alternate) { n *= 2; if (n > 9) n -= 9; }
+      sum += n;
+      alternate = !alternate;
+    }
+    return sum % 10 === 0;
+  },
+
+  custom: function (value, validatorFn) {
+    if (typeof validatorFn !== 'function') return true;
+    return validatorFn(value);
+  },
+};
+
+// ─── Default Error Messages ───────────────────────────────────────────────────
+
+const defaultMessages = {
+  required: 'This field is required',
+  minLength: 'Must be at least {min} characters',
+  maxLength: 'Must be no more than {max} characters',
+  min: 'Must be at least {min}',
+  max: 'Must be no more than {max}',
+  email: 'Must be a valid email address',
+  url: 'Must be a valid URL',
+  pattern: 'Invalid format',
+  numeric: 'Must be a number',
+  integer: 'Must be an integer',
+  alpha: 'Must contain only letters',
+  alphaNumeric: 'Must contain only letters and numbers',
+  date: 'Must be a valid date',
+  phone: 'Must be a valid phone number',
+  creditCard: 'Must be a valid credit card number',
+  custom: 'Validation failed',
+};
+
+/**
+ * Get an error message for a rule, with parameter interpolation.
+ * @param {string} ruleName
+ * @param {Object} params
+ * @param {Object} [customMessages]
+ * @returns {string}
+ */
+function getMessage(ruleName, params, customMessages) {
+  const template = (customMessages && customMessages[ruleName]) || defaultMessages[ruleName] || 'Validation failed';
+  return template.replace(/\{(\w+)\}/g, (_, key) => params[key] !== undefined ? params[key] : '');
+}
+
+// ─── Validator Composition ────────────────────────────────────────────────────
+
+/**
+ * Create a validator that requires all rules to pass (AND).
+ * @param {...Function} validators
+ * @returns {Function}
+ */
+function and() {
+  const validators = Array.prototype.slice.call(arguments);
+  return function (value) {
+    for (const validator of validators) {
+      const result = validator(value);
+      if (result !== true) return result;
+    }
+    return true;
+  };
+}
+
+/**
+ * Create a validator that requires at least one rule to pass (OR).
+ * @param {...Function} validators
+ * @returns {Function}
+ */
+function or() {
+  const validators = Array.prototype.slice.call(arguments);
+  return function (value) {
+    const errors = [];
+    for (const validator of validators) {
+      const result = validator(value);
+      if (result === true) return true;
+      errors.push(result);
+    }
+    return errors[0]; // Return first error
+  };
+}
+
+/**
+ * Create a validator that negates another validator.
+ * @param {Function} validator
+ * @returns {Function}
+ */
+function not(validator) {
+  return function (value) {
+    const result = validator(value);
+    return result === true ? 'Value should not match this rule' : true;
+  };
+}
+
+/**
+ * Create a conditional validator that only applies when a condition is met.
+ * @param {Function} condition - (value, allValues) => boolean
+ * @param {Function} validator
+ * @returns {Function}
+ */
+function when(condition, validator) {
+  return function (value, allValues) {
+    if (condition(value, allValues)) {
+      return validator(value, allValues);
+    }
+    return true;
+  };
+}
+
+// ─── Field Validation ─────────────────────────────────────────────────────────
+
+/**
+ * Create a field validator from a rule configuration.
+ * @param {Object} config
+ * @param {Array} config.rules - Array of { rule, params, message }
+ * @param {Function} [config.transform] - Transform value before validation
+ * @returns {Function} Validator function
+ */
+function createFieldValidator(config) {
+  const fieldRules = config.rules || [];
+  const transform = config.transform;
+
+  return function validateField(value, allValues) {
+    const val = transform ? transform(value) : value;
+    const errors = [];
+
+    for (const ruleConfig of fieldRules) {
+      const ruleName = ruleConfig.rule;
+      const ruleParams = ruleConfig.params || {};
+      const customMessage = ruleConfig.message;
+
+      const ruleFn = typeof ruleName === 'function' ? ruleName : rules[ruleName];
+      if (!ruleFn) continue;
+
+      const args = ruleName === 'custom' ? [val, ruleParams.validator] : [val];
+
+      // Add params as additional arguments for rules that need them
+      if (ruleName === 'minLength' && ruleParams.min !== undefined) args.push(ruleParams.min);
+      if (ruleName === 'maxLength' && ruleParams.max !== undefined) args.push(ruleParams.max);
+      if (ruleName === 'min' && ruleParams.min !== undefined) args.push(ruleParams.min);
+      if (ruleName === 'max' && ruleParams.max !== undefined) args.push(ruleParams.max);
+      if (ruleName === 'pattern' && ruleParams.regex) args.push(ruleParams.regex);
+
+      const result = ruleFn.apply(null, args);
+
+      if (result !== true) {
+        const message = customMessage || getMessage(ruleName, ruleParams);
+        errors.push(message);
+      }
+    }
+
+    return errors.length === 0 ? true : errors;
+  };
+}
+
+// ─── Async Validation ─────────────────────────────────────────────────────────
+
+/**
+ * Create an async validator.
+ * @param {Function} asyncFn - (value, allValues) => Promise<boolean|string>
+ * @returns {Function} Async validator function
+ */
+function asyncValidator(asyncFn) {
+  return function (value, allValues) {
+    return Promise.resolve(asyncFn(value, allValues)).then((result) => {
+      if (result === true) return true;
+      if (typeof result === 'string') return [result];
+      return ['Async validation failed'];
+    }).catch((error) => {
+      return [error.message || 'Async validation error'];
+    });
+  };
+}
+
+// ─── Form Validation ──────────────────────────────────────────────────────────
+
+/**
+ * Create a form validator from a schema.
+ * @param {Object} schema - Field name to validator mapping
+ * @returns {Object} Form validator with validate method
+ */
+function createFormValidator(schema) {
+  const fieldValidators = {};
+  const crossFieldValidators = [];
+
+  Object.keys(schema).forEach((fieldName) => {
+    const fieldConfig = schema[fieldName];
+    if (typeof fieldConfig === 'function') {
+      fieldValidators[fieldName] = fieldConfig;
+    } else if (fieldConfig.rules) {
+      fieldValidators[fieldName] = createFieldValidator(fieldConfig);
+    } else if (fieldConfig.crossField) {
+      crossFieldValidators.push({
+        fields: fieldConfig.fields,
+        validator: fieldConfig.validator,
+        message: fieldConfig.message,
+      });
+    } else {
+      fieldValidators[fieldName] = createFieldValidator({ rules: Array.isArray(fieldConfig) ? fieldConfig : [fieldConfig] });
+    }
+  });
+
+  return {
+    /**
+     * Validate a single field.
+     * @param {string} fieldName
+     * @param {*} value
+     * @param {Object} [allValues]
+     * @returns {true|Array<string>}
+     */
+    validateField: function (fieldName, value, allValues) {
+      const validator = fieldValidators[fieldName];
+      if (!validator) return true;
+      return validator(value, allValues || {});
+    },
+
+    /**
+     * Validate all fields in the form.
+     * @param {Object} values - Field name to value mapping
+     * @returns {Object} { valid: boolean, errors: { [fieldName]: string[] } }
+     */
+    validate: function (values) {
+      const errors = {};
+      let valid = true;
+
+      // Validate each field
+      Object.keys(fieldValidators).forEach((fieldName) => {
+        const result = fieldValidators[fieldName](values[fieldName], values);
+        if (result !== true) {
+          errors[fieldName] = Array.isArray(result) ? result : [result];
+          valid = false;
+        }
+      });
+
+      // Run cross-field validators
+      crossFieldValidators.forEach((crossVal) => {
+        const result = crossVal.validator(values);
+        if (result !== true) {
+          const message = crossVal.message || result;
+          crossVal.fields.forEach((f) => {
+            if (!errors[f]) errors[f] = [];
+            errors[f].push(typeof message === 'string' ? message : 'Cross-field validation failed');
+          });
+          valid = false;
+        }
+      });
+
+      return { valid, errors };
+    },
+
+    /**
+     * Async validation for all fields.
+     * @param {Object} values
+     * @returns {Promise<Object>}
+     */
+    validateAsync: async function (values) {
+      const errors = {};
+      let valid = true;
+
+      const promises = Object.keys(fieldValidators).map(async (fieldName) => {
+        const result = await Promise.resolve(fieldValidators[fieldName](values[fieldName], values));
+        if (result !== true) {
+          errors[fieldName] = Array.isArray(result) ? result : [result];
+          valid = false;
+        }
+      });
+
+      await Promise.all(promises);
+      return { valid, errors };
+    },
+
+    /**
+     * Validate and return only the first error for each field.
+     * @param {Object} values
+     * @returns {Object} { valid, errors: { [fieldName]: string } }
+     */
+    validateFirst: function (values) {
+      const result = this.validate(values);
+      const firstErrors = {};
+      Object.keys(result.errors).forEach((k) => {
+        firstErrors[k] = result.errors[k][0];
+      });
+      return { valid: result.valid, errors: firstErrors };
+    },
+  };
+}
+
+// ─── Schema Definition ────────────────────────────────────────────────────────
+
+/**
+ * Define a validation schema fluently.
+ * @returns {Object} Schema builder
+ */
+function schema() {
+  const fields = {};
+
+  return {
+    field: function (name) {
+      const fieldRules = [];
+      const builder = {
+        required: function (msg) { fieldRules.push({ rule: 'required', message: msg }); return builder; },
+        minLength: function (min, msg) { fieldRules.push({ rule: 'minLength', params: { min }, message: msg }); return builder; },
+        maxLength: function (max, msg) { fieldRules.push({ rule: 'maxLength', params: { max }, message: msg }); return builder; },
+        min: function (minVal, msg) { fieldRules.push({ rule: 'min', params: { min: minVal }, message: msg }); return builder; },
+        max: function (maxVal, msg) { fieldRules.push({ rule: 'max', params: { max: maxVal }, message: msg }); return builder; },
+        email: function (msg) { fieldRules.push({ rule: 'email', message: msg }); return builder; },
+        url: function (msg) { fieldRules.push({ rule: 'url', message: msg }); return builder; },
+        pattern: function (regex, msg) { fieldRules.push({ rule: 'pattern', params: { regex }, message: msg }); return builder; },
+        numeric: function (msg) { fieldRules.push({ rule: 'numeric', message: msg }); return builder; },
+        integer: function (msg) { fieldRules.push({ rule: 'integer', message: msg }); return builder; },
+        custom: function (fn, msg) { fieldRules.push({ rule: 'custom', params: { validator: fn }, message: msg }); return builder; },
+        end: function () { return schema(); },
+      };
+
+      fields[name] = fieldRules;
+      return builder;
+    },
+
+    build: function () {
+      const formSchema = {};
+      Object.keys(fields).forEach((name) => {
+        formSchema[name] = { rules: fields[name] };
+      });
+      return createFormValidator(formSchema);
+    },
+  };
+}
+
+// ─── Sanitization ─────────────────────────────────────────────────────────────
+
+const sanitizers = {
+  trim: function (value) { return typeof value === 'string' ? value.trim() : value; },
+  escape: function (value) {
+    if (typeof value !== 'string') return value;
+    const map = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
+    return value.replace(/[&<>"']/g, (c) => map[c]);
+  },
+  normalize: function (value) { return typeof value === 'string' ? value.normalize() : value; },
+  stripHtml: function (value) { return typeof value === 'string' ? value.replace(/<[^>]*>/g, '') : value; },
+  toNumber: function (value) { const n = Number(value); return isNaN(n) ? value : n; },
+  toDate: function (value) { const d = new Date(value); return isNaN(d.getTime()) ? value : d; },
+  toLowerCase: function (value) { return typeof value === 'string' ? value.toLowerCase() : value; },
+  toUpperCase: function (value) { return typeof value === 'string' ? value.toUpperCase() : value; },
+  toBoolean: function (value) {
+    if (typeof value === 'string') {
+      if (value.toLowerCase() === 'true' || value === '1') return true;
+      if (value.toLowerCase() === 'false' || value === '0') return false;
+    }
+    return Boolean(value);
+  },
+  truncate: function (value, maxLen) {
+    if (typeof value !== 'string') return value;
+    return value.length > maxLen ? value.slice(0, maxLen) : value;
+  },
+};
+
+// ─── Type Coercion ────────────────────────────────────────────────────────────
+
+/**
+ * Coerce a value to a specific type.
+ * @param {*} value
+ * @param {string} type - 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date'
+ * @returns {*}
+ */
+function coerce(value, type) {
+  switch (type) {
+    case 'string': return String(value);
+    case 'number': { const n = Number(value); return isNaN(n) ? value : n; }
+    case 'boolean': return sanitizers.toBoolean(value);
+    case 'array': return Array.isArray(value) ? value : [value];
+    case 'object': return typeof value === 'object' && value !== null ? value : { value };
+    case 'date': { const d = new Date(value); return isNaN(d.getTime()) ? value : d; }
+    default: return value;
+  }
+}
+
+// ─── Cross-Field Validation ───────────────────────────────────────────────────
+
+/**
+ * Create a cross-field validator.
+ * @param {string[]} fields - Field names involved
+ * @param {Function} validator - (values) => boolean | string
+ * @param {string} [message]
+ * @returns {Object}
+ */
+function crossField(fields, validator, message) {
+  return { fields, validator, message, crossField: true };
+}
+
+/**
+ * Pre-built cross-field validators.
+ */
+const crossFieldRules = {
+  match: function (field1, field2, message) {
+    return crossField([field1, field2], (values) => {
+      return values[field1] === values[field2];
+    }, message || field1 + ' and ' + field2 + ' must match');
+  },
+
+  different: function (field1, field2, message) {
+    return crossField([field1, field2], (values) => {
+      return values[field1] !== values[field2];
+    }, message || field1 + ' and ' + field2 + ' must be different');
+  },
+
+  requiredIf: function (field, conditionField, message) {
+    return crossField([field, conditionField], (values) => {
+      if (values[conditionField]) return rules.required(values[field]);
+      return true;
+    }, message || field + ' is required when ' + conditionField + ' is set');
+  },
+
+  greaterThan: function (field1, field2, message) {
+    return crossField([field1, field2], (values) => {
+      return Number(values[field1]) > Number(values[field2]);
+    }, message || field1 + ' must be greater than ' + field2);
+  },
+};
+
+// ─── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+  rules,
+  defaultMessages,
+  getMessage,
+  and,
+  or,
+  not,
+  when,
+  createFieldValidator,
+  asyncValidator,
+  createFormValidator,
+  schema,
+  sanitizers,
+  coerce,
+  crossField,
+  crossFieldRules,
+};