@arcblock/validator 1.27.16 → 1.28.0

package/esm/lodash.d.ts

@@ -0,0 +1,2 @@
+//#region src/lodash.d.ts
+declare module 'lodash/isEqual';

package/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/extension/bn.d.ts

@@ -1,96 +1,100 @@
-import { Root, AnySchema } from 'joi';
-import BN from 'bn.js';
-export interface BNSchema extends AnySchema {
-    min(threshold: any): this;
-    gte(threshold: any): this;
-    max(threshold: any): this;
-    lte(threshold: any): this;
-    greater(threshold: any): this;
-    gt(threshold: any): this;
-    less(threshold: any): this;
-    lt(threshold: any): this;
-    positive(): this;
-    negative(): this;
+import { AnySchema, Root } from "joi";
+import BN from "bn.js";
+
+//#region src/extension/bn.d.ts
+interface BNSchema extends AnySchema {
+  min(threshold: any): this;
+  gte(threshold: any): this;
+  max(threshold: any): this;
+  lte(threshold: any): this;
+  greater(threshold: any): this;
+  gt(threshold: any): this;
+  less(threshold: any): this;
+  lt(threshold: any): this;
+  positive(): this;
+  negative(): this;
 }
-export declare function BNExtension(root: Root): {
-    type: string;
-    base: AnySchema<any>;
-    messages: {
-        'bn.nan': string;
-        'bn.max': string;
-        'bn.min': string;
-        'bn.less': string;
-        'bn.greater': string;
-        'bn.positive': string;
-        'bn.negative': string;
+declare function BNExtension(root: Root): {
+  type: string;
+  base: AnySchema<any>;
+  messages: {
+    'bn.nan': string;
+    'bn.max': string;
+    'bn.min': string;
+    'bn.less': string;
+    'bn.greater': string;
+    'bn.positive': string;
+    'bn.negative': string;
+  };
+  prepare(value: any, helpers: any): {
+    value: BN;
+    errors?: undefined;
+  } | {
+    errors: any;
+    value?: undefined;
+  };
+  coerce(value: BN): {
+    value: string;
+  };
+  validate(value: any): {
+    value: any;
+  };
+  rules: {
+    gt: {
+      args: ({
+        name: string;
+        ref: boolean;
+        assert: (v: any) => v is BN;
+        message: string;
+        normalize: (v: any) => BN;
+      } | {
+        name: string;
+        assert: (v: any) => v is boolean;
+        message: string;
+        ref?: undefined;
+        normalize?: undefined;
+      })[];
+      validate(value: any, helpers: any, args: any): any;
     };
-    prepare(value: any, helpers: any): {
-        value: BN;
-        errors?: undefined;
-    } | {
-        errors: any;
-        value?: undefined;
+    lt: {
+      args: ({
+        name: string;
+        ref: boolean;
+        assert: (v: any) => v is BN;
+        message: string;
+        normalize: (v: any) => BN;
+      } | {
+        name: string;
+        assert: (v: any) => v is boolean;
+        message: string;
+        ref?: undefined;
+        normalize?: undefined;
+      })[];
+      validate(value: any, helpers: any, args: any): any;
     };
-    coerce(value: BN): {
-        value: string;
+    min: {
+      alias: string;
+      method(threshold: any): BNSchema;
     };
-    validate(value: any): {
-        value: any;
+    max: {
+      alias: string;
+      method(threshold: any): BNSchema;
     };
-    rules: {
-        gt: {
-            args: ({
-                name: string;
-                ref: boolean;
-                assert: (v: any) => v is BN;
-                message: string;
-                normalize: (v: any) => BN;
-            } | {
-                name: string;
-                assert: (v: any) => v is boolean;
-                message: string;
-                ref?: undefined;
-                normalize?: undefined;
-            })[];
-            validate(value: any, helpers: any, args: any): any;
-        };
-        lt: {
-            args: ({
-                name: string;
-                ref: boolean;
-                assert: (v: any) => v is BN;
-                message: string;
-                normalize: (v: any) => BN;
-            } | {
-                name: string;
-                assert: (v: any) => v is boolean;
-                message: string;
-                ref?: undefined;
-                normalize?: undefined;
-            })[];
-            validate(value: any, helpers: any, args: any): any;
-        };
-        min: {
-            alias: string;
-            method(threshold: any): BNSchema;
-        };
-        max: {
-            alias: string;
-            method(threshold: any): BNSchema;
-        };
-        greater: {
-            alias: string;
-            method(threshold: any): BNSchema;
-        };
-        less: {
-            alias: string;
-            method(threshold: any): BNSchema;
-        };
-        positive: {
-            method(): BNSchema;
-        };
-        negative: {
-            method(): BNSchema;
-        };
+    greater: {
+      alias: string;
+      method(threshold: any): BNSchema;
     };
+    less: {
+      alias: string;
+      method(threshold: any): BNSchema;
+    };
+    positive: {
+      method(): BNSchema;
+    };
+    negative: {
+      method(): BNSchema;
+    };
+  };
 };
+//#endregion
+export { BNExtension, BNSchema };

package/lib/extension/bn.js

@@ -1,136 +1,142 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BNExtension = BNExtension;
-const bn_js_1 = __importDefault(require("bn.js"));
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+let bn_js = require("bn.js");
+bn_js = require_rolldown_runtime.__toESM(bn_js);
+
+//#region src/extension/bn.ts
 function BNExtension(root) {
-    return {
-        type: 'BN',
-        base: root.any(),
-        messages: {
-            'bn.nan': '{{#label}} is not a big number',
-            'bn.max': '{{#label}} needs to be less than or equal to "{{#threshold}}"',
-            'bn.min': '{{#label}} needs to be greater than or equal to "{{#threshold}}"',
-            'bn.less': '{{#label}} needs to be less than "{{#threshold}}"',
-            'bn.greater': '{{#label}} needs to be greater than "{{#threshold}}"',
-            'bn.positive': '{{#label}} needs to be positive',
-            'bn.negative': '{{#label}} needs to be negative',
-        },
-        prepare(value, helpers) {
-            try {
-                return { value: new bn_js_1.default(value) };
-            }
-            catch (err) {
-                return { errors: helpers.error('bn.nan') };
-            }
-        },
-        coerce(value) {
-            return { value: value.toString(10) };
-        },
-        validate(value) {
-            return { value };
-        },
-        rules: {
-            gt: {
-                args: [
-                    {
-                        name: 'threshold',
-                        ref: true,
-                        assert: (v) => bn_js_1.default.isBN(v),
-                        message: 'must be a big number',
-                        normalize: (v) => new bn_js_1.default(v),
-                    },
-                    {
-                        name: 'equal',
-                        assert: (v) => typeof v === 'boolean',
-                        message: 'must be a boolean',
-                    },
-                ],
-                // The rule return structure is different from the root
-                // eslint-disable-next-line consistent-return
-                validate(value, helpers, args) {
-                    const v = new bn_js_1.default(value);
-                    if (args.equal && v.lt(args.threshold)) {
-                        return helpers.error('bn.min', args);
-                    }
-                    if (!args.equal && v.lte(args.threshold)) {
-                        return helpers.error('bn.greater', args);
-                    }
-                    // must return value when valid
-                    return value;
-                },
-            },
-            lt: {
-                args: [
-                    {
-                        name: 'threshold',
-                        ref: true,
-                        assert: (v) => bn_js_1.default.isBN(v),
-                        message: 'must be a big number',
-                        normalize: (v) => new bn_js_1.default(v),
-                    },
-                    {
-                        name: 'equal',
-                        assert: (v) => typeof v === 'boolean',
-                        message: 'must be a boolean',
-                    },
-                ],
-                // The rule return structure is different from the root
-                // eslint-disable-next-line consistent-return
-                validate(value, helpers, args) {
-                    const v = new bn_js_1.default(value);
-                    if (args.equal && v.gt(args.threshold)) {
-                        return helpers.error('bn.max', args);
-                    }
-                    if (!args.equal && v.gte(args.threshold)) {
-                        return helpers.error('bn.less', args);
-                    }
-                    // must return value when valid
-                    return value;
-                },
-            },
-            min: {
-                alias: 'gte',
-                method(threshold) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'gt', args: { threshold, equal: true } });
-                },
-            },
-            max: {
-                alias: 'lte',
-                method(threshold) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'lt', args: { threshold, equal: true } });
-                },
-            },
-            greater: {
-                alias: 'gt',
-                method(threshold) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'gt', args: { threshold, equal: false } });
-                },
-            },
-            less: {
-                alias: 'lt',
-                method(threshold) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'lt', args: { threshold, equal: false } });
-                },
-            },
-            positive: {
-                method() {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'gt', args: { threshold: 0, equal: false } });
-                },
-            },
-            negative: {
-                method() {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'lt', args: { threshold: 0, equal: false } });
-                },
-            },
-        },
-    };
+	return {
+		type: "BN",
+		base: root.any(),
+		messages: {
+			"bn.nan": "{{#label}} is not a big number",
+			"bn.max": "{{#label}} needs to be less than or equal to \"{{#threshold}}\"",
+			"bn.min": "{{#label}} needs to be greater than or equal to \"{{#threshold}}\"",
+			"bn.less": "{{#label}} needs to be less than \"{{#threshold}}\"",
+			"bn.greater": "{{#label}} needs to be greater than \"{{#threshold}}\"",
+			"bn.positive": "{{#label}} needs to be positive",
+			"bn.negative": "{{#label}} needs to be negative"
+		},
+		prepare(value, helpers) {
+			try {
+				return { value: new bn_js.default(value) };
+			} catch (err) {
+				return { errors: helpers.error("bn.nan") };
+			}
+		},
+		coerce(value) {
+			return { value: value.toString(10) };
+		},
+		validate(value) {
+			return { value };
+		},
+		rules: {
+			gt: {
+				args: [{
+					name: "threshold",
+					ref: true,
+					assert: (v) => bn_js.default.isBN(v),
+					message: "must be a big number",
+					normalize: (v) => new bn_js.default(v)
+				}, {
+					name: "equal",
+					assert: (v) => typeof v === "boolean",
+					message: "must be a boolean"
+				}],
+				validate(value, helpers, args) {
+					const v = new bn_js.default(value);
+					if (args.equal && v.lt(args.threshold)) return helpers.error("bn.min", args);
+					if (!args.equal && v.lte(args.threshold)) return helpers.error("bn.greater", args);
+					return value;
+				}
+			},
+			lt: {
+				args: [{
+					name: "threshold",
+					ref: true,
+					assert: (v) => bn_js.default.isBN(v),
+					message: "must be a big number",
+					normalize: (v) => new bn_js.default(v)
+				}, {
+					name: "equal",
+					assert: (v) => typeof v === "boolean",
+					message: "must be a boolean"
+				}],
+				validate(value, helpers, args) {
+					const v = new bn_js.default(value);
+					if (args.equal && v.gt(args.threshold)) return helpers.error("bn.max", args);
+					if (!args.equal && v.gte(args.threshold)) return helpers.error("bn.less", args);
+					return value;
+				}
+			},
+			min: {
+				alias: "gte",
+				method(threshold) {
+					return this.$_addRule({
+						name: "gt",
+						args: {
+							threshold,
+							equal: true
+						}
+					});
+				}
+			},
+			max: {
+				alias: "lte",
+				method(threshold) {
+					return this.$_addRule({
+						name: "lt",
+						args: {
+							threshold,
+							equal: true
+						}
+					});
+				}
+			},
+			greater: {
+				alias: "gt",
+				method(threshold) {
+					return this.$_addRule({
+						name: "gt",
+						args: {
+							threshold,
+							equal: false
+						}
+					});
+				}
+			},
+			less: {
+				alias: "lt",
+				method(threshold) {
+					return this.$_addRule({
+						name: "lt",
+						args: {
+							threshold,
+							equal: false
+						}
+					});
+				}
+			},
+			positive: { method() {
+				return this.$_addRule({
+					name: "gt",
+					args: {
+						threshold: 0,
+						equal: false
+					}
+				});
+			} },
+			negative: { method() {
+				return this.$_addRule({
+					name: "lt",
+					args: {
+						threshold: 0,
+						equal: false
+					}
+				});
+			} }
+		}
+	};
 }
+
+//#endregion
+exports.BNExtension = BNExtension;

package/lib/extension/did.d.ts

@@ -1,77 +1,81 @@
-import { Root, StringSchema } from 'joi';
-import { KeyType, HashType, RoleType } from '@ocap/mcrypto';
-import { DIDTypeShortcut } from '@arcblock/did';
-export interface DIDSchema extends StringSchema {
-    wallet(type: DIDTypeShortcut): this;
-    pk(type: KeyType): this;
-    hash(type: HashType): this;
-    role(type: RoleType): this;
-    prefix(str?: string): this;
+import { Root, StringSchema } from "joi";
+import { HashType, KeyType, RoleType } from "@ocap/mcrypto";
+import { DIDTypeShortcut } from "@arcblock/did";
+
+//#region src/extension/did.d.ts
+interface DIDSchema extends StringSchema {
+  wallet(type: DIDTypeShortcut): this;
+  pk(type: KeyType): this;
+  hash(type: HashType): this;
+  role(type: RoleType): this;
+  prefix(str?: string): this;
 }
-export declare function DIDExtension(root: Root): {
-    type: string;
-    base: StringSchema<string>;
-    messages: {
-        'did.empty': string;
-        'did.invalid': string;
-        'did.wallet': string;
-        'did.pk': string;
-        'did.hash': string;
-        'did.role': string;
-        'did.prefix': string;
+declare function DIDExtension(root: Root): {
+  type: string;
+  base: StringSchema<string>;
+  messages: {
+    'did.empty': string;
+    'did.invalid': string;
+    'did.wallet': string;
+    'did.pk': string;
+    'did.hash': string;
+    'did.role': string;
+    'did.prefix': string;
+  };
+  validate(value: any, helpers: any): {
+    errors: any;
+    value?: undefined;
+  } | {
+    value: string;
+    errors?: undefined;
+  };
+  rules: {
+    type: {
+      args: ({
+        name: string;
+        ref: boolean;
+        assert: (v: string) => boolean;
+        message: string;
+      } | {
+        name: string;
+        assert: (v: string) => boolean;
+        message: string;
+        ref?: undefined;
+      })[];
+      validate(value: string, helpers: any, args: any): any;
     };
-    validate(value: any, helpers: any): {
-        errors: any;
-        value?: undefined;
-    } | {
-        value: string;
-        errors?: undefined;
+    pk: {
+      method(type: KeyType): DIDSchema;
     };
-    rules: {
-        type: {
-            args: ({
-                name: string;
-                ref: boolean;
-                assert: (v: string) => boolean;
-                message: string;
-            } | {
-                name: string;
-                assert: (v: string) => boolean;
-                message: string;
-                ref?: undefined;
-            })[];
-            validate(value: string, helpers: any, args: any): any;
-        };
-        pk: {
-            method(type: KeyType): DIDSchema;
-        };
-        hash: {
-            method(type: HashType): DIDSchema;
-        };
-        role: {
-            method(type: RoleType): DIDSchema;
-        };
-        wallet: {
-            method(type: DIDTypeShortcut): DIDSchema;
-            args: {
-                name: string;
-                ref: boolean;
-                assert: (v: any) => boolean;
-                message: string;
-                normalize: (v: any) => any;
-            }[];
-            validate(value: any, helpers: any, args?: any): any;
-        };
-        prefix: {
-            method(str?: string): DIDSchema;
-            args: {
-                name: string;
-                ref: boolean;
-                assert: (v: any) => boolean;
-                message: string;
-                normalize: (v: any) => any;
-            }[];
-            validate(value: any, helpers: any, args?: any): any;
-        };
+    hash: {
+      method(type: HashType): DIDSchema;
     };
+    role: {
+      method(type: RoleType): DIDSchema;
+    };
+    wallet: {
+      method(type: DIDTypeShortcut): DIDSchema;
+      args: {
+        name: string;
+        ref: boolean;
+        assert: (v: any) => boolean;
+        message: string;
+        normalize: (v: any) => any;
+      }[];
+      validate(value: any, helpers: any, args?: any): any;
+    };
+    prefix: {
+      method(str?: string): DIDSchema;
+      args: {
+        name: string;
+        ref: boolean;
+        assert: (v: any) => boolean;
+        message: string;
+        normalize: (v: any) => any;
+      }[];
+      validate(value: any, helpers: any, args?: any): any;
+    };
+  };
 };
+//#endregion
+export { DIDExtension, DIDSchema };