@tachybase/schema 0.23.41 → 0.23.48

package/lib/validator/rules.js

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var rules_exports = {};
+__export(rules_exports, {
+  default: () => rules_default
+});
+module.exports = __toCommonJS(rules_exports);
+var import_shared = require("../shared");
+var import_registry = require("./registry");
+const isValidateEmpty = /* @__PURE__ */ __name((value) => {
+  var _a;
+  if ((0, import_shared.isArr)(value)) {
+    for (let i = 0; i < value.length; i++) {
+      if ((0, import_shared.isValid)(value[i])) return false;
+    }
+    return true;
+  } else {
+    if (value == null ? void 0 : value.getCurrentContent) {
+      return !((_a = value.getCurrentContent()) == null ? void 0 : _a.hasText());
+    }
+    return (0, import_shared.isEmpty)(value);
+  }
+}, "isValidateEmpty");
+const getLength = /* @__PURE__ */ __name((value) => (0, import_shared.isStr)(value) ? (0, import_shared.stringLength)(value) : value ? value.length : 0, "getLength");
+const extendSameRules = /* @__PURE__ */ __name((rules, names) => {
+  (0, import_shared.each)(names, (realName, name) => {
+    rules[name] = (value, rule, ...args) => rules[realName](value, { ...rule, [realName]: rule[name] }, ...args);
+  });
+}, "extendSameRules");
+const RULES = {
+  format(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    if (rule.format) {
+      const format = (0, import_registry.getValidateFormats)(rule.format);
+      if (format) {
+        return !new RegExp(format).test(value) ? rule.message : "";
+      }
+    }
+    return "";
+  },
+  required(value, rule) {
+    if (rule.required === false) return "";
+    return isValidateEmpty(value) ? rule.message : "";
+  },
+  max(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    const length = (0, import_shared.isNum)(value) ? value : getLength(value);
+    const max = Number(rule.max);
+    return length > max ? rule.message : "";
+  },
+  min(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    const length = (0, import_shared.isNum)(value) ? value : getLength(value);
+    const min = Number(rule.min);
+    return length < min ? rule.message : "";
+  },
+  exclusiveMaximum(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    const length = (0, import_shared.isNum)(value) ? value : getLength(value);
+    const max = Number(rule.exclusiveMaximum);
+    return length >= max ? rule.message : "";
+  },
+  exclusiveMinimum(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    const length = (0, import_shared.isNum)(value) ? value : getLength(value);
+    const min = Number(rule.exclusiveMinimum);
+    return length <= min ? rule.message : "";
+  },
+  len(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    const length = getLength(value);
+    const len = Number(rule.len);
+    return length !== len ? rule.message : "";
+  },
+  pattern(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    return !new RegExp(rule.pattern).test(value) ? rule.message : "";
+  },
+  async validator(value, rule, context, format) {
+    if ((0, import_shared.isFn)(rule.validator)) {
+      const response = await Promise.resolve(rule.validator(value, rule, context, format));
+      if ((0, import_shared.isBool)(response)) {
+        return !response ? rule.message : "";
+      } else {
+        return response;
+      }
+    }
+    throw new Error("The rule's validator property must be a function.");
+  },
+  whitespace(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    if (rule.whitespace) {
+      return /^\s+$/.test(value) ? rule.message : "";
+    }
+  },
+  enum(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    const enums = (0, import_shared.toArr)(rule.enum);
+    return enums.indexOf(value) === -1 ? rule.message : "";
+  },
+  const(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    return rule.const !== value ? rule.message : "";
+  },
+  multipleOf(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    return Number(value) % Number(rule.multipleOf) !== 0 ? rule.message : "";
+  },
+  uniqueItems(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    value = (0, import_shared.toArr)(value);
+    return value.some((item, index) => {
+      for (let i = 0; i < value.length; i++) {
+        if (i !== index && !(0, import_shared.isEqual)(value[i], item)) {
+          return false;
+        }
+      }
+      return true;
+    }) ? "" : rule.message;
+  },
+  maxProperties(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    return Object.keys(value || {}).length <= Number(rule.maxProperties) ? "" : rule.message;
+  },
+  minProperties(value, rule) {
+    if (isValidateEmpty(value)) return "";
+    return Object.keys(value || {}).length >= Number(rule.minProperties) ? "" : rule.message;
+  }
+};
+extendSameRules(RULES, {
+  maximum: "max",
+  minimum: "min",
+  maxItems: "max",
+  minItems: "min",
+  maxLength: "max",
+  minLength: "min"
+});
+var rules_default = RULES;

package/lib/validator/template.d.ts

@@ -0,0 +1,2 @@
+import { IValidateResult, IValidatorRules } from './types';
+export declare const render: (result: IValidateResult, rules: IValidatorRules) => IValidateResult;

package/lib/validator/template.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var template_exports = {};
+__export(template_exports, {
+  render: () => render
+});
+module.exports = __toCommonJS(template_exports);
+var import_shared = require("../shared");
+var import_registry = require("./registry");
+const render = /* @__PURE__ */ __name((result, rules) => {
+  const { message } = result;
+  if ((0, import_shared.isStr)(message)) {
+    const template = (0, import_registry.getValidateMessageTemplateEngine)();
+    if ((0, import_shared.isFn)(template)) {
+      result.message = template(message, rules);
+    }
+    result.message = result.message.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_, $0) => {
+      return import_shared.FormPath.getIn(rules, $0);
+    });
+  }
+  return result;
+}, "render");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render
+});

package/lib/validator/types.d.ts

@@ -0,0 +1,62 @@
+export type ValidatorFormats = 'url' | 'email' | 'ipv6' | 'ipv4' | 'number' | 'integer' | 'idcard' | 'qq' | 'phone' | 'money' | 'zh' | 'date' | 'zip' | (string & {});
+export interface IValidateResult {
+    type: 'error' | 'warning' | 'success' | (string & {});
+    message: string;
+}
+export interface IValidateResults {
+    error?: string[];
+    warning?: string[];
+    success?: string[];
+}
+export declare const isValidateResult: (obj: any) => obj is IValidateResult;
+export type ValidatorFunctionResponse = null | string | boolean | IValidateResult;
+export type ValidatorFunction<Context = any> = (value: any, rule: IValidatorRules<Context>, ctx: Context, render: (message: string, scope?: any) => string) => ValidatorFunctionResponse | Promise<ValidatorFunctionResponse> | null;
+export type ValidatorParsedFunction<Context = any> = (value: any, ctx: Context) => IValidateResult | Promise<IValidateResult> | null;
+export type ValidatorTriggerType = 'onInput' | 'onFocus' | 'onBlur' | (string & {});
+export interface IValidatorRules<Context = any> {
+    triggerType?: ValidatorTriggerType;
+    format?: ValidatorFormats;
+    validator?: ValidatorFunction<Context>;
+    required?: boolean;
+    pattern?: RegExp | string;
+    max?: number;
+    maximum?: number;
+    maxItems?: number;
+    minItems?: number;
+    maxLength?: number;
+    minLength?: number;
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    minimum?: number;
+    min?: number;
+    len?: number;
+    whitespace?: boolean;
+    enum?: any[];
+    const?: any;
+    multipleOf?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    message?: string;
+    [key: string]: any;
+}
+export interface IRegistryLocaleMessages {
+    [key: string]: string | IRegistryLocaleMessages;
+}
+export interface IRegistryLocales {
+    [language: string]: IRegistryLocaleMessages;
+}
+export interface IRegistryRules<Context = any> {
+    [key: string]: ValidatorFunction<Context>;
+}
+export interface IRegistryFormats {
+    [key: string]: string | RegExp;
+}
+export type ValidatorDescription<Context = any> = ValidatorFormats | ValidatorFunction<Context> | IValidatorRules<Context>;
+export type MultiValidator<Context = any> = ValidatorDescription<Context>[];
+export type Validator<Context = any> = ValidatorDescription<Context> | MultiValidator<Context>;
+export interface IValidatorOptions<Context = any> {
+    validateFirst?: boolean;
+    triggerType?: ValidatorTriggerType;
+    context?: Context;
+}

package/lib/validator/types.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var types_exports = {};
+__export(types_exports, {
+  isValidateResult: () => isValidateResult
+});
+module.exports = __toCommonJS(types_exports);
+const isValidateResult = /* @__PURE__ */ __name((obj) => !!obj["type"] && !!obj["message"], "isValidateResult");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isValidateResult
+});

package/lib/validator/validator.d.ts

@@ -0,0 +1,2 @@
+import { IValidateResults, IValidatorOptions, Validator } from './types';
+export declare const validate: <Context = any>(value: any, validator: Validator<Context>, options?: IValidatorOptions<Context>) => Promise<IValidateResults>;

package/lib/validator/validator.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validator_exports = {};
+__export(validator_exports, {
+  validate: () => validate
+});
+module.exports = __toCommonJS(validator_exports);
+var import_formats = __toESM(require("./formats"));
+var import_locale = __toESM(require("./locale"));
+var import_parser = require("./parser");
+var import_registry = require("./registry");
+var import_rules = __toESM(require("./rules"));
+(0, import_registry.registerValidateRules)(import_rules.default);
+(0, import_registry.registerValidateLocale)(import_locale.default);
+(0, import_registry.registerValidateFormats)(import_formats.default);
+const validate = /* @__PURE__ */ __name(async (value, validator, options) => {
+  const validates = (0, import_parser.parseValidator)(validator, options);
+  const results = {
+    error: [],
+    success: [],
+    warning: []
+  };
+  for (let i = 0; i < validates.length; i++) {
+    const result = await validates[i](value, options == null ? void 0 : options.context);
+    const { type, message } = result;
+    results[type] = results[type] || [];
+    if (message) {
+      results[type].push(message);
+      if (options == null ? void 0 : options.validateFirst) break;
+    }
+  }
+  return results;
+}, "validate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validate
+});

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@tachybase/schema",
-  "version": "0.23.41",
+  "version": "0.23.48",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "dependencies": {
-    "@formily/core": "2.3.2",
-    "@formily/grid": "2.3.2",
-    "@formily/json-schema": "2.3.2",
-    "@formily/path": "2.3.2",
-    "@formily/react": "2.3.2",
-    "@formily/reactive": "2.3.2",
-    "@formily/reactive-react": "2.3.2",
-    "@formily/shared": "2.3.2",
-    "@formily/validator": "2.3.2"
+    "camel-case": "^4.1.1",
+    "hoist-non-react-statics": "^3.3.2",
+    "lower-case": "^2.0.1",
+    "param-case": "^3.0.4",
+    "pascal-case": "^3.1.1",
+    "upper-case": "^2.0.1"
+  },
+  "devDependencies": {
+    "@testing-library/react": "16.2.0",
+    "immutable": "5.0.3",
+    "moment": "2.30.1",
+    "vitest": "3.0.5"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0"
   },
   "scripts": {
     "build": "tachybase-build --no-dts @tachybase/schema"