@unicom-cloud/utils 0.1.24 → 0.1.25

package/tween/index.js

@@ -0,0 +1,8 @@
+/* 2025-11-03 10:27:31 */
+import * as e from "./src/easing.js";
+import { default as r, default as t } from "./src/tween.js";
+export {
+  r as Tween,
+  t as default,
+  e as easing
+};

package/tween/src/easing.js

@@ -0,0 +1,62 @@
+/* 2025-11-03 10:27:31 */
+function u(n) {
+  return function(t) {
+    return Math.pow(t, n);
+  };
+}
+function r(n) {
+  return function(t) {
+    return 1 - Math.abs(Math.pow(t - 1, n));
+  };
+}
+function c(n) {
+  return function(t) {
+    return t < 0.5 ? u(n)(t * 2) / 2 : r(n)(t * 2 - 1) / 2 + 0.5;
+  };
+}
+function s(n) {
+  return n;
+}
+const a = u(2), I = r(2), f = c(2), O = u(3), h = r(3), M = c(3), p = u(4), q = r(4), b = c(4), P = u(5), d = r(5), l = c(5);
+function y(n) {
+  return 1 + Math.sin(Math.PI / 2 * n - Math.PI / 2);
+}
+function B(n) {
+  return Math.sin(Math.PI / 2 * n);
+}
+function w(n) {
+  return (1 + Math.sin(Math.PI * n - Math.PI / 2)) / 2;
+}
+function e(n) {
+  return n < 1 / 2.75 ? 7.5625 * n * n : n < 2 / 2.75 ? (n -= 1.5 / 2.75, 7.5625 * n * n + 0.75) : n < 2.5 / 2.75 ? (n -= 2.25 / 2.75, 7.5625 * n * n + 0.9375) : (n -= 2.625 / 2.75, 7.5625 * n * n + 0.984375);
+}
+function o(n) {
+  return 1 - e(1 - n);
+}
+function x(n) {
+  return n < 0.5 ? o(n * 2) * 0.5 : e(n * 2 - 1) * 0.5 + 0.5;
+}
+export {
+  o as bounceIn,
+  x as bounceInOut,
+  e as bounceOut,
+  O as cubicIn,
+  M as cubicInOut,
+  h as cubicOut,
+  u as easeInBy,
+  c as easeInOutBy,
+  r as easeOutBy,
+  s as linear,
+  a as quadIn,
+  f as quadInOut,
+  I as quadOut,
+  p as quartIn,
+  b as quartInOut,
+  q as quartOut,
+  P as quintIn,
+  l as quintInOut,
+  d as quintOut,
+  y as sineIn,
+  w as sineInOut,
+  B as sineOut
+};

package/tween/src/tween.js

@@ -0,0 +1,46 @@
+/* 2025-11-03 10:27:31 */
+import n from "lodash/isFunction.js";
+import d from "lodash/isString.js";
+import * as l from "./easing.js";
+import { linear as u } from "./easing.js";
+class F {
+  constructor(i) {
+    const {
+      from: s,
+      to: e,
+      duration: a = 500,
+      delay: r = 0,
+      easing: h,
+      onStart: o,
+      onUpdate: f = function() {
+      },
+      onFinish: m
+    } = i;
+    for (const t in s)
+      e[t] === void 0 && (e[t] = s[t]);
+    for (const t in e)
+      s[t] === void 0 && (s[t] = e[t]);
+    this.from = s, this.to = e, this.duration = a, this.delay = r, n(h) ? this.easing = h : d(h) && (this.easing = l[h]), this.easing ||= u, this.onStart = o, this.onUpdate = f, this.onFinish = m, this.startTime = Date.now() + this.delay, this.started = !1, this.finished = !1, this.timer = null, this.keys = {};
+  }
+  update() {
+    if (this.time = Date.now(), !(this.time < this.startTime) && !this.finished) {
+      this.elapsed = this.time - this.startTime, this.elapsed = Math.min(this.elapsed, this.duration);
+      for (const i in this.to)
+        this.keys[i] = this.from[i] + (this.to[i] - this.from[i]) * this.easing(this.elapsed / this.duration);
+      this.started || (n(this.onStart) && this.onStart(this.keys), this.started = !0), n(this.onUpdate) && this.onUpdate(this.keys), this.elapsed === this.duration && !this.finished && (this.finished = !0, n(this.onFinish) && this.onFinish(this.keys));
+    }
+  }
+  start() {
+    this.startTime = Date.now() + this.delay, this.started = !1, this.finished = !1;
+    const i = () => {
+      this.update(), this.finished ? this.timer && (cancelAnimationFrame(this.timer), this.timer = null) : this.timer = requestAnimationFrame(i);
+    };
+    this.timer = requestAnimationFrame(i);
+  }
+  stop() {
+    this.timer && (cancelAnimationFrame(this.timer), this.timer = null), this.finished = !0;
+  }
+}
+export {
+  F as default
+};

package/tween.js

@@ -0,0 +1,8 @@
+/* 2025-11-03 10:27:31 */
+import * as e from "./tween/src/easing.js";
+import { default as r, default as t } from "./tween/src/tween.js";
+export {
+  r as Tween,
+  t as default,
+  e as easing
+};

package/types/dom-helpers/types.d.ts

@@ -2,3 +2,5 @@ import * as CSS from 'csstype';
 export type HyphenProperty = keyof CSS.PropertiesHyphen;
 export type CamelProperty = keyof CSS.Properties;
 export type Property = HyphenProperty | CamelProperty;
+declare const _default: {};
+export default _default;

package/types/normalize-wheel/index.d.ts

@@ -111,5 +111,5 @@ declare namespace normalizeWheel {
      * the older DOMMouseScroll for Firefox, as FF does not include wheelDelta with
      * 'wheel' event, making spin speed determination impossible.
      */
-    function getEventType(): "wheel" | "DOMMouseScroll" | "mousewheel";
+    function getEventType(): "DOMMouseScroll" | "wheel" | "mousewheel";
 }

package/types/snapdom/src/api/snapdom.d.ts

@@ -1,5 +1,7 @@
 /**
  * Main function that captures a DOM element and returns export utilities.
+ * Local-first plugins: `options.plugins` override globals for this capture.
+ *
  * @param {HTMLElement} element - The DOM element to capture.
  * @param {object} userOptions - Options for rendering/exporting.
  * @returns {Promise<object>} Object with exporter methods:
@@ -17,8 +19,10 @@
  */
 export function snapdom(element: HTMLElement, userOptions: object): Promise<object>;
 export namespace snapdom {
+    function plugins(...defs: any[]): typeof snapdom;
     /**
      * Internal capture method that returns helper methods for transformation/export.
+     * Integrates export hooks: beforeExport → work() → afterExport → afterSnap(once per URL)
      * @private
      * @param {HTMLElement} el - The DOM element to capture.
      * @param {object} context - Normalized context options.

package/types/snapdom/src/core/capture.d.ts

@@ -8,22 +8,8 @@
  * @param {number} [options.scale=1] - Output scale multiplier
  * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
  * @param {Function} [options.filter] - Custom filter function
- * @param {boolean} [options.straighten=false] - Normalize root by removing translate*rotate* (keep scale/skew)
- * @param {boolean} [options.noShadows=false] - Do not expand bleed for shadows/blur/outline on root (and strip root shadows visually)
- * @returns {Promise<string>} Promise that resolves to an SVG data URL
- */
-/**
- * Captures an HTML element as an SVG data URL, inlining styles, images, backgrounds, and optionally fonts.
- *
- * @param {Element} element - DOM element to capture
- * @param {Object} [options={}] - Capture options
- * @param {boolean} [options.embedFonts=false] - Whether to embed custom fonts
- * @param {boolean} [options.fast=true] - Whether to skip idle delay for faster results
- * @param {number} [options.scale=1] - Output scale multiplier
- * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
- * @param {Function} [options.filter] - Custom filter function
- * @param {boolean} [options.straighten=false] - Normalize root by removing translate/rotate (keep scale/skew)
- * @param {boolean} [options.noShadows=false] - Do not expand bleed for shadows/blur/outline on root (and strip root shadows visually)
+ * @param {boolean} [options.outerTransforms=false] - Normalize root by removing translate/rotate (keep scale/skew)
+ * @param {boolean} [options.outerShadows=false] - Do not expand bleed for shadows/blur/outline on root (and strip root shadows visually)
  * @returns {Promise<string>} Promise that resolves to an SVG data URL
  */
 export function captureDOM(element: Element, options?: {
@@ -32,6 +18,6 @@ export function captureDOM(element: Element, options?: {
     scale?: number | undefined;
     exclude?: string[] | undefined;
     filter?: Function | undefined;
-    straighten?: boolean | undefined;
-    noShadows?: boolean | undefined;
+    outerTransforms?: boolean | undefined;
+    outerShadows?: boolean | undefined;
 }): Promise<string>;

package/types/snapdom/src/core/context.d.ts

@@ -34,8 +34,8 @@ export function normalizeCachePolicy(v: unknown): CachePolicy;
  * @param {string|null} [options.backgroundColor]
  * @param {string}  [options.filename]
  * @param {unknown} [options.cache] // "disabled"|"full"|"auto"|"soft"
- * @param {boolean} [options.straighten] // NEW
- * @param {boolean} [options.noShadows]      // NEW
+ * @param {boolean} [options.outerTransforms] // NEW
+ * @param {boolean} [options.outerShadows]      // NEW
  * @returns {Object}
  */
 export function createContext(options?: {
@@ -61,7 +61,7 @@ export function createContext(options?: {
     backgroundColor?: string | null | undefined;
     filename?: string | undefined;
     cache?: unknown;
-    straighten?: boolean | undefined;
-    noShadows?: boolean | undefined;
+    outerTransforms?: boolean | undefined;
+    outerShadows?: boolean | undefined;
 }): Object;
 export type CachePolicy = "disabled" | "full" | "auto" | "soft";

package/types/snapdom/src/core/exporters.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Normalize an exporter def: Factory, [Factory, options], { exporter, options }, instance.
+ * @param {any} spec
+ * @returns {any|null}
+ */
+export function normalizeExporter(spec: any): any | null;
+/**
+ * Register one or many exporters.
+ * Last one wins on format collision.
+ * @param  {...any} defs
+ */
+export function registerExporters(...defs: any[]): void;
+/**
+ * Resolve the exporter for a format (case-insensitive).
+ * @param {string} format
+ * @returns {any|null}
+ */
+export function getExporter(format: string): any | null;
+/** Utilities for tests */
+export function _exportersMap(): Map<any, any>;
+export function _clearExporters(): void;
+/**
+ * Runs export-related hooks around a given export task.
+ *
+ * Flow:
+ *   beforeExport → work() → afterExport → afterSnap(once per URL)
+ *
+ * @template T
+ * @param {object} ctx - Capture context extended with { export:{ type, options, url } }
+ * @param {() => Promise<T>} work - Async exporter function
+ * @returns {Promise<T>} - The export result
+ */
+export function runExportHooks<T>(ctx: object, work: () => Promise<T>): Promise<T>;

package/types/snapdom/src/core/plugins.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Normalize any plugin definition form into an instance.
+ * Supports plain objects, [factory, options], { plugin, options }, or functions.
+ * @param {any} spec
+ * @returns {any|null}
+ */
+export function normalizePlugin(spec: any): any | null;
+/**
+ * Register global plugins (deduped by name, preserves order).
+ * @param  {...any} defs
+ */
+export function registerPlugins(...defs: any[]): void;
+/**
+ * Llama un hook y propaga un acumulador (compat con tu runHook actual).
+ * Usa los plugins locales si existen, o los globales en fallback.
+ * @param {string} name
+ * @param {any} context
+ * @param {any} payload
+ */
+export function runHook(name: string, context: any, payload: any): Promise<any>;
+/**
+ * NUEVO: recolecta los valores devueltos por TODOS los plugins para un hook.
+ * Útil para `defineExports` (cada plugin devuelve un mapa propio).
+ * Usa plugins locales si existen, o los globales en fallback.
+ * @param {string} name
+ * @param {any} context
+ * @param {any} payload
+ */
+export function runAll(name: string, context: any, payload: any): Promise<any[]>;
+/**
+ * Return a shallow copy of currently registered global plugins.
+ * @returns {any[]}
+ */
+export function pluginsList(): any[];
+/** Clear all globally registered plugins (mostly for tests). */
+export function clearPlugins(): void;
+/**
+ * Merge local (per-capture) plugin defs with the global registry (local-first).
+ * - Local plugins override globals by `name`.
+ * - Accepts plain instances, factories ([factory, options]) and {plugin, options}.
+ * - Returns a frozen array for immutability & GC safety.
+ * @param {any[]|undefined} localDefs
+ * @returns {ReadonlyArray<any>}
+ */
+export function mergePlugins(localDefs: any[] | undefined): ReadonlyArray<any>;
+/**
+ * Attach a per-capture plugin list on the given context (local-first).
+ * Idempotent: if `context.plugins` already exists, it remains unless `force` is true.
+ * @param {any} context
+ * @param {any[]|undefined} localDefs
+ * @param {boolean} [force=false]
+ * @returns {any} the same context (for chaining)
+ */
+export function attachSessionPlugins(context: any, localDefs: any[] | undefined, force?: boolean): any;
+/**
+ * Shallow copy of current global plugins (handy for tests or introspection).
+ * @returns {any[]}
+ */
+export function getGlobalPlugins(): any[];

package/types/snapdom/src/modules/CSSVar.d.ts

@@ -1,9 +1,5 @@
 /**
- * Resolve any author-specified CSS variable usages (var(...)) into computed values
- * on the cloned element. Works for HTML & SVG, inline styles and attributes,
- * without relying on tag/attribute whitelists.
- *
- * @param {Element} sourceEl - Original element in live DOM
- * @param {HTMLElement|SVGElement} cloneEl - Cloned element (detached)
+ * General: resuelve var() en estilos inline/atributos. Además, si no hay var()
+ * pero el valor computado de KEY_PROPS difiere del baseline, inlina ese valor.
  */
-export function resolveCSSVars(sourceEl: Element, cloneEl: HTMLElement | SVGElement): void;
+export function resolveCSSVars(sourceEl: any, cloneEl: any): void;

package/types/snapdom/src/modules/iconFonts.d.ts

@@ -1,2 +1,36 @@
 export function extendIconFonts(fonts: any): void;
 export function isIconFont(input: any): boolean;
+/**
+ * Rasterization helpers for Google Material Icons / Material Symbols that use ligatures.
+ * Converts elements that render icons via text ligatures into inline <img> (data URL).
+ * This runs on the CLONE tree (never mutates the original).
+ *
+ * @module materialIcons
+ */
+/** True si la familia es Material Icons / Material Symbols */
+export function isMaterialFamily(family?: string): boolean;
+/** Espera a que la fuente esté lista (ligaduras) */
+export function ensureMaterialFontsReady(family?: string, px?: number): Promise<void>;
+/**
+ * Dibuja la ligadura (ej. "face") en canvas → dataURL PNG.
+ */
+export function materialIconToImage(ligatureText: any, { family, weight, fontSize, color, variation, }?: {
+    family?: string | undefined;
+    weight?: string | undefined;
+    fontSize?: number | undefined;
+    color?: string | undefined;
+    variation?: string | undefined;
+}): Promise<{
+    dataUrl: string;
+    width: number;
+    height: number;
+}>;
+/**
+ * Reemplaza nodos de Material (ligaduras) por <img> en el CLONE.
+ * IMPORTANTE: leé estilos del SOURCE para obtener el color correcto.
+ *
+ * @param {Element} cloneRoot - subárbol clonado
+ * @param {Element} sourceRoot - subárbol original (para estilos reales)
+ * @returns {Promise<number>}
+ */
+export function ligatureIconToImage(cloneRoot: Element, sourceRoot: Element): Promise<number>;

package/types/snapdom/src/modules/svgDefs.d.ts

@@ -1,19 +1,13 @@
 /**
- * Ensures that all external <symbol> or <defs> elements referenced by <use>
- * inside the given root element are inlined into it.
+ * Inline external <defs> and <symbol> dependencies needed by an SVG subtree (or multiple SVGs),
+ * so that serialization does not break. Handles:
+ *  1) <use href="#..."> targets (symbols/defs)
+ *  2) Attributes/inline styles that reference url(#id) (gradients, patterns, filters, clipPath, mask, marker-*)
+ *  3) Recursive chains via href/xlink:href and nested url(#...) inside cloned defs
  *
- * This is necessary when capturing or exporting an SVG fragment that relies on
- * definitions existing elsewhere in the document, ensuring it remains
- * self-contained and renders correctly.
+ * Fast path: no computed styles, no layout reads. Only DOM queries + cloning.
  *
- * Process:
- * 1. Collect all IDs referenced by <use> elements in the root.
- * 2. Look up those IDs in the global document (outside the root).
- * 3. Create or reuse a hidden <svg> container inside the root to hold inlined defs.
- * 4. Only insert missing <symbol>/<defs> elements that are not already present.
- *
- * Existing definitions in the root are never modified or removed.
- *
- * @param {HTMLElement} rootElement - The root element being processed (typically the cloned DOM fragment).
+ * @param {Element} element - SVG root or container holding one/more SVGs.
+ * @param {Document|ParentNode} [lookupRoot] - Where to search for external defs/symbols (defaults to element.ownerDocument).
  */
-export function inlineExternalDefsAndSymbols(rootElement: HTMLElement): void;
+export function inlineExternalDefsAndSymbols(element: Element, lookupRoot?: Document | ParentNode): void;

package/types/tween/index.d.ts

@@ -0,0 +1 @@
+export { default, easing, default as Tween } from "./src";

package/types/tween/src/easing.d.ts

@@ -0,0 +1,22 @@
+export function easeInBy(power: any): (t: any) => number;
+export function easeOutBy(power: any): (t: any) => number;
+export function easeInOutBy(power: any): (t: any) => number;
+export function linear(t: any): any;
+export function sineIn(t: any): number;
+export function sineOut(t: any): number;
+export function sineInOut(t: any): number;
+export function bounceOut(t: any): number;
+export function bounceIn(t: any): number;
+export function bounceInOut(t: any): number;
+export function quadIn(t: any): number;
+export function quadOut(t: any): number;
+export function quadInOut(t: any): number;
+export function cubicIn(t: any): number;
+export function cubicOut(t: any): number;
+export function cubicInOut(t: any): number;
+export function quartIn(t: any): number;
+export function quartOut(t: any): number;
+export function quartInOut(t: any): number;
+export function quintIn(t: any): number;
+export function quintOut(t: any): number;
+export function quintInOut(t: any): number;

package/types/tween/src/index.d.ts

@@ -0,0 +1,3 @@
+export { easing };
+export { default } from "./tween";
+import * as easing from './easing';

package/types/tween/src/tween.d.ts

@@ -0,0 +1,22 @@
+export default Tween;
+declare class Tween {
+    constructor(options: any);
+    from: any;
+    to: any;
+    duration: any;
+    delay: any;
+    easing: any;
+    onStart: any;
+    onUpdate: any;
+    onFinish: any;
+    startTime: any;
+    started: boolean;
+    finished: boolean;
+    timer: number | null;
+    keys: {};
+    update(): void;
+    time: number | undefined;
+    elapsed: any;
+    start(): void;
+    stop(): void;
+}

package/types/validate/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src';
+export { default } from './src';
+export type * from './src';

package/types/validate/src/index.d.ts

@@ -0,0 +1,39 @@
+import type { GlobalConfig, InnerValidateOptions, SchemaType, ValidateMessagesType, ValidateOptions } from './interface';
+import enUSValidateLocale from './locale/en-US';
+import zhCNValidateLocale from './locale/zh-CN';
+import DefaultValidateMessage from './message';
+import ArrayValidator from './rules/array';
+import BooleanValidator from './rules/boolean';
+import CustomValidator from './rules/custom';
+import NumberValidator from './rules/number';
+import ObjectValidator from './rules/object';
+import StringValidator from './rules/string';
+import TypeValidator from './rules/type';
+import { mergeTemplate } from './utils';
+declare const PqbValidate: {
+    (object: unknown, options: ValidateOptions): Validate;
+    globalConfig: GlobalConfig;
+    setGlobalConfig(options: GlobalConfig): void;
+};
+declare class Validate {
+    number: NumberValidator;
+    string: StringValidator;
+    array: ArrayValidator;
+    object: ObjectValidator;
+    boolean: BooleanValidator;
+    type: TypeValidator;
+    custom: CustomValidator;
+    constructor(object: unknown, _options: InnerValidateOptions);
+}
+declare class Schema {
+    schema: SchemaType;
+    options: ValidateOptions;
+    constructor(schema: SchemaType, options?: ValidateOptions);
+    messages(validateMessages: ValidateMessagesType): void;
+    validate(values: {
+        [key: string]: unknown;
+    }, callback: any): void;
+}
+export { ArrayValidator, BooleanValidator, CustomValidator, zhCNValidateLocale as defaultValidateLocale, DefaultValidateMessage, enUSValidateLocale, mergeTemplate, NumberValidator, ObjectValidator, Schema, StringValidator, TypeValidator, zhCNValidateLocale, };
+export default PqbValidate;
+export type { CustomValidatorType, GlobalConfig, InnerValidateOptions, RuleType, SchemaRuleType, SchemaType, ValidateMessagesTemplateType, ValidateMessagesType, ValidateOptions, ValidatorError, } from './interface';

package/types/validate/src/interface.d.ts

@@ -0,0 +1,53 @@
+import ValidateMessages from './message';
+export type ValidateMessagesTemplateType = typeof ValidateMessages;
+export type ValidateMessagesType = Partial<{
+    [key in keyof ValidateMessagesTemplateType]: ValidateMessagesTemplateType[key] extends string ? ValidateMessagesTemplateType[key] : Record<keyof ValidateMessagesTemplateType[key], string | ((info: any) => unknown)>;
+}>;
+export type RuleType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'url' | 'email' | 'ip' | 'type' | 'custom';
+export type GlobalConfig = Pick<ValidateOptions, 'strict' | 'trim' | 'ignoreEmptyString' | 'validateMessages'>;
+export type ValidateOptions = {
+    strict?: boolean;
+    trim?: boolean;
+    ignoreEmptyString?: boolean;
+    message?: unknown;
+    type?: RuleType;
+    validateMessages?: ValidateMessagesType;
+};
+export type InnerValidateOptions = ValidateOptions & {
+    field?: string;
+};
+export type CustomValidatorType = (value: unknown, callback: (message?: unknown) => void) => Promise<void> | void;
+export type SchemaRuleType = {
+    required?: boolean;
+    message?: unknown;
+    validator?: CustomValidatorType;
+    type?: RuleType;
+    true?: boolean;
+    false?: boolean;
+    deepEqual?: unknown;
+    hasKeys?: string[];
+    empty?: boolean;
+    includes?: unknown;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: RegExp;
+    length?: number;
+    uppercase?: boolean;
+    lowercase?: boolean;
+    min?: number;
+    max?: number;
+    equal?: number;
+    positive?: boolean;
+    negative?: boolean;
+    ignoreEmptyString?: boolean;
+    strict?: boolean;
+};
+export type SchemaType = {
+    [key: string]: SchemaRuleType[];
+};
+export type ValidatorError = {
+    value: unknown;
+    type: ValidateOptions['type'];
+    requiredError?: boolean;
+    message?: unknown;
+};

package/types/validate/src/locale/en-US.d.ts

@@ -0,0 +1,47 @@
+declare const _default: {
+    required: string;
+    type: {
+        ip: string;
+        email: string;
+        url: string;
+        string: string;
+        number: string;
+        array: string;
+        object: string;
+        boolean: string;
+    };
+    number: {
+        min: string;
+        max: string;
+        equal: string;
+        range: string;
+        positive: string;
+        negative: string;
+    };
+    string: {
+        maxLength: string;
+        minLength: string;
+        length: string;
+        match: string;
+        uppercase: string;
+        lowercase: string;
+    };
+    array: {
+        length: string;
+        minLength: string;
+        maxLength: string;
+        includes: string;
+        deepEqual: string;
+        empty: string;
+    };
+    object: {
+        deepEqual: string;
+        hasKeys: string;
+        empty: string;
+    };
+    boolean: {
+        true: string;
+        false: string;
+    };
+};
+export default _default;

package/types/validate/src/locale/zh-CN.d.ts

@@ -0,0 +1,47 @@
+declare const _default: {
+    required: string;
+    type: {
+        string: string;
+        number: string;
+        boolean: string;
+        array: string;
+        object: string;
+        url: string;
+        email: string;
+        ip: string;
+    };
+    number: {
+        min: string;
+        max: string;
+        equal: string;
+        range: string;
+        positive: string;
+        negative: string;
+    };
+    array: {
+        length: string;
+        minLength: string;
+        maxLength: string;
+        includes: string;
+        deepEqual: string;
+        empty: string;
+    };
+    string: {
+        minLength: string;
+        maxLength: string;
+        length: string;
+        match: string;
+        uppercase: string;
+        lowercase: string;
+    };
+    object: {
+        deepEqual: string;
+        hasKeys: string;
+        empty: string;
+    };
+    boolean: {
+        true: string;
+        false: string;
+    };
+};
+export default _default;

package/types/validate/src/message.d.ts

@@ -0,0 +1,2 @@
+import defaultValidateLocale from './locale/zh-CN';
+export default defaultValidateLocale;

package/types/validate/src/rules/array.d.ts

@@ -0,0 +1,12 @@
+import { InnerValidateOptions } from './../interface';
+import Base from './base';
+declare class ArrayValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    length(num: number): this;
+    minLength(num: number): this;
+    maxLength(num: number): this;
+    includes(arrays: number[]): this;
+    deepEqual(other: number[]): this;
+    get empty(): this;
+}
+export default ArrayValidator;