@loomcli/validators 0.0.0 → 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Drew Butler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bounds.d.ts

@@ -0,0 +1,29 @@
+import type { StandardSchemaV1 } from '@loomcli/core';
+import type { BoundCodes } from './codes.js';
+/** Inclusive bounds on a numeric factory, either or both absent. */
+interface Bounds {
+    min: number | undefined;
+    max: number | undefined;
+}
+/** What a numeric factory requires of each bound, stated for its fault messages. */
+interface BoundRule {
+    factory: string;
+    accepts: (value: number) => boolean;
+    requirement: string;
+    correction: string;
+}
+/** Reads a numeric factory's `min` and `max`, and faults on a bad bound or `min` above `max`. */
+declare function readBounds(options: unknown, rule: BoundRule): Bounds;
+declare function withinBounds(value: number, { max, min }: Bounds): boolean;
+/** The number a numeric token outputs, with `-0` read as `0`. */
+declare function withoutNegativeZero(value: number): number;
+/** The one issue for a numeric configuration, under the code for the bounds it declares. */
+declare function boundsIssue(codes: BoundCodes, { max, min }: Bounds): StandardSchemaV1.Issue;
+/** The published schema for a numeric type, with each declared bound. */
+declare function boundsSchema(type: 'integer' | 'number', { max, min }: Bounds): {
+    type: "integer" | "number";
+    minimum?: number;
+    maximum?: number;
+};
+export { boundsIssue, boundsSchema, readBounds, withinBounds, withoutNegativeZero };
+export type { Bounds };

package/dist/bounds.js

@@ -0,0 +1,60 @@
+import { fault, readOptions } from './faults.js';
+import { boundsOrder, boundValue } from './rules.js';
+const zero = 0;
+/** One bound a numeric factory declares, checked against its rule; a fault marks the bound. */
+function boundOf(bound, name, value) {
+    const { call, rule } = bound;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !rule.accepts(value)) {
+        throw fault(boundValue, { ...call, mark: `0.${name}` }, {
+            correction: rule.correction,
+            sentence: `${rule.factory}() ${name} is not ${rule.requirement}.`,
+        });
+    }
+    return value;
+}
+/** Reads a numeric factory's `min` and `max`, and faults on a bad bound or `min` above `max`. */
+function readBounds(options, rule) {
+    const declared = readOptions(rule.factory, options);
+    const call = { arguments: [options], factory: rule.factory };
+    const min = boundOf({ call, rule }, 'min', declared.min);
+    const max = boundOf({ call, rule }, 'max', declared.max);
+    if (min !== undefined && max !== undefined && min > max) {
+        throw fault(boundsOrder, { ...call, mark: '0.min' }, {
+            correction: 'Supply a min at or below max.',
+            sentence: `${rule.factory}() min ${String(min)} is above max ${String(max)}.`,
+        });
+    }
+    return { max, min };
+}
+function withinBounds(value, { max, min }) {
+    return (min === undefined || value >= min) && (max === undefined || value <= max);
+}
+/** The number a numeric token outputs, with `-0` read as `0`. */
+function withoutNegativeZero(value) {
+    return value === zero ? zero : value;
+}
+/** The one issue for a numeric configuration, under the code for the bounds it declares. */
+function boundsIssue(codes, { max, min }) {
+    if (min !== undefined && max !== undefined) {
+        return codes.range.issue({ max, min });
+    }
+    if (min !== undefined) {
+        return codes.min.issue({ min });
+    }
+    if (max !== undefined) {
+        return codes.max.issue({ max });
+    }
+    return codes.unbounded.issue({});
+}
+/** The published schema for a numeric type, with each declared bound. */
+function boundsSchema(type, { max, min }) {
+    return {
+        type,
+        ...(min === undefined ? {} : { minimum: min }),
+        ...(max === undefined ? {} : { maximum: max }),
+    };
+}
+export { boundsIssue, boundsSchema, readBounds, withinBounds, withoutNegativeZero };

package/dist/codes.d.ts

@@ -0,0 +1,78 @@
+import type { IssueCode } from './issue-code.js';
+import type { NoParams } from './params.js';
+import type { PathKind } from './probe.js';
+declare const textNonemptyIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const textMinLengthIssue: IssueCode<{
+    min: number;
+}>;
+declare const textMaxLengthIssue: IssueCode<{
+    max: number;
+}>;
+declare const textExactLengthIssue: IssueCode<{
+    length: number;
+}>;
+declare const textLengthRangeIssue: IssueCode<{
+    max: number;
+    min: number;
+}>;
+/** The author's own sentence for a `text()` pattern, which is the code's one blank. */
+declare const textPatternIssue: IssueCode<{
+    message: string;
+}>;
+declare const integerIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const integerRangeIssue: IssueCode<{
+    max: number;
+    min: number;
+}>;
+declare const integerMinIssue: IssueCode<{
+    min: number;
+}>;
+declare const integerMaxIssue: IssueCode<{
+    max: number;
+}>;
+declare const numberIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const numberRangeIssue: IssueCode<{
+    max: number;
+    min: number;
+}>;
+declare const numberMinIssue: IssueCode<{
+    min: number;
+}>;
+declare const numberMaxIssue: IssueCode<{
+    max: number;
+}>;
+declare const portIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const oneOfIssue: IssueCode<{
+    values: readonly string[];
+}>;
+declare const urlIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const urlSchemeIssue: IssueCode<{
+    protocols: readonly string[];
+}>;
+declare const uuidIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const dateIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const pathIssue: IssueCode<Readonly<Record<string, never>>>;
+declare const pathReadableIssue: IssueCode<{
+    kind: PathKind;
+}>;
+declare const pathWritableIssue: IssueCode<{
+    kind: PathKind;
+}>;
+/** The four codes a numeric factory rejects with, one for each way its bounds are declared. */
+interface BoundCodes {
+    unbounded: IssueCode<NoParams>;
+    range: IssueCode<{
+        max: number;
+        min: number;
+    }>;
+    min: IssueCode<{
+        min: number;
+    }>;
+    max: IssueCode<{
+        max: number;
+    }>;
+}
+declare const integerCodes: BoundCodes;
+declare const numberCodes: BoundCodes;
+export { dateIssue, integerCodes, integerIssue, integerMaxIssue, integerMinIssue, integerRangeIssue, numberCodes, numberIssue, numberMaxIssue, numberMinIssue, numberRangeIssue, oneOfIssue, pathIssue, pathReadableIssue, pathWritableIssue, portIssue, textExactLengthIssue, textLengthRangeIssue, textMaxLengthIssue, textMinLengthIssue, textNonemptyIssue, textPatternIssue, urlIssue, urlSchemeIssue, uuidIssue, };
+export type { BoundCodes };

package/dist/codes.js

@@ -0,0 +1,134 @@
+import { issueCode } from './issue-code.js';
+import { listing } from './issues.js';
+import { isCount, isFiniteNumber, isSafeInteger, kindParams, lengthParams, maxParams, messageParams, minParams, noParams, protocolsParams, rangeParams, valuesParams, } from './params.js';
+/**
+ * The catalog's issue codes, one for each sentence a catalog validator prints. Each code's
+ * parameters are that sentence's blanks and hold the rule's settings, never the rejected value.
+ */
+const oneCharacter = 1;
+/** A count of characters, reading `character` for a count of 1. */
+function characters(count) {
+    return count === oneCharacter ? '1 character' : `${String(count)} characters`;
+}
+/** The catalog's own code for a rule: the package name, `/`, and the rule name. */
+function catalogCode(rule) {
+    return `@loomcli/validators/${rule}`;
+}
+const textNonemptyIssue = issueCode(catalogCode('text-nonempty'), {
+    message: () => 'Expected a nonempty value.',
+    schema: noParams,
+});
+const textMinLengthIssue = issueCode(catalogCode('text-min-length'), {
+    message: ({ min }) => `Expected at least ${characters(min)}.`,
+    schema: minParams(isCount),
+});
+const textMaxLengthIssue = issueCode(catalogCode('text-max-length'), {
+    message: ({ max }) => `Expected at most ${characters(max)}.`,
+    schema: maxParams(isCount),
+});
+const textExactLengthIssue = issueCode(catalogCode('text-exact-length'), {
+    message: ({ length }) => `Expected exactly ${characters(length)}.`,
+    schema: lengthParams,
+});
+const textLengthRangeIssue = issueCode(catalogCode('text-length-range'), {
+    message: ({ max, min }) => `Expected from ${String(min)} through ${characters(max)}.`,
+    schema: rangeParams(isCount),
+});
+/** The author's own sentence for a `text()` pattern, which is the code's one blank. */
+const textPatternIssue = issueCode(catalogCode('text-pattern'), {
+    message: ({ message }) => message,
+    schema: messageParams,
+});
+const integerIssue = issueCode(catalogCode('integer'), {
+    message: () => 'Expected a whole number.',
+    schema: noParams,
+});
+const integerRangeIssue = issueCode(catalogCode('integer-range'), {
+    message: ({ max, min }) => `Expected a whole number from ${String(min)} through ${String(max)}.`,
+    schema: rangeParams(isSafeInteger),
+});
+const integerMinIssue = issueCode(catalogCode('integer-min'), {
+    message: ({ min }) => `Expected a whole number of at least ${String(min)}.`,
+    schema: minParams(isSafeInteger),
+});
+const integerMaxIssue = issueCode(catalogCode('integer-max'), {
+    message: ({ max }) => `Expected a whole number of at most ${String(max)}.`,
+    schema: maxParams(isSafeInteger),
+});
+const numberIssue = issueCode(catalogCode('number'), {
+    message: () => 'Expected a number.',
+    schema: noParams,
+});
+const numberRangeIssue = issueCode(catalogCode('number-range'), {
+    message: ({ max, min }) => `Expected a number from ${String(min)} through ${String(max)}.`,
+    schema: rangeParams(isFiniteNumber),
+});
+const numberMinIssue = issueCode(catalogCode('number-min'), {
+    message: ({ min }) => `Expected a number of at least ${String(min)}.`,
+    schema: minParams(isFiniteNumber),
+});
+const numberMaxIssue = issueCode(catalogCode('number-max'), {
+    message: ({ max }) => `Expected a number of at most ${String(max)}.`,
+    schema: maxParams(isFiniteNumber),
+});
+const portIssue = issueCode(catalogCode('port'), {
+    message: () => 'Expected a port number from 1 through 65535.',
+    schema: noParams,
+});
+const oneOfIssue = issueCode(catalogCode('one-of'), {
+    message: ({ values }) => `Expected one of: ${values.join(', ')}.`,
+    schema: valuesParams,
+});
+const urlIssue = issueCode(catalogCode('url'), {
+    message: () => 'Expected an absolute URL, such as https://example.com.',
+    schema: noParams,
+});
+const urlSchemeIssue = issueCode(catalogCode('url-scheme'), {
+    message: ({ protocols }) => `Expected an absolute URL with the scheme ${listing(protocols)}.`,
+    schema: protocolsParams,
+});
+const uuidIssue = issueCode(catalogCode('uuid'), {
+    message: () => 'Expected a UUID, such as 123e4567-e89b-12d3-a456-426614174000.',
+    schema: noParams,
+});
+const dateIssue = issueCode(catalogCode('date'), {
+    message: () => 'Expected a date as YYYY-MM-DD, such as 2026-09-25.',
+    schema: noParams,
+});
+const pathIssue = issueCode(catalogCode('path'), {
+    message: () => 'Expected a nonempty path with no NUL character.',
+    schema: noParams,
+});
+/** How each kind reads in a readable-path sentence. */
+const readableKinds = {
+    any: 'file or directory',
+    directory: 'directory',
+    file: 'file',
+};
+/** How each kind reads in a writable-path sentence. */
+const writableKinds = {
+    any: 'path',
+    directory: 'directory',
+    file: 'file',
+};
+const pathReadableIssue = issueCode(catalogCode('path-readable'), {
+    message: ({ kind }) => `Expected a readable ${readableKinds[kind]} that exists.`,
+    schema: kindParams,
+});
+const pathWritableIssue = issueCode(catalogCode('path-writable'), {
+    message: ({ kind }) => `Expected a writable ${writableKinds[kind]}, or a new ${writableKinds[kind]} in a writable directory.`,
+    schema: kindParams,
+});
+const integerCodes = {
+    max: integerMaxIssue,
+    min: integerMinIssue,
+    range: integerRangeIssue,
+    unbounded: integerIssue,
+};
+const numberCodes = {
+    max: numberMaxIssue,
+    min: numberMinIssue,
+    range: numberRangeIssue,
+    unbounded: numberIssue,
+};
+export { dateIssue, integerCodes, integerIssue, integerMaxIssue, integerMinIssue, integerRangeIssue, numberCodes, numberIssue, numberMaxIssue, numberMinIssue, numberRangeIssue, oneOfIssue, pathIssue, pathReadableIssue, pathWritableIssue, portIssue, textExactLengthIssue, textLengthRangeIssue, textMaxLengthIssue, textMinLengthIssue, textNonemptyIssue, textPatternIssue, urlIssue, urlSchemeIssue, uuidIssue, };

package/dist/create.d.ts

@@ -0,0 +1,22 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1, ValidationContext } from '@loomcli/core';
+/** What `parse` returns: `{ value }` for an accepted token or `{ issues }` for a rejected one. */
+type ParseResult<Output> = StandardSchemaV1.Result<Output>;
+/** A validator that publishes its input schema, as every catalog factory returns. */
+type Validator<Output> = StandardSchemaV1<string, Output> & StandardJSONSchemaV1<string, Output>;
+/** The author's definition of one validator. */
+interface ValidatorDefinition<Output> {
+    parse: (raw: string, context: ValidationContext) => ParseResult<Output> | Promise<ParseResult<Output>>;
+    inputSchema?: Readonly<Record<string, unknown>>;
+}
+/** The vendor every Standard Schema value this package builds reports. */
+declare const vendor = "@loomcli/validators";
+/**
+ * Builds a frozen Standard Schema value from the author's parse function.
+ * With an input schema it also publishes that schema through Standard JSON Schema.
+ */
+declare function createValidator<Output>(definition: ValidatorDefinition<Output> & {
+    inputSchema: Readonly<Record<string, unknown>>;
+}): Validator<Output>;
+declare function createValidator<Output>(definition: ValidatorDefinition<Output>): StandardSchemaV1<string, Output>;
+export { createValidator, vendor };
+export type { ParseResult, Validator, ValidatorDefinition };

package/dist/create.js

@@ -0,0 +1,114 @@
+import { DeclarationError, validationContext } from '@loomcli/core';
+import { copyRecord, isPlainObject } from './data.js';
+import { fault } from './faults.js';
+import { contextOutsideRun, inputSchema, validatorDefinition } from './rules.js';
+/** The vendor every Standard Schema value this package builds reports. */
+const vendor = '@loomcli/validators';
+const target = 'draft-2020-12';
+const dialect = 'https://json-schema.org/draft/2020-12/schema';
+/** A read of the context outside a run, which no declaration call stands for. */
+function unavailable() {
+    throw new DeclarationError(contextOutsideRun, {
+        correction: 'Call the validator through an Application run, or leave the context unread.',
+        sentence: 'This validator reads the validation context, which only exists during a Loom run.',
+    });
+}
+/**
+ * The context `parse` receives when core did not make the call.
+ * Every field throws at the read, so only a validator that reads the context fails.
+ */
+const outsideRun = Object.freeze({
+    get command() {
+        return unavailable();
+    },
+    get host() {
+        return unavailable();
+    },
+    get input() {
+        return unavailable();
+    },
+    get passthrough() {
+        return unavailable();
+    },
+    get phase() {
+        return unavailable();
+    },
+    get supplied() {
+        return unavailable();
+    },
+});
+/** The converter that publishes a frozen input schema for draft 2020-12 and nothing else. */
+function converter(schema) {
+    return Object.freeze({
+        input: (options) => {
+            if (options.target !== target) {
+                throw new Error(`This validator publishes JSON Schema for ${target} only, not ${options.target}.`);
+            }
+            return { $schema: dialect, ...copyRecord(schema, false) };
+        },
+        output: () => {
+            throw new Error('This validator publishes no output schema.');
+        },
+    });
+}
+/**
+ * Checks a definition that bypassed the types, and returns its input schema copied and frozen, or
+ * undefined when it declares none.
+ */
+function checkDefinition(definition) {
+    const at = (mark) => ({ arguments: [definition], factory: 'createValidator', mark });
+    if (!isPlainObject(definition)) {
+        throw fault(validatorDefinition, at('0'), {
+            correction: 'Supply an object with a parse function.',
+            sentence: 'createValidator() definition is not a plain object.',
+        });
+    }
+    if (typeof definition.parse !== 'function') {
+        throw fault(validatorDefinition, at('parse' in definition ? '0.parse' : '0'), {
+            correction: 'Supply a function that validates one raw string.',
+            sentence: 'createValidator() parse is not a function.',
+        });
+    }
+    return declaredSchema(definition.inputSchema, at);
+}
+/**
+ * The declared input schema, checked, copied, and frozen, or undefined when none is declared. `at`
+ * rebuilds the `createValidator()` call, marking the part at fault.
+ */
+function declaredSchema(declared, at) {
+    if (declared === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(declared)) {
+        throw fault(inputSchema, at('0.inputSchema'), {
+            correction: 'Supply the JSON Schema as a plain object.',
+            sentence: 'createValidator() inputSchema is not a plain object.',
+        });
+    }
+    if (Object.hasOwn(declared, '$schema')) {
+        throw fault(inputSchema, at('0.inputSchema.$schema'), {
+            correction: 'Leave out $schema, which the validator publishes itself.',
+            sentence: 'createValidator() inputSchema declares its own $schema.',
+        });
+    }
+    return copyRecord(declared, true);
+}
+function createValidator(definition) {
+    const schema = checkDefinition(definition);
+    const { parse } = definition;
+    const props = {
+        validate: (value, options) => {
+            if (typeof value !== 'string') {
+                throw new TypeError(`A validator reads one raw string, and received a value of type ${typeof value}.`);
+            }
+            return parse(value, validationContext(options) ?? outsideRun);
+        },
+        vendor,
+        version: 1,
+    };
+    if (schema === undefined) {
+        return Object.freeze({ '~standard': Object.freeze(props) });
+    }
+    return Object.freeze({ '~standard': Object.freeze({ ...props, jsonSchema: converter(schema) }) });
+}
+export { createValidator, vendor };

package/dist/data.d.ts

@@ -0,0 +1,8 @@
+/** Whether a value is a plain object: an object literal or one made with a null prototype. */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * A deep copy of plain JSON-like data, so neither the author nor a reader can change the original.
+ * Arrays and plain objects are copied, frozen when asked, and every other value is kept as it is.
+ */
+declare function copyRecord(record: Readonly<Record<string, unknown>>, freeze: boolean): Record<string, unknown>;
+export { copyRecord, isPlainObject };

package/dist/data.js

@@ -0,0 +1,25 @@
+/** Whether a value is a plain object: an object literal or one made with a null prototype. */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function copyValue(value, freeze) {
+    if (Array.isArray(value)) {
+        const items = value;
+        const copy = items.map((item) => copyValue(item, freeze));
+        return freeze ? Object.freeze(copy) : copy;
+    }
+    return isPlainObject(value) ? copyRecord(value, freeze) : value;
+}
+/**
+ * A deep copy of plain JSON-like data, so neither the author nor a reader can change the original.
+ * Arrays and plain objects are copied, frozen when asked, and every other value is kept as it is.
+ */
+function copyRecord(record, freeze) {
+    const copy = Object.fromEntries(Object.entries(record).map(([key, value]) => [key, copyValue(value, freeze)]));
+    return freeze ? Object.freeze(copy) : copy;
+}
+export { copyRecord, isPlainObject };

package/dist/date.d.ts

@@ -0,0 +1,4 @@
+import type { Validator } from './create.js';
+/** A calendar date as `YYYY-MM-DD`, kept as the token because a date has no time or zone. */
+declare function date(): Validator<string>;
+export { date };

package/dist/date.js

@@ -0,0 +1,32 @@
+import { dateIssue } from './codes.js';
+import { createValidator } from './create.js';
+import { reject } from './issues.js';
+const layout = /^(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})$/u;
+/**
+ * Five 400-year Gregorian cycles.
+ * The calendar repeats every cycle, so a shifted year keeps its leap days, and the shift moves
+ * years below 100 out of the range `Date.UTC` maps to the 1900s.
+ */
+const cycleShift = 2000;
+/** The number of the first month, which `Date.UTC` counts from zero. */
+const january = 1;
+/** Whether the parts name a real day of the proleptic Gregorian calendar. */
+function isRealDay(year, month, day) {
+    const monthIndex = month - january;
+    const probe = new Date(Date.UTC(year + cycleShift, monthIndex, day));
+    return probe.getUTCMonth() === monthIndex && probe.getUTCDate() === day;
+}
+/** A calendar date as `YYYY-MM-DD`, kept as the token because a date has no time or zone. */
+function date() {
+    const issue = dateIssue.issue({});
+    return createValidator({
+        inputSchema: { type: 'string', format: 'date' },
+        parse: (raw) => {
+            const parts = layout.exec(raw)?.groups;
+            const real = parts !== undefined &&
+                isRealDay(Number(parts.year), Number(parts.month), Number(parts.day));
+            return real ? { value: raw } : reject(issue);
+        },
+    });
+}
+export { date };

package/dist/faults.d.ts

@@ -0,0 +1,29 @@
+import { DeclarationError } from '@loomcli/core';
+import type { DiagnosticRule } from '@loomcli/core';
+/** One factory call as a finding rebuilds it: the factory's name and the arguments it received. */
+interface FactoryCall {
+    readonly factory: string;
+    readonly arguments: readonly unknown[];
+}
+/**
+ * A factory argument that can never work, under the rule it breaks. The finding rebuilds the call
+ * and marks the argument or the key at fault, `mark` being its dotted path among the arguments,
+ * with a note when given. The sentence names the factory and the argument and states the problem,
+ * and the correction states the fix.
+ */
+declare function fault(rule: DiagnosticRule, at: FactoryCall & {
+    readonly mark: string;
+    readonly note?: string;
+}, parts: {
+    readonly sentence: string;
+    readonly correction: string;
+}): DeclarationError;
+/** A declared value as a fault message quotes it: a string in quotes, a primitive as printed. */
+declare function quote(value: unknown): string;
+/**
+ * A factory's options read as unknown values, because a JavaScript caller can pass anything.
+ * Omitted options read as an empty record.
+ */
+declare function readOptions(factory: string, options: unknown): Readonly<Record<string, unknown>>;
+export { fault, quote, readOptions };
+export type { FactoryCall };

package/dist/faults.js

@@ -0,0 +1,49 @@
+import { DeclarationError } from '@loomcli/core';
+import { isPlainObject } from './data.js';
+import { factoryOptions } from './rules.js';
+/**
+ * A factory argument that can never work, under the rule it breaks. The finding rebuilds the call
+ * and marks the argument or the key at fault, `mark` being its dotted path among the arguments,
+ * with a note when given. The sentence names the factory and the argument and states the problem,
+ * and the correction states the fix.
+ */
+function fault(rule, at, parts) {
+    const { mark, note } = at;
+    const finding = { arguments: at.arguments, call: at.factory, mark };
+    return new DeclarationError(rule, {
+        correction: parts.correction,
+        findings: [note === undefined ? finding : { ...finding, note }],
+        sentence: parts.sentence,
+    });
+}
+/** A declared value as a fault message quotes it: a string in quotes, a primitive as printed. */
+function quote(value) {
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        typeof value === 'bigint' ||
+        value === null ||
+        value === undefined) {
+        return String(value);
+    }
+    return `a value of type ${typeof value}`;
+}
+/**
+ * A factory's options read as unknown values, because a JavaScript caller can pass anything.
+ * Omitted options read as an empty record.
+ */
+function readOptions(factory, options) {
+    if (options === undefined) {
+        return {};
+    }
+    if (!isPlainObject(options)) {
+        throw fault(factoryOptions, { arguments: [options], factory, mark: '0' }, {
+            correction: 'Supply an object or leave it out.',
+            sentence: `${factory}() options is not a plain object.`,
+        });
+    }
+    return options;
+}
+export { fault, quote, readOptions };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { dateIssue, integerIssue, integerMaxIssue, integerMinIssue, integerRangeIssue, numberIssue, numberMaxIssue, numberMinIssue, numberRangeIssue, oneOfIssue, pathIssue, pathReadableIssue, pathWritableIssue, portIssue, textExactLengthIssue, textLengthRangeIssue, textMaxLengthIssue, textMinLengthIssue, textNonemptyIssue, textPatternIssue, urlIssue, urlSchemeIssue, uuidIssue, } from './codes.js';
+export { createValidator } from './create.js';
+export { date } from './date.js';
+export { integer } from './integer.js';
+export { issueCode } from './issue-code.js';
+export { number } from './number.js';
+export { oneOf } from './one-of.js';
+export { path } from './path.js';
+export { port } from './port.js';
+export { text } from './text.js';
+export { url } from './url.js';
+export { uuid } from './uuid.js';
+export type { ParseResult, Validator } from './create.js';
+export type { IssueCode } from './issue-code.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+export { dateIssue, integerIssue, integerMaxIssue, integerMinIssue, integerRangeIssue, numberIssue, numberMaxIssue, numberMinIssue, numberRangeIssue, oneOfIssue, pathIssue, pathReadableIssue, pathWritableIssue, portIssue, textExactLengthIssue, textLengthRangeIssue, textMaxLengthIssue, textMinLengthIssue, textNonemptyIssue, textPatternIssue, urlIssue, urlSchemeIssue, uuidIssue, } from './codes.js';
+export { createValidator } from './create.js';
+export { date } from './date.js';
+export { integer } from './integer.js';
+export { issueCode } from './issue-code.js';
+export { number } from './number.js';
+export { oneOf } from './one-of.js';
+export { path } from './path.js';
+export { port } from './port.js';
+export { text } from './text.js';
+export { url } from './url.js';
+export { uuid } from './uuid.js';

package/dist/integer.d.ts

@@ -0,0 +1,11 @@
+import type { Validator } from './create.js';
+interface IntegerOptions {
+    min?: number;
+    max?: number;
+}
+/** The safe integer a token spells in decimal digits, `-0` as `0`, or undefined when none. */
+declare function readInteger(raw: string): number | undefined;
+/** A decimal whole number that is a safe integer within `min` and `max`, both inclusive. */
+declare function integer(options?: IntegerOptions): Validator<number>;
+export { integer, readInteger };
+export type { IntegerOptions };