@unicom-cloud/utils 0.1.24 → 0.1.26

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 enUS: {
+    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 enUS;

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

@@ -0,0 +1,47 @@
+declare const zhCN: {
+    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 zhCN;

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;

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

@@ -0,0 +1,25 @@
+import { InnerValidateOptions, ValidateMessagesTemplateType, ValidateOptions, ValidatorError } from './../interface';
+/**
+ * @param options.trim trim string value
+ * @param options.ignoreEmptyString used form type
+ * @param options.message
+ * @param options.type
+ */
+declare abstract class Base {
+    object: unknown;
+    message: ValidateOptions['message'];
+    type: ValidateOptions['type'];
+    error: null | ValidatorError;
+    _not?: boolean;
+    validateMessages: ValidateMessagesTemplateType;
+    field?: string;
+    constructor(object: unknown, options: InnerValidateOptions);
+    get not(): this;
+    get isRequired(): this;
+    get end(): ValidatorError | null;
+    addError(message: unknown): void;
+    getValidateMsg: (keyPath: string, info?: unknown) => unknown;
+    validate(expression: boolean, errorMessage: unknown): this;
+    collect(callback: (error: null | ValidatorError) => void): void;
+}
+export default Base;

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

@@ -0,0 +1,8 @@
+import { InnerValidateOptions } from './../interface';
+import Base from './base';
+declare class BooleanValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    get true(): this;
+    get false(): this;
+}
+export default BooleanValidator;

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

@@ -0,0 +1,7 @@
+import { CustomValidatorType, InnerValidateOptions, ValidatorError } from './../interface';
+import Base from './base';
+declare class CustomValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    validate_(validator: CustomValidatorType, callback?: (message?: ValidatorError | null) => void): ValidatorError | (Promise<void> | this)[] | null | undefined;
+}
+export default CustomValidator;

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

@@ -0,0 +1,12 @@
+import { InnerValidateOptions } from './../interface';
+import Base from './base';
+declare class NumberValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    min(num: number): this;
+    max(num: number): this;
+    equal(num: number): this;
+    range(min: number, max: number): this;
+    get positive(): NumberValidator;
+    get negative(): NumberValidator;
+}
+export default NumberValidator;

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

@@ -0,0 +1,9 @@
+import { InnerValidateOptions } from './../interface';
+import Base from './base';
+declare class ObjectValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    deepEqual(other: unknown): this;
+    hasKeys(keys: string[]): this;
+    get empty(): this;
+}
+export default ObjectValidator;

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

@@ -0,0 +1,12 @@
+import { InnerValidateOptions } from './../interface';
+import Base from './base';
+declare class StringValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    maxLength(length: number): this;
+    minLength(length: number): this;
+    length(length: number): this;
+    match(pattern: RegExp): this;
+    get uppercase(): StringValidator;
+    get lowercase(): StringValidator;
+}
+export default StringValidator;

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

@@ -0,0 +1,9 @@
+import { InnerValidateOptions } from './../interface';
+import Base from './base';
+declare class TypeValidator extends Base {
+    constructor(object: unknown, options: InnerValidateOptions);
+    get email(): this;
+    get url(): this;
+    get ip(): this;
+}
+export default TypeValidator;

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

@@ -0,0 +1,3 @@
+import type { ValidateMessagesTemplateType, ValidateMessagesType } from './interface';
+export declare const mergeTemplate: <T = ValidateMessagesType>(defaultValidateMessages: T, validateMessages: ValidateMessagesType) => T;
+export declare const getTemplate: (validateMessages: ValidateMessagesTemplateType, keyPath: string) => any;

package/ui-color/compareColorByRange.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 function i(r = [34797, 15747172]) {
   return (n = 1) => {
     const o = r, t = Math.log(256) / Math.log(2), e = o[0] >>> t * 2 & 255, g = o[0] >>> t * 1 & 255, l = o[0] >>> t * 0 & 255, c = o[1] >>> t * 2 & 255, s = o[1] >>> t * 1 & 255, f = o[1] >>> t * 0 & 255, a = c - (c - e) * n, b = s - (s - g) * n, h = f - (f - l) * n;

package/ui-color/index.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import { TinyColor as e } from "../tinycolor/src/index.js";
 import { default as Q } from "./compareColorByRange.js";
 const c = 10, f = {

package/uiColor.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import "./tinycolor/src/index.js";
 import { default as o } from "./ui-color/compareColorByRange.js";
 import { LENGTH as t, PRIMARY_COLOR_KEY_MAPPING as p, blue as g, colorPresets as n, colors as m, cyan as s, generate as y, generateDark as P, gold as c, gray as d, grayPresets as i, green as u, lime as R, magenta as f, orange as k, orangered as _, palette as x, paletteDark as A, pinkpurple as C, primary as D, purple as E, red as G, yellow as I } from "./ui-color/index.js";

package/url-toolkit/index.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./src/url-toolkit.js";
 export {
   e as buildAbsoluteURL,

package/url-toolkit/src/url-toolkit.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 const l = /^(?=((?:[a-zA-Z0-9+\-.]+:)?))\1(?=((?:\/\/[^\/?#]*)?))\2(?=((?:(?:[^?#\/]*\/)*[^;?#\/]*)?))\3((?:;[^?#]*)?)(\?[^#]*)?(#[^]*)?$/, p = /^(?=([^\/?#]*))\1([^]*)$/, f = /(?:\/|^)\.(?=\/)/g, m = /(?:\/|^)\.\.\/(?!\.\.\/)[^\/]*(?=\/)/g;
 function E(r, a, s) {
   if (s = s || {}, r = r.trim(), a = a.trim(), !a) {

package/urlToolkit.js

@@ -1,4 +1,4 @@
-/* 2025-10-28 09:57:10 */
+/* 2025-11-04 10:32:44 */
 import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./url-toolkit/src/url-toolkit.js";
 export {
   e as buildAbsoluteURL,

package/validate/index.js

@@ -0,0 +1,28 @@
+/* 2025-11-04 10:32:44 */
+import { Schema as t, default as o } from "./src/index.js";
+import { default as l } from "./src/rules/array.js";
+import { default as d } from "./src/rules/boolean.js";
+import { default as u } from "./src/rules/custom.js";
+import { default as p, default as i, default as x } from "./src/locale/zh-CN.js";
+import { default as c } from "./src/locale/en-US.js";
+import { default as n } from "./src/rules/number.js";
+import { default as S } from "./src/rules/object.js";
+import { default as h } from "./src/rules/string.js";
+import { default as C } from "./src/rules/type.js";
+import { mergeTemplate as T } from "./src/utils.js";
+export {
+  l as ArrayValidator,
+  d as BooleanValidator,
+  u as CustomValidator,
+  p as DefaultValidateMessage,
+  n as NumberValidator,
+  S as ObjectValidator,
+  t as Schema,
+  h as StringValidator,
+  C as TypeValidator,
+  o as default,
+  i as defaultValidateLocale,
+  c as enUSValidateLocale,
+  T as mergeTemplate,
+  x as zhCNValidateLocale
+};

package/validate/src/index.js

@@ -0,0 +1,106 @@
+/* 2025-11-04 10:32:44 */
+import V from "lodash/defaultsDeep";
+import u from "lodash/isArray.js";
+import E from "lodash/isFunction.js";
+import v from "lodash/isObjectLike.js";
+import C from "./rules/array.js";
+import M from "./rules/boolean.js";
+import S from "./rules/custom.js";
+import q from "./rules/number.js";
+import O from "./rules/object.js";
+import A from "./rules/string.js";
+import P from "./rules/type.js";
+import { mergeTemplate as y } from "./utils.js";
+const f = (l, e) => new b(l, { field: "value", ...e });
+f.globalConfig = {};
+f.setGlobalConfig = (l) => {
+  f.globalConfig = V(
+    {},
+    l,
+    f.globalConfig
+  );
+};
+class b {
+  constructor(e, a) {
+    const n = f.globalConfig, s = {
+      ...n,
+      ...a,
+      validateMessages: y(
+        n.validateMessages,
+        a.validateMessages
+      )
+    };
+    this.string = new A(e, s), this.number = new q(e, s), this.array = new C(e, s), this.object = new O(e, s), this.boolean = new M(e, s), this.type = new P(e, s), this.custom = new S(e, s);
+  }
+}
+class U {
+  constructor(e, a = {}) {
+    this.schema = e, this.options = a;
+  }
+  // 更新校验信息
+  messages(e) {
+    this.options = {
+      ...this.options,
+      validateMessages: y(
+        this.options.validateMessages,
+        e
+      )
+    };
+  }
+  validate(e, a) {
+    if (!v(e)) return;
+    const n = [];
+    let s = null;
+    function m(t, h) {
+      s || (s = {}), s && (!s[t] || h.requiredError) && (s[t] = h);
+    }
+    this.schema && Object.entries(this.schema).forEach(([t, h], T, x) => {
+      if (u(this.schema[t]))
+        for (let c = 0; c < this.schema[t].length; c++) {
+          const o = this.schema[t][c], g = o.type, w = o.message;
+          if (!g) {
+            if (!o.validator) throw `You must specify a type to field ${t}!`;
+          }
+          const p = {
+            ...this.options,
+            message: w,
+            field: t
+          };
+          "ignoreEmptyString" in o && (p.ignoreEmptyString = o.ignoreEmptyString), "strict" in o && (p.strict = o.strict);
+          const d = new b(e[t], p);
+          let i = d.type[g] || null;
+          if (!i) if (o.validator) {
+            i = d.custom.validate_(o.validator), u(i) && i[0]?.then ? n.push({
+              function: i[0],
+              _this: i[1],
+              key: t
+            }) : i && m(t, i);
+            continue;
+          } else
+            i = d[g];
+          if (Object.entries(o).forEach(([r, B], D, F) => {
+            o.required && (i = i.isRequired), r !== "message" && i?.[r] && o[r] && v(i[r]) && (i = i[r]), i?.[r] && o[r] !== void 0 && E(i[r]) && (i = i[r](o[r]));
+          }), i.collect((r) => {
+            r && m(t, r);
+          }), s)
+            break;
+        }
+    }), n.length > 0 ? Promise.all(n.map((t) => t.function)).then(() => {
+      n.forEach((t) => {
+        "error" in t._this && t._this.error && m(t.key, t._this.error);
+      }), a?.(s);
+    }) : a?.(s);
+  }
+}
+export {
+  C as ArrayValidator,
+  M as BooleanValidator,
+  S as CustomValidator,
+  q as NumberValidator,
+  O as ObjectValidator,
+  U as Schema,
+  A as StringValidator,
+  P as TypeValidator,
+  f as default,
+  y as mergeTemplate
+};

package/validate/src/locale/en-US.js

@@ -0,0 +1,50 @@
+/* 2025-11-04 10:32:44 */
+const e = "#{field} is not a #{type} type", t = {
+  required: "#{field} is required",
+  type: {
+    ip: e,
+    email: e,
+    url: e,
+    string: e,
+    number: e,
+    array: e,
+    object: e,
+    boolean: e
+  },
+  number: {
+    min: "`#{value}` is not greater than `#{min}`",
+    max: "`#{value}` is not less than `#{max}`",
+    equal: "`#{value}` is not equal to `#{equal}`",
+    range: "`#{value}` is not in range `#{min} ~ #{max}`",
+    positive: "`#{value}` is not a positive number",
+    negative: "`#{value}` is not a negative number"
+  },
+  string: {
+    maxLength: "#{field} cannot be longer than #{maxLength} characters",
+    minLength: "#{field} must be at least #{minLength} characters",
+    length: "#{field} must be exactly #{length} characters",
+    match: "`#{value}` does not match pattern #{pattern}",
+    uppercase: "`#{value}` must be all uppercase",
+    lowercase: "`#{value}` must be all lowercased"
+  },
+  array: {
+    length: "#{field} must be exactly #{length} in length",
+    minLength: "#{field} cannot be less than #{minLength} in length",
+    maxLength: "#{field} cannot be greater than #{maxLength} in length",
+    includes: "#{field} is not includes #{includes}",
+    deepEqual: "#{field} is not deep equal with #{deepEqual}",
+    empty: "#{field} is not an empty array"
+  },
+  object: {
+    deepEqual: "#{field} is not deep equal to expected value",
+    hasKeys: "#{field} does not contain required fields",
+    empty: "#{field} is not an empty object"
+  },
+  boolean: {
+    true: "Expect true but got `#{value}`",
+    false: "Expect false but got `#{value}`"
+  }
+};
+export {
+  t as default
+};

package/validate/src/locale/zh-CN.js

@@ -0,0 +1,50 @@
+/* 2025-11-04 10:32:44 */
+const e = {
+  required: "#{field} 是必填项",
+  type: {
+    string: "#{field} 不是合法的文本类型",
+    number: "#{field} 不是合法的数字类型",
+    boolean: "#{field} 不是合法的布尔类型",
+    array: "#{field} 不是合法的数组类型",
+    object: "#{field} 不是合法的对象类型",
+    url: "#{field} 不是合法的 url 地址",
+    email: "#{field} 不是合法的邮箱地址",
+    ip: "#{field} 不是合法的 IP 地址"
+  },
+  number: {
+    min: "`#{value}` 小于最小值 `#{min}`",
+    max: "`#{value}` 大于最大值 `#{max}`",
+    equal: "`#{value}` 不等于 `#{equal}`",
+    range: "`#{value}` 不在 `#{min} ~ #{max}` 范围内",
+    positive: "`#{value}` 不是正数",
+    negative: "`#{value}` 不是负数"
+  },
+  array: {
+    length: "#{field} 个数不等于 #{length}",
+    minLength: "#{field} 个数最少为 #{minLength}",
+    maxLength: "#{field} 个数最多为 #{maxLength}",
+    includes: "#{field} 不包含 #{includes}",
+    deepEqual: "#{field} 不等于 #{deepEqual}",
+    empty: "#{field} 不是空数组"
+  },
+  string: {
+    minLength: "字符数最少为 #{minLength}",
+    maxLength: "字符数最多为 #{maxLength}",
+    length: "字符数必须是 #{length}",
+    match: "`#{value}` 不符合模式 #{pattern}",
+    uppercase: "`#{value}` 必须全大写",
+    lowercase: "`#{value}` 必须全小写"
+  },
+  object: {
+    deepEqual: "#{field} 不等于期望值",
+    hasKeys: "#{field} 不包含必须字段",
+    empty: "#{field} 不是对象"
+  },
+  boolean: {
+    true: "期望是 `true`",
+    false: "期望是 `false`"
+  }
+};
+export {
+  e as default
+};

package/validate/src/message.js

@@ -0,0 +1,5 @@
+/* 2025-11-04 10:32:44 */
+import r from "./locale/zh-CN.js";
+export {
+  r as default
+};