@arcblock/validator 1.27.15 → 1.28.0

package/lib/extension/did.js

@@ -1,142 +1,150 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIDExtension = DIDExtension;
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const mcrypto_1 = require("@ocap/mcrypto");
-const did_1 = require("@arcblock/did");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+let lodash_isEqual = require("lodash/isEqual");
+lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);
+let _ocap_mcrypto = require("@ocap/mcrypto");
+let _arcblock_did = require("@arcblock/did");
+
+//#region src/extension/did.ts
 const ruleTypes = {
-    pk: Object.keys(mcrypto_1.types.KeyType),
-    hash: Object.keys(mcrypto_1.types.HashType),
-    role: Object.keys(mcrypto_1.types.RoleType),
+	pk: Object.keys(_ocap_mcrypto.types.KeyType),
+	hash: Object.keys(_ocap_mcrypto.types.HashType),
+	role: Object.keys(_ocap_mcrypto.types.RoleType)
 };
 function DIDExtension(root) {
-    return {
-        type: 'DID',
-        base: root.string().trim(),
-        messages: {
-            'did.empty': 'Expect {{#label}} to be non-empty string',
-            'did.invalid': 'Expect {{#label}} to be valid did',
-            'did.wallet': 'Expect wallet type of {{#label}} to be "{{#expected}}" wallet',
-            'did.pk': 'Expect pk type of {{#label}} to be "{{#expected}}"',
-            'did.hash': 'Expect hash type of {{#label}} to be "{{#expected}}"',
-            'did.role': 'Expect role type of {{#label}} to be "{{#expected}}"',
-            'did.prefix': 'Expect prefix of {{#label}} to be "{{#expected}}"',
-        },
-        validate(value, helpers) {
-            if (!value || typeof value !== 'string') {
-                return { errors: helpers.error('did.empty', { value }) };
-            }
-            if ((0, did_1.isValid)(value) === false) {
-                return { errors: helpers.error('did.invalid', { value }) };
-            }
-            return { value };
-        },
-        rules: {
-            type: {
-                args: [
-                    {
-                        name: 'key',
-                        ref: true,
-                        assert: (v) => Object.keys(ruleTypes).includes(v),
-                        message: `must be one of ${Object.keys(ruleTypes).join(', ')}`,
-                    },
-                    {
-                        name: 'expected',
-                        // @ts-ignore
-                        assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
-                        message: 'must be valid type',
-                    },
-                ],
-                // The rule return structure is different from the root
-                // eslint-disable-next-line consistent-return
-                validate(value, helpers, args) {
-                    const typeStr = (0, did_1.toTypeInfoStr)(value);
-                    if (args.key === 'pk' && typeStr.pk !== args.expected) {
-                        return helpers.error('did.pk', { ...args, actual: typeStr.pk });
-                    }
-                    if (args.key === 'hash' && typeStr.hash !== args.expected) {
-                        return helpers.error('did.hash', { ...args, actual: typeStr.hash });
-                    }
-                    if (args.key === 'role' && typeStr.role !== args.expected) {
-                        return helpers.error('did.role', { ...args, actual: typeStr.role });
-                    }
-                    return value;
-                },
-            },
-            pk: {
-                method(type) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'type', args: { key: 'pk', expected: type } });
-                },
-            },
-            hash: {
-                method(type) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'type', args: { key: 'hash', expected: type } });
-                },
-            },
-            role: {
-                method(type) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'type', args: { key: 'role', expected: type } });
-                },
-            },
-            wallet: {
-                method(type) {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'wallet', args: { type } });
-                },
-                args: [
-                    {
-                        name: 'type',
-                        ref: true,
-                        assert: (v) => ['arcblock', 'ethereum', 'default', 'eth', 'passkey'].includes(v),
-                        message: 'must be a string',
-                        normalize: (v) => v.trim(),
-                    },
-                ],
-                validate(value, helpers, args = {}) {
-                    const type = (0, did_1.toTypeInfo)(value);
-                    const typeStr = (0, did_1.toTypeInfoStr)(value);
-                    if (['ethereum', 'eth'].includes(args.type) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ETHEREUM) === false) {
-                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
-                    }
-                    if (['arcblock', 'default'].includes(args.type) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ARCBLOCK) === false) {
-                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
-                    }
-                    if (['passkey'].includes(args.type) && (0, isEqual_1.default)(type, did_1.DID_TYPE_PASSKEY) === false) {
-                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
-                    }
-                    return value;
-                },
-            },
-            prefix: {
-                method(str = '') {
-                    // @ts-ignore
-                    return this.$_addRule({ name: 'prefix', args: { str } });
-                },
-                args: [
-                    {
-                        name: 'str',
-                        ref: true,
-                        assert: (v) => ['', did_1.DID_PREFIX].includes(v),
-                        message: 'must be a string',
-                        normalize: (v) => v.trim(),
-                    },
-                ],
-                validate(value, helpers, args = {}) {
-                    if (args.str && value.startsWith(args.str) === false) {
-                        return helpers.error('did.prefix', { expected: args.str });
-                    }
-                    if (!args.str && (0, did_1.toAddress)(value) !== value) {
-                        return helpers.error('did.prefix', { expected: args.str });
-                    }
-                    return value;
-                },
-            },
-        },
-    };
+	return {
+		type: "DID",
+		base: root.string().trim(),
+		messages: {
+			"did.empty": "Expect {{#label}} to be non-empty string",
+			"did.invalid": "Expect {{#label}} to be valid did",
+			"did.wallet": "Expect wallet type of {{#label}} to be \"{{#expected}}\" wallet",
+			"did.pk": "Expect pk type of {{#label}} to be \"{{#expected}}\"",
+			"did.hash": "Expect hash type of {{#label}} to be \"{{#expected}}\"",
+			"did.role": "Expect role type of {{#label}} to be \"{{#expected}}\"",
+			"did.prefix": "Expect prefix of {{#label}} to be \"{{#expected}}\""
+		},
+		validate(value, helpers) {
+			if (!value || typeof value !== "string") return { errors: helpers.error("did.empty", { value }) };
+			if ((0, _arcblock_did.isValid)(value) === false) return { errors: helpers.error("did.invalid", { value }) };
+			return { value };
+		},
+		rules: {
+			type: {
+				args: [{
+					name: "key",
+					ref: true,
+					assert: (v) => Object.keys(ruleTypes).includes(v),
+					message: `must be one of ${Object.keys(ruleTypes).join(", ")}`
+				}, {
+					name: "expected",
+					assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
+					message: "must be valid type"
+				}],
+				validate(value, helpers, args) {
+					const typeStr = (0, _arcblock_did.toTypeInfoStr)(value);
+					if (args.key === "pk" && typeStr.pk !== args.expected) return helpers.error("did.pk", {
+						...args,
+						actual: typeStr.pk
+					});
+					if (args.key === "hash" && typeStr.hash !== args.expected) return helpers.error("did.hash", {
+						...args,
+						actual: typeStr.hash
+					});
+					if (args.key === "role" && typeStr.role !== args.expected) return helpers.error("did.role", {
+						...args,
+						actual: typeStr.role
+					});
+					return value;
+				}
+			},
+			pk: { method(type) {
+				return this.$_addRule({
+					name: "type",
+					args: {
+						key: "pk",
+						expected: type
+					}
+				});
+			} },
+			hash: { method(type) {
+				return this.$_addRule({
+					name: "type",
+					args: {
+						key: "hash",
+						expected: type
+					}
+				});
+			} },
+			role: { method(type) {
+				return this.$_addRule({
+					name: "type",
+					args: {
+						key: "role",
+						expected: type
+					}
+				});
+			} },
+			wallet: {
+				method(type) {
+					return this.$_addRule({
+						name: "wallet",
+						args: { type }
+					});
+				},
+				args: [{
+					name: "type",
+					ref: true,
+					assert: (v) => [
+						"arcblock",
+						"ethereum",
+						"default",
+						"eth",
+						"passkey"
+					].includes(v),
+					message: "must be a string",
+					normalize: (v) => v.trim()
+				}],
+				validate(value, helpers, args = {}) {
+					const type = (0, _arcblock_did.toTypeInfo)(value);
+					const typeStr = (0, _arcblock_did.toTypeInfoStr)(value);
+					if (["ethereum", "eth"].includes(args.type) && (0, lodash_isEqual.default)(type, _arcblock_did.DID_TYPE_ETHEREUM) === false) return helpers.error("did.wallet", {
+						expected: args.type,
+						actual: JSON.stringify(typeStr)
+					});
+					if (["arcblock", "default"].includes(args.type) && (0, lodash_isEqual.default)(type, _arcblock_did.DID_TYPE_ARCBLOCK) === false) return helpers.error("did.wallet", {
+						expected: args.type,
+						actual: JSON.stringify(typeStr)
+					});
+					if (["passkey"].includes(args.type) && (0, lodash_isEqual.default)(type, _arcblock_did.DID_TYPE_PASSKEY) === false) return helpers.error("did.wallet", {
+						expected: args.type,
+						actual: JSON.stringify(typeStr)
+					});
+					return value;
+				}
+			},
+			prefix: {
+				method(str = "") {
+					return this.$_addRule({
+						name: "prefix",
+						args: { str }
+					});
+				},
+				args: [{
+					name: "str",
+					ref: true,
+					assert: (v) => ["", _arcblock_did.DID_PREFIX].includes(v),
+					message: "must be a string",
+					normalize: (v) => v.trim()
+				}],
+				validate(value, helpers, args = {}) {
+					if (args.str && value.startsWith(args.str) === false) return helpers.error("did.prefix", { expected: args.str });
+					if (!args.str && (0, _arcblock_did.toAddress)(value) !== value) return helpers.error("did.prefix", { expected: args.str });
+					return value;
+				}
+			}
+		}
+	};
 }
+
+//#endregion
+exports.DIDExtension = DIDExtension;

package/lib/index.d.ts

@@ -1,51 +1,55 @@
-import BaseJoi, { Root } from 'joi';
-import { BNSchema } from './extension/bn';
-import { DIDSchema } from './extension/did';
-export interface ExtendedRoot extends Root {
-    DID(): DIDSchema;
-    BN(): BNSchema;
+import { BNSchema } from "./extension/bn.js";
+import { DIDSchema } from "./extension/did.js";
+import BaseJoi, { Root } from "joi";
+
+//#region src/index.d.ts
+interface ExtendedRoot extends Root {
+  DID(): DIDSchema;
+  BN(): BNSchema;
 }
-export declare const Joi: ExtendedRoot;
-export declare const schemas: {
-    context: BaseJoi.ObjectSchema<any>;
-    tokenInput: BaseJoi.ObjectSchema<any>;
-    multiInput: BaseJoi.ArraySchema<any[]>;
-    multiSig: BaseJoi.ArraySchema<any[]>;
-    foreignToken: BaseJoi.ObjectSchema<any>;
-    variableInput: BaseJoi.ObjectSchema<any>;
-    nftDisplay: BaseJoi.ObjectSchema<any>;
-    nftEndpoint: BaseJoi.ObjectSchema<any>;
-    nftIssuer: BaseJoi.ObjectSchema<any>;
-    tokenHolder: BaseJoi.AlternativesSchema<any>;
-    assetProps: {
-        address: DIDSchema;
-        moniker: BaseJoi.StringSchema<string>;
-        data: BaseJoi.AnySchema<any>;
-        readonly: BaseJoi.BooleanSchema<boolean>;
-        transferrable: BaseJoi.BooleanSchema<boolean>;
-        ttl: BaseJoi.NumberSchema<number>;
-        parent: DIDSchema;
-        issuer: DIDSchema;
-        endpoint: BaseJoi.ObjectSchema<any>;
-        display: BaseJoi.ObjectSchema<any>;
-        tags: BaseJoi.ArraySchema<any[]>;
-    };
-    assetSchema: BaseJoi.ObjectSchema<any>;
-    factoryProps: {
-        address: DIDSchema;
-        name: BaseJoi.StringSchema<string>;
-        description: BaseJoi.StringSchema<string>;
-        settlement: BaseJoi.StringSchema<string>;
-        limit: BaseJoi.NumberSchema<number>;
-        trustedIssuers: BaseJoi.ArraySchema<any[]>;
-        data: BaseJoi.AnySchema<any>;
-        display: BaseJoi.ObjectSchema<any>;
-        input: BaseJoi.ObjectSchema<any>;
-        output: BaseJoi.ObjectSchema<any>;
-        hooks: BaseJoi.ArraySchema<any[]>;
-    };
-    factorySchema: BaseJoi.ObjectSchema<any>;
+declare const Joi: ExtendedRoot;
+declare const schemas: {
+  context: BaseJoi.ObjectSchema<any>;
+  tokenInput: BaseJoi.ObjectSchema<any>;
+  multiInput: BaseJoi.ArraySchema<any[]>;
+  multiSig: BaseJoi.ArraySchema<any[]>;
+  foreignToken: BaseJoi.ObjectSchema<any>;
+  variableInput: BaseJoi.ObjectSchema<any>;
+  nftDisplay: BaseJoi.ObjectSchema<any>;
+  nftEndpoint: BaseJoi.ObjectSchema<any>;
+  nftIssuer: BaseJoi.ObjectSchema<any>;
+  tokenHolder: BaseJoi.AlternativesSchema<any>;
+  assetProps: {
+    address: DIDSchema;
+    moniker: BaseJoi.StringSchema<string>;
+    data: BaseJoi.AnySchema<any>;
+    readonly: BaseJoi.BooleanSchema<boolean>;
+    transferrable: BaseJoi.BooleanSchema<boolean>;
+    ttl: BaseJoi.NumberSchema<number>;
+    parent: DIDSchema;
+    issuer: DIDSchema;
+    endpoint: BaseJoi.ObjectSchema<any>;
+    display: BaseJoi.ObjectSchema<any>;
+    tags: BaseJoi.ArraySchema<any[]>;
+  };
+  assetSchema: BaseJoi.ObjectSchema<any>;
+  factoryProps: {
+    address: DIDSchema;
+    name: BaseJoi.StringSchema<string>;
+    description: BaseJoi.StringSchema<string>;
+    settlement: BaseJoi.StringSchema<string>;
+    limit: BaseJoi.NumberSchema<number>;
+    trustedIssuers: BaseJoi.ArraySchema<any[]>;
+    data: BaseJoi.AnySchema<any>;
+    display: BaseJoi.ObjectSchema<any>;
+    input: BaseJoi.ObjectSchema<any>;
+    output: BaseJoi.ObjectSchema<any>;
+    hooks: BaseJoi.ArraySchema<any[]>;
+  };
+  factorySchema: BaseJoi.ObjectSchema<any>;
 };
-export declare const patterns: {
-    txHash: RegExp;
+declare const patterns: {
+  txHash: RegExp;
 };
+//#endregion
+export { ExtendedRoot, Joi, patterns, schemas };