@loomcli/validators 0.5.0 → 0.6.0

package/dist/issue-code.js

@@ -0,0 +1,183 @@
+import { isRuleIdentity } from '@loomcli/core';
+import { isPlainObject } from './data.js';
+import { fault, quote } from './faults.js';
+import { issueCodeConfig, issueCodeName, issueCodeSchema, issueParameters } from './rules.js';
+/** The Standard Schema version this package reads. */
+const standardVersion = 1;
+/** Whether a value is an object or a function, which alone can carry fields. */
+function isObjectLike(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+/**
+ * Whether a value answers the Standard Schema v1 contract, as core checks a validator. A value
+ * whose fields throw when read, through a getter or a proxy trap, is not a Standard Schema.
+ */
+function isStandardSchema(value) {
+    try {
+        if (!isObjectLike(value)) {
+            return false;
+        }
+        const standard = '~standard' in value ? value['~standard'] : undefined;
+        return (standard !== null &&
+            typeof standard === 'object' &&
+            'version' in standard &&
+            standard.version === standardVersion &&
+            'vendor' in standard &&
+            typeof standard.vendor === 'string' &&
+            'validate' in standard &&
+            typeof standard.validate === 'function');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The verdict a schema's result states, or `undefined` for a value that is not a Standard Schema
+ * result: a success must hold its own `value` and no issues, and a failure an issues array. Both
+ * `issue` and `read` read a result here, so neither keeps parameters the schema never output. A
+ * getter or a proxy trap that throws while the result is read propagates to the caller.
+ */
+function verdictOf(result) {
+    if (!isObjectLike(result)) {
+        return undefined;
+    }
+    if (result.issues === undefined) {
+        return Object.hasOwn(result, 'value') ? { kind: 'accepted', params: result.value } : undefined;
+    }
+    const issues = result.issues;
+    return Array.isArray(issues) ? { kind: 'rejected' } : undefined;
+}
+/** The verdict a result states, where a result that throws while it is read states none. */
+function verdictOrNothing(result) {
+    try {
+        return verdictOf(result);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether a schema's answer is a promise or another thenable, which a synchronous read cannot
+ * wait for. A value whose `then` cannot be read is not a thenable, so the test never throws.
+ */
+function isThenable(value) {
+    try {
+        return isObjectLike(value) && 'then' in value && typeof value.then === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+/** The `issueCode()` call a fault marks one part of: the code, the config, or one of its keys. */
+function declarationAt(code, config, mark) {
+    return { arguments: [code, config], factory: 'issueCode', mark };
+}
+/** The mark for one key of a config object, or the config itself when the key is absent. */
+function keyMark(config, key) {
+    return key in config ? `1.${key}` : '1';
+}
+/** Faults on a declaration that bypassed the types: a code outside the grammar, or a bad config. */
+function checkDeclaration(code, config) {
+    if (!isRuleIdentity(code)) {
+        throw fault(issueCodeName, declarationAt(code, config, '0'), {
+            correction: 'Supply a code such as "@acme/validators/port-range", with each subpath segment and the rule of lowercase letters and digits in words joined by single hyphens.',
+            sentence: `issueCode() code ${quote(code)} is not a package name, any subpath segments, and a rule name joined by slashes.`,
+        });
+    }
+    if (!isPlainObject(config)) {
+        throw fault(issueCodeConfig, declarationAt(code, config, '1'), {
+            correction: 'Supply an object with a schema and a message function.',
+            sentence: 'issueCode() config is not a plain object.',
+        });
+    }
+    if (!isStandardSchema(config.schema)) {
+        throw fault(issueCodeConfig, declarationAt(code, config, keyMark(config, 'schema')), {
+            correction: 'Supply a Standard Schema value that validates the parameters.',
+            sentence: 'issueCode() schema is not a Standard Schema.',
+        });
+    }
+    if (typeof config.message !== 'function') {
+        throw fault(issueCodeConfig, declarationAt(code, config, keyMark(config, 'message')), {
+            correction: 'Supply a function that builds the sentence from the parameters.',
+            sentence: 'issueCode() message is not a function.',
+        });
+    }
+}
+/**
+ * Declares one issue code with its parameter schema and its one sentence, and returns a frozen
+ * descriptor. `issue` builds the rejection a `parse` function returns, and `read` recovers the
+ * typed parameters from an issue carrying the code.
+ */
+function issueCode(code, config) {
+    checkDeclaration(code, config);
+    const { message, schema } = config;
+    // A schema fault is the declaration's, so it marks the schema the code was declared with.
+    const schemaAt = declarationAt(code, config, '1.schema');
+    /** The schema's synchronous result; a promise faults, since neither caller can wait for it. */
+    function settled(answer) {
+        if (isThenable(answer)) {
+            // The unawaited answer may still reject, and an unobserved rejection would end the process.
+            void Promise.resolve(answer).catch(() => undefined);
+            throw fault(issueCodeSchema, schemaAt, {
+                correction: 'Supply a schema that validates synchronously.',
+                sentence: `Issue code ${JSON.stringify(code)} has a schema that answers with a promise.`,
+            });
+        }
+        return answer;
+    }
+    /** The schema's answer to the parameters `issue` was given; a throw is the declaration's fault. */
+    function declaredAnswer(params) {
+        try {
+            return schema['~standard'].validate(params);
+        }
+        catch {
+            throw fault(issueCodeSchema, schemaAt, {
+                correction: 'Supply a schema that returns its issues instead of throwing.',
+                sentence: `Issue code ${JSON.stringify(code)} has a schema that throws in issue().`,
+            });
+        }
+    }
+    /**
+     * The verdict `issue` builds from. Anything but a well-formed synchronous result is the
+     * declaration's fault, so a result that throws while it is read is not a result either.
+     */
+    function declaredVerdict(params) {
+        const verdict = verdictOrNothing(settled(declaredAnswer(params)));
+        if (verdict === undefined) {
+            throw fault(issueCodeSchema, schemaAt, {
+                correction: 'Supply a schema that returns its value or its issues.',
+                sentence: `Issue code ${JSON.stringify(code)} has a schema that answers with a value that is not a Standard Schema result.`,
+            });
+        }
+        return verdict;
+    }
+    return Object.freeze({
+        code,
+        issue: (params) => {
+            const verdict = declaredVerdict(params);
+            if (verdict.kind === 'rejected') {
+                throw fault(issueParameters, { arguments: [params], factory: 'issue', mark: '0' }, {
+                    correction: 'Supply parameters its schema accepts.',
+                    sentence: `Issue code ${JSON.stringify(code)} rejects the parameters passed to issue().`,
+                });
+            }
+            return Object.freeze({ code, message: message(verdict.params), params: verdict.params });
+        },
+        // Core hands a failure view a plain-object copy of each issue a validator returned.
+        // Reading the copy's own fields runs no getter, and its parameters reach the schema as they are.
+        read: (issue) => {
+            const candidate = issue;
+            if (!isObjectLike(candidate) || !('code' in candidate) || candidate.code !== code) {
+                return undefined;
+            }
+            const params = 'params' in candidate ? candidate.params : undefined;
+            if (!isObjectLike(params)) {
+                return undefined;
+            }
+            const verdict = verdictOf(settled(schema['~standard'].validate(params)));
+            return verdict?.kind === 'accepted' ? verdict.params : undefined;
+        },
+        schema,
+    });
+}
+export { issueCode };

package/dist/issues.d.ts

@@ -1,6 +1,6 @@
 import type { StandardSchemaV1 } from '@loomcli/core';
-/** A rejection: one issue with no path and no code, carrying the configuration's one sentence. */
-declare function reject(message: string): StandardSchemaV1.FailureResult;
+/** A rejection: one issue with no path, carrying the configuration's code and one sentence. */
+declare function reject(issue: StandardSchemaV1.Issue): StandardSchemaV1.FailureResult;
 /** Joins items as a sentence lists them: `a`, `a or b`, or `a, b, or c`. */
 declare function listing(items: readonly string[]): string;
 export { listing, reject };

package/dist/issues.js

@@ -3,9 +3,9 @@ const pair = 2;
 const first = 0;
 /** The index of the last item, counted from the end. */
 const last = -1;
-/** A rejection: one issue with no path and no code, carrying the configuration's one sentence. */
-function reject(message) {
-    return { issues: [{ message }] };
+/** A rejection: one issue with no path, carrying the configuration's code and one sentence. */
+function reject(issue) {
+    return { issues: [issue] };
 }
 /** Joins items as a sentence lists them: `a`, `a or b`, or `a, b, or c`. */
 function listing(items) {

package/dist/number.js

@@ -1,4 +1,5 @@
-import { boundsSchema, boundsSentence, readBounds, withinBounds, withoutNegativeZero, } from './bounds.js';
+import { boundsIssue, boundsSchema, readBounds, withinBounds, withoutNegativeZero, } from './bounds.js';
+import { numberCodes } from './codes.js';
 import { createValidator } from './create.js';
 import { reject } from './issues.js';
 const decimal = /^-?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
@@ -10,15 +11,15 @@ function number(options) {
         factory: 'number',
         requirement: 'a finite number',
     });
-    const sentence = boundsSentence('a number', bounds);
+    const issue = boundsIssue(numberCodes, bounds);
     return createValidator({
         inputSchema: boundsSchema('number', bounds),
         parse: (raw) => {
             if (!decimal.test(raw)) {
-                return reject(sentence);
+                return reject(issue);
             }
             const value = withoutNegativeZero(Number(raw));
-            return Number.isFinite(value) && withinBounds(value, bounds) ? { value } : reject(sentence);
+            return Number.isFinite(value) && withinBounds(value, bounds) ? { value } : reject(issue);
         },
     });
 }

package/dist/one-of.js

@@ -1,46 +1,78 @@
+import { DeclarationError } from '@loomcli/core';
+import { oneOfIssue } from './codes.js';
 import { createValidator } from './create.js';
 import { fault } from './faults.js';
 import { reject } from './issues.js';
+import { oneOfValues } from './rules.js';
 const empty = 0;
+/** A fault of the list `oneOf()` received, marking the list or one of its values. */
+function listFault(values, mark, parts) {
+    return fault(oneOfValues, { arguments: [values], factory: 'oneOf', mark }, parts);
+}
 /** The declared list as unknown items, after faulting on one that is not an array or is empty. */
 function checkList(values) {
     if (!Array.isArray(values)) {
-        throw fault('oneOf() values is not an array. Supply an array of strings.');
+        throw listFault(values, '0', {
+            correction: 'Supply an array of strings.',
+            sentence: 'oneOf() values is not an array.',
+        });
     }
     const items = values;
     if (items.length === empty) {
-        throw fault('oneOf() values is empty. List at least one value.');
+        throw listFault(values, '0', {
+            correction: 'List at least one value.',
+            sentence: 'oneOf() values is empty.',
+        });
     }
     return items;
 }
-/** Faults on a value that is not a string, is empty, or was listed earlier. */
-function checkValue(item, seen) {
+/**
+ * Faults on a value that is not a string, is empty, or was listed earlier. `seen` holds the
+ * position of each value listed so far, so a repeat marks both.
+ */
+function checkValue(listed, index, seen) {
+    const item = listed[index];
     if (typeof item !== 'string') {
-        throw fault('oneOf() lists a value that is not a string. List strings only.');
+        throw listFault(listed, `0.${String(index)}`, {
+            correction: 'List strings only.',
+            sentence: 'oneOf() lists a value that is not a string.',
+        });
     }
     if (item === '') {
-        throw fault('oneOf() lists an empty string. List nonempty values only.');
+        throw listFault(listed, `0.${String(index)}`, {
+            correction: 'List nonempty values only.',
+            sentence: 'oneOf() lists an empty string.',
+        });
     }
-    if (seen.has(item)) {
-        throw fault(`oneOf() lists ${JSON.stringify(item)} twice. List each value once.`);
+    const first = seen.get(item);
+    if (first !== undefined) {
+        const call = { arguments: [listed], call: 'oneOf' };
+        throw new DeclarationError(oneOfValues, {
+            correction: 'List each value once.',
+            findings: [
+                { ...call, mark: `0.${String(first)}`, note: 'the first' },
+                { ...call, mark: `0.${String(index)}`, note: 'the second' },
+            ],
+            sentence: `oneOf() lists ${JSON.stringify(item)} twice.`,
+        });
     }
-    seen.add(item);
+    seen.set(item, index);
 }
 /** A token exactly equal to one of the declared values, typed as their union. */
 function oneOf(values) {
     checkList(values);
     // The copy is what the validator keeps, so the checks read the copy and not the caller's list.
     const listed = [...values];
-    const seen = new Set();
-    for (const item of listed) {
-        checkValue(item, seen);
+    const seen = new Map();
+    for (const index of listed.keys()) {
+        checkValue(listed, index, seen);
     }
-    const sentence = `Expected one of: ${listed.join(', ')}.`;
+    const issue = oneOfIssue.issue({ values: listed });
     return createValidator({
         inputSchema: { type: 'string', enum: [...listed] },
         parse: (raw) => {
             const match = listed.find((value) => value === raw);
-            return match === undefined ? reject(sentence) : { value: match };
+            return match === undefined ? reject(issue) : { value: match };
         },
     });
 }

package/dist/params.d.ts

@@ -0,0 +1,54 @@
+import type { StandardSchemaV1 } from '@loomcli/core';
+import type { PathKind } from './probe.js';
+/** A check on one parameter that also tells the compiler its type. */
+type Guard<Value> = (value: unknown) => value is Value;
+/** The parameters of a code whose sentence has no blank. */
+type NoParams = Readonly<Record<string, never>>;
+declare const isCount: Guard<number>;
+declare const isSafeInteger: Guard<number>;
+declare const isFiniteNumber: Guard<number>;
+declare const noParams: StandardSchemaV1<Readonly<Record<string, never>>, Readonly<Record<string, never>>>;
+declare function minParams(accepts: Guard<number>): StandardSchemaV1<{
+    min: number;
+}, {
+    min: number;
+}>;
+declare function maxParams(accepts: Guard<number>): StandardSchemaV1<{
+    max: number;
+}, {
+    max: number;
+}>;
+declare function rangeParams(accepts: Guard<number>): StandardSchemaV1<{
+    max: number;
+    min: number;
+}, {
+    max: number;
+    min: number;
+}>;
+declare const lengthParams: StandardSchemaV1<{
+    length: number;
+}, {
+    length: number;
+}>;
+declare const messageParams: StandardSchemaV1<{
+    message: string;
+}, {
+    message: string;
+}>;
+declare const valuesParams: StandardSchemaV1<{
+    values: readonly string[];
+}, {
+    values: readonly string[];
+}>;
+declare const protocolsParams: StandardSchemaV1<{
+    protocols: readonly string[];
+}, {
+    protocols: readonly string[];
+}>;
+declare const kindParams: StandardSchemaV1<{
+    kind: PathKind;
+}, {
+    kind: PathKind;
+}>;
+export { isCount, isFiniteNumber, isSafeInteger, kindParams, lengthParams, maxParams, messageParams, minParams, noParams, protocolsParams, rangeParams, valuesParams, };
+export type { NoParams };

package/dist/params.js

@@ -0,0 +1,68 @@
+import { vendor } from './create.js';
+import { isPlainObject } from './data.js';
+/**
+ * A Standard Schema for one fixed parameter shape, built without a schema library. It accepts a
+ * plain object with exactly `keys`, which `read` turns into the typed parameters, and outputs a
+ * frozen copy, so an issue's parameters cannot be changed by a reader.
+ */
+function paramsSchema(shape, keys, read) {
+    const refusal = () => ({
+        issues: [{ message: `Expected the parameters ${shape}.` }],
+    });
+    return Object.freeze({
+        '~standard': Object.freeze({
+            validate: (value) => {
+                if (!isPlainObject(value)) {
+                    return refusal();
+                }
+                const exact = Object.keys(value).length === keys.length &&
+                    keys.every((key) => Object.hasOwn(value, key));
+                const params = exact ? read(value) : undefined;
+                if (params === undefined) {
+                    return refusal();
+                }
+                Object.freeze(params);
+                return { value: params };
+            },
+            vendor,
+            version: 1,
+        }),
+    });
+}
+const none = 0;
+const isCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= none;
+const isSafeInteger = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isKind = (value) => value === 'file' || value === 'directory' || value === 'any';
+/** A nonempty list of strings, copied and frozen, or undefined for anything else. */
+function stringList(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value;
+    return items.length > none && items.every((item) => typeof item === 'string')
+        ? Object.freeze([...items])
+        : undefined;
+}
+const noParams = paramsSchema('{}', [], () => ({}));
+function minParams(accepts) {
+    return paramsSchema('{ min: number }', ['min'], ({ min }) => accepts(min) ? { min } : undefined);
+}
+function maxParams(accepts) {
+    return paramsSchema('{ max: number }', ['max'], ({ max }) => accepts(max) ? { max } : undefined);
+}
+function rangeParams(accepts) {
+    return paramsSchema('{ min: number; max: number }', ['max', 'min'], ({ max, min }) => accepts(max) && accepts(min) ? { max, min } : undefined);
+}
+const lengthParams = paramsSchema('{ length: number }', ['length'], ({ length }) => isCount(length) ? { length } : undefined);
+const messageParams = paramsSchema('{ message: string }', ['message'], ({ message }) => typeof message === 'string' && message !== '' ? { message } : undefined);
+const valuesParams = paramsSchema('{ values: readonly string[] }', ['values'], (record) => {
+    const values = stringList(record.values);
+    return values === undefined ? undefined : { values };
+});
+const protocolsParams = paramsSchema('{ protocols: readonly string[] }', ['protocols'], (record) => {
+    const protocols = stringList(record.protocols);
+    return protocols === undefined ? undefined : { protocols };
+});
+const kindParams = paramsSchema("{ kind: 'file' | 'directory' | 'any' }", ['kind'], ({ kind }) => isKind(kind) ? { kind } : undefined);
+export { isCount, isFiniteNumber, isSafeInteger, kindParams, lengthParams, maxParams, messageParams, minParams, noParams, protocolsParams, rangeParams, valuesParams, };

package/dist/path.js

@@ -1,34 +1,34 @@
 import { posix, win32 } from 'node:path';
+import { pathIssue, pathReadableIssue, pathWritableIssue } from './codes.js';
 import { createValidator } from './create.js';
 import { fault, readOptions } from './faults.js';
 import { reject } from './issues.js';
 import { readable, writable } from './probe.js';
-const sentences = {
-    read: {
-        any: 'Expected a readable file or directory that exists.',
-        directory: 'Expected a readable directory that exists.',
-        file: 'Expected a readable file that exists.',
-    },
-    write: {
-        any: 'Expected a writable path, or a new path in a writable directory.',
-        directory: 'Expected a writable directory, or a new directory in a writable directory.',
-        file: 'Expected a writable file, or a new file in a writable directory.',
-    },
-};
-function accessOf(value) {
+import { pathCheck } from './rules.js';
+function accessOf(call, value) {
     if (value === undefined || value === 'read' || value === 'write') {
         return value;
     }
-    throw fault('path() access is not "read" or "write". Supply "read" or "write".');
+    throw fault(pathCheck, { ...call, mark: '0.access' }, {
+        correction: 'Supply "read" or "write".',
+        sentence: 'path() access is not "read" or "write".',
+    });
 }
-function kindOf(value, access) {
+function kindOf(call, value, access) {
+    const at = { ...call, mark: '0.kind' };
     if (value !== undefined && access === undefined) {
-        throw fault('path() kind has no access to check. Supply an access or leave out kind.');
+        throw fault(pathCheck, at, {
+            correction: 'Supply an access or leave out kind.',
+            sentence: 'path() kind has no access to check.',
+        });
     }
     if (value === undefined || value === 'file' || value === 'directory' || value === 'any') {
         return value ?? 'file';
     }
-    throw fault('path() kind is not "file", "directory", or "any". Supply one of them.');
+    throw fault(pathCheck, at, {
+        correction: 'Supply one of them.',
+        sentence: 'path() kind is not "file", "directory", or "any".',
+    });
 }
 /**
  * A path resolved against the host's cwd under the host platform's rules, and normalized.
@@ -36,14 +36,17 @@ function kindOf(value, access) {
  */
 function path(options) {
     const declared = readOptions('path', options);
-    const access = accessOf(declared.access);
-    const kind = kindOf(declared.kind, access);
-    const sentence = access === undefined ? 'Expected a path.' : sentences[access][kind];
+    const call = { arguments: [options], factory: 'path' };
+    const access = accessOf(call, declared.access);
+    const kind = kindOf(call, declared.kind, access);
+    const issue = access === undefined
+        ? pathIssue.issue({})
+        : (access === 'read' ? pathReadableIssue : pathWritableIssue).issue({ kind });
     return createValidator({
         inputSchema: { type: 'string', minLength: 1 },
         parse: (raw, context) => {
             if (raw === '' || raw.includes('\0')) {
-                return reject(sentence);
+                return reject(issue);
             }
             const { cwd, platform } = context.host;
             const rules = platform === 'win32' ? win32 : posix;
@@ -54,7 +57,7 @@ function path(options) {
             const probe = access === 'read'
                 ? readable(resolved, kind)
                 : writable(resolved, kind, rules.dirname(resolved));
-            return probe.then((passes) => (passes ? { value: resolved } : reject(sentence)));
+            return probe.then((passes) => (passes ? { value: resolved } : reject(issue)));
         },
     });
 }

package/dist/port.js

@@ -1,17 +1,17 @@
 import { boundsSchema, withinBounds } from './bounds.js';
+import { portIssue } from './codes.js';
 import { createValidator } from './create.js';
 import { readInteger } from './integer.js';
 import { reject } from './issues.js';
 const range = { max: 65_535, min: 1 };
 /** A TCP or UDP port the operator names, 1 through 65535; port 0 is left to `integer()`. */
 function port() {
+    const issue = portIssue.issue({});
     return createValidator({
         inputSchema: boundsSchema('integer', range),
         parse: (raw) => {
             const value = readInteger(raw);
-            return value !== undefined && withinBounds(value, range)
-                ? { value }
-                : reject('Expected a port number from 1 through 65535.');
+            return value !== undefined && withinBounds(value, range) ? { value } : reject(issue);
         },
     });
 }

package/dist/rules.d.ts

@@ -0,0 +1,32 @@
+import type { DiagnosticRule } from '@loomcli/core';
+/** A factory's options that are not a plain object. */
+declare const factoryOptions: DiagnosticRule;
+/** A `oneOf()` list that is not a list of distinct nonempty strings. */
+declare const oneOfValues: DiagnosticRule;
+/** A bound that is not a number of the kind its validator reads. */
+declare const boundValue: DiagnosticRule;
+/** A lower bound above its upper bound. */
+declare const boundsOrder: DiagnosticRule;
+/** A `url()` protocols list that is not a list of scheme names. */
+declare const urlProtocols: DiagnosticRule;
+/** A `path()` access or kind outside its set, or a kind with no access to narrow. */
+declare const pathCheck: DiagnosticRule;
+/** A `text()` pattern that JSON Schema cannot read as it is. */
+declare const textPattern: DiagnosticRule;
+/** A `text()` pattern without its sentence, or a sentence without a pattern. */
+declare const patternMessage: DiagnosticRule;
+/** An issue code outside the `<package>[/<subpath>...]/<kebab-case-rule>` grammar. */
+declare const issueCodeName: DiagnosticRule;
+/** An `issueCode()` config without a Standard Schema and a message function. */
+declare const issueCodeConfig: DiagnosticRule;
+/** An issue code schema that answers with a promise, throws, or answers with no result. */
+declare const issueCodeSchema: DiagnosticRule;
+/** Parameters an issue code's schema rejects. */
+declare const issueParameters: DiagnosticRule;
+/** A `createValidator()` definition without a parse function. */
+declare const validatorDefinition: DiagnosticRule;
+/** A `createValidator()` input schema that is not a plain object, or declares its own dialect. */
+declare const inputSchema: DiagnosticRule;
+/** A validator that read the validation context outside a Loom run. */
+declare const contextOutsideRun: DiagnosticRule;
+export { boundsOrder, boundValue, contextOutsideRun, factoryOptions, inputSchema, issueCodeConfig, issueCodeName, issueCodeSchema, issueParameters, oneOfValues, pathCheck, patternMessage, textPattern, urlProtocols, validatorDefinition, };