2025/2/8第一次更新

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/any.ts

@@ -0,0 +1,18 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const any: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+  }
+  callback(errors);
+};
+
+export default any;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/array.ts

@@ -0,0 +1,21 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule/index';
+
+const array: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if ((value === undefined || value === null) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, 'array');
+    if (value !== undefined && value !== null) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default array;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/boolean.ts

@@ -0,0 +1,21 @@
+import { isEmptyValue } from '../util';
+import rules from '../rule';
+import type { ExecuteValidator } from '../interface';
+
+const boolean: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default boolean;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/date.ts

@@ -0,0 +1,34 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const date: ExecuteValidator = (rule, value, callback, source, options) => {
+  // console.log('integer rule called %j', rule);
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  // console.log('validate on %s value', value);
+  if (validate) {
+    if (isEmptyValue(value, 'date') && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, 'date')) {
+      let dateObject;
+
+      if (value instanceof Date) {
+        dateObject = value;
+      } else {
+        dateObject = new Date(value);
+      }
+
+      rules.type(rule, dateObject, source, errors, options);
+      if (dateObject) {
+        rules.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+
+export default date;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/enum.ts

@@ -0,0 +1,29 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const ENUM = 'enum' as const;
+
+const enumerable: ExecuteValidator = (
+  rule,
+  value,
+  callback,
+  source,
+  options,
+) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules[ENUM](rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default enumerable;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/float.ts

@@ -0,0 +1,22 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const floatFn: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default floatFn;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/index.ts

@@ -0,0 +1,35 @@
+import string from './string';
+import method from './method';
+import number from './number';
+import boolean from './boolean';
+import regexp from './regexp';
+import integer from './integer';
+import float from './float';
+import array from './array';
+import object from './object';
+import enumValidator from './enum';
+import pattern from './pattern';
+import date from './date';
+import required from './required';
+import type from './type';
+import any from './any';
+
+export default {
+  string,
+  method,
+  number,
+  boolean,
+  regexp,
+  integer,
+  float,
+  array,
+  object,
+  enum: enumValidator,
+  pattern,
+  date,
+  url: type,
+  hex: type,
+  email: type,
+  required,
+  any,
+};

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/integer.ts

@@ -0,0 +1,22 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const integer: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default integer;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/method.ts

@@ -0,0 +1,21 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const method: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default method;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/number.ts

@@ -0,0 +1,25 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const number: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (value === '') {
+      value = undefined;
+    }
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default number;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/object.ts

@@ -0,0 +1,21 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const object: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default object;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/pattern.ts

@@ -0,0 +1,21 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const pattern: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value, 'string') && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, 'string')) {
+      rules.pattern(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default pattern;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/regexp.ts

@@ -0,0 +1,21 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const regexp: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default regexp;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/required.ts

@@ -0,0 +1,11 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+
+const required: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const type = Array.isArray(value) ? 'array' : typeof value;
+  rules.required(rule, value, source, errors, options, type);
+  callback(errors);
+};
+
+export default required;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/string.ts

@@ -0,0 +1,26 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const string: ExecuteValidator = (rule, value, callback, source, options) => {
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value, 'string') && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, 'string');
+    if (!isEmptyValue(value, 'string')) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+      rules.pattern(rule, value, source, errors, options);
+      if (rule.whitespace === true) {
+        rules.whitespace(rule, value, source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+
+export default string;

node_modules/@tuniao/tnui-vue3-uniapp/libs/async-validator/validator/type.ts

@@ -0,0 +1,22 @@
+import type { ExecuteValidator } from '../interface';
+import rules from '../rule';
+import { isEmptyValue } from '../util';
+
+const type: ExecuteValidator = (rule, value, callback, source, options) => {
+  const ruleType = rule.type;
+  const errors: string[] = [];
+  const validate =
+    rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+  if (validate) {
+    if (isEmptyValue(value, ruleType) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, ruleType);
+    if (!isEmptyValue(value, ruleType)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+
+export default type;