@atcute/lexicons 1.1.1 → 1.2.0

package/dist/validations/index.d.ts

@@ -1,3 +1,4 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import * as syntax from '../syntax/index.js';
 import * as interfaces from '../interfaces/index.js';
 import type { $type } from '../types/brand.js';
@@ -22,51 +23,45 @@ type StringFormatMap = {
 export type StringFormat = keyof StringFormatMap;
 type Literal = string | number | boolean;
 type Key = string | number;
+type IssueFormatter = () => string;
 export type IssueLeaf = {
     ok: false;
+    msg: IssueFormatter;
+} & ({
     code: 'missing_value';
 } | {
-    ok: false;
     code: 'invalid_literal';
     expected: readonly Literal[];
 } | {
-    ok: false;
     code: 'invalid_type';
     expected: InputType;
 } | {
-    ok: false;
     code: 'invalid_variant';
     expected: string[];
 } | {
-    ok: false;
     code: 'invalid_integer_range';
     min: number;
     max: number;
 } | {
-    ok: false;
     code: 'invalid_string_format';
     expected: StringFormat;
 } | {
-    ok: false;
     code: 'invalid_string_graphemes';
     minGraphemes: number;
     maxGraphemes: number;
 } | {
-    ok: false;
     code: 'invalid_string_length';
     minLength: number;
     maxLength: number;
 } | {
-    ok: false;
     code: 'invalid_array_length';
     minLength: number;
     maxLength: number;
 } | {
-    ok: false;
     code: 'invalid_bytes_size';
     minSize: number;
     maxSize: number;
-};
+});
 export type IssueTree = IssueLeaf | {
     ok: false;
     code: 'prepend';
@@ -134,6 +129,7 @@ export type Err = {
     throw(): never;
 };
 export type ValidationResult<T> = Ok<T> | Err;
+export declare const ok: <T>(value: T) => Ok<T>;
 declare const kType: unique symbol;
 type kType = typeof kType;
 declare const kObjectType: unique symbol;
@@ -142,10 +138,12 @@ export declare const FLAG_EMPTY = 0;
 export declare const FLAG_ABORT_EARLY: number;
 type MatcherResult = undefined | Ok<unknown> | IssueTree;
 type Matcher = (input: unknown, flags: number) => MatcherResult;
+type LexStandardSchema<T extends BaseSchema> = StandardSchemaV1.Props<InferInput<T>, InferOutput<T>>;
 export interface BaseSchema<TInput = unknown, TOutput = TInput> {
     readonly kind: 'schema';
     readonly type: string;
     readonly '~run': Matcher;
+    readonly '~standard': LexStandardSchema<this>;
     readonly [kType]?: {
         in: TInput;
         out: TOutput;

package/dist/validations/index.js

@@ -11,13 +11,17 @@ const joinIssues = (left, right) => {
 const prependPath = (key, tree) => {
     return { ok: false, code: 'prepend', key, tree };
 };
+// #__NO_SIDE_EFFECTS__
+export const ok = (value) => {
+    return { ok: true, value };
+};
 // None set
 export const FLAG_EMPTY = 0;
 // Don't continue validation if an error is encountered
 export const FLAG_ABORT_EARLY = 1 << 0;
 // #region Schema runner
 const cloneIssueWithPath = (issue, path) => {
-    const { ok: _ok, ...clone } = issue;
+    const { ok: _ok, msg: _fmt, ...clone } = issue;
     return { ...clone, path };
 };
 const collectIssues = (tree, path = [], issues = []) => {
@@ -112,65 +116,7 @@ const formatIssueTree = (tree) => {
         }
         break;
     }
-    let message;
-    switch (tree.code) {
-        case 'missing_value': {
-            message = `missing value`;
-            break;
-        }
-        case 'invalid_literal': {
-            message = `expected ${separatedList(tree.expected.map(formatLiteral), 'or')}`;
-            break;
-        }
-        case 'invalid_type': {
-            message = `expected ${tree.expected}`;
-            break;
-        }
-        case 'invalid_variant': {
-            message = `expected ${separatedList(tree.expected, 'or')}`;
-            break;
-        }
-        case 'invalid_integer_range': {
-            const min = tree.min;
-            const max = tree.max;
-            message = `expected an integer `;
-            if (min > 0) {
-                if (max === min) {
-                    message += `of exactly ${min}`;
-                }
-                else if (max !== Infinity) {
-                    message += `between ${min} and ${max}`;
-                }
-                else {
-                    message += `of at least ${min}`;
-                }
-            }
-            else {
-                message += `of at most ${max}`;
-            }
-            break;
-        }
-        case 'invalid_string_format': {
-            message = `expected a ${tree.expected} formatted string`;
-            break;
-        }
-        case 'invalid_string_graphemes': {
-            message = formatRangeMessage('a string', 'grapheme', tree.minGraphemes, tree.maxGraphemes);
-            break;
-        }
-        case 'invalid_string_length': {
-            message = formatRangeMessage('a string', 'character', tree.minLength, tree.maxLength);
-            break;
-        }
-        case 'invalid_array_length': {
-            message = formatRangeMessage('an array', 'item', tree.minLength, tree.maxLength);
-            break;
-        }
-        case 'invalid_bytes_size': {
-            message = formatRangeMessage('a byte array', 'byte', tree.minSize, tree.maxSize);
-            break;
-        }
-    }
+    const message = tree.msg();
     let msg = `${tree.code} at ${path || '.'} (${message})`;
     if (count > 0) {
         msg += ` (+${count} other issue(s))`;
@@ -216,7 +162,7 @@ export const is = (schema, input) => {
 export const safeParse = (schema, input) => {
     const r = schema['~run'](input, FLAG_EMPTY);
     if (r === undefined) {
-        return { ok: true, value: input };
+        return ok(input);
     }
     if (r.ok) {
         return r;
@@ -233,6 +179,43 @@ export const parse = (schema, input) => {
     }
     throw new ValidationError(r);
 };
+// #region Standard Schema support
+const collectStandardIssues = (tree, path = [], issues = []) => {
+    for (;;) {
+        switch (tree.code) {
+            case 'join': {
+                collectStandardIssues(tree.left, path.slice(), issues);
+                tree = tree.right;
+                continue;
+            }
+            case 'prepend': {
+                path.push(tree.key);
+                tree = tree.tree;
+                continue;
+            }
+            default: {
+                issues.push({ message: tree.msg(), path: path.length > 0 ? path : undefined });
+                return issues;
+            }
+        }
+    }
+};
+const toStandardSchema = (schema) => {
+    return {
+        version: 1,
+        vendor: '@atcute/lexicons',
+        validate(value) {
+            const r = schema['~run'](value, FLAG_EMPTY);
+            if (r === undefined) {
+                return { value: value };
+            }
+            if (r.ok) {
+                return { value: r.value };
+            }
+            return { issues: collectStandardIssues(r) };
+        },
+    };
+};
 // #__NO_SIDE_EFFECTS__
 export const constrain = (base, constraints) => {
     const len = constraints.length;
@@ -283,6 +266,9 @@ export const literal = (value) => {
         ok: false,
         code: 'invalid_literal',
         expected: [value],
+        msg() {
+            return `expected ${formatLiteral(value)}`;
+        },
     };
     return {
         kind: 'schema',
@@ -294,6 +280,9 @@ export const literal = (value) => {
             }
             return undefined;
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 // #__NO_SIDE_EFFECTS__
@@ -302,6 +291,9 @@ export const literalEnum = (values) => {
         ok: false,
         code: 'invalid_literal',
         expected: values,
+        msg() {
+            return `expected ${separatedList(values.map(formatLiteral), 'or')}`;
+        },
     };
     return {
         kind: 'schema',
@@ -313,12 +305,18 @@ export const literalEnum = (values) => {
             }
             return undefined;
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 const ISSUE_TYPE_BOOLEAN = {
     ok: false,
     code: 'invalid_type',
     expected: 'boolean',
+    msg() {
+        return `expected boolean`;
+    },
 };
 const BOOLEAN_SCHEMA = {
     kind: 'schema',
@@ -329,6 +327,9 @@ const BOOLEAN_SCHEMA = {
         }
         return undefined;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const boolean = () => {
@@ -338,6 +339,9 @@ const ISSUE_TYPE_INTEGER = {
     ok: false,
     code: 'invalid_type',
     expected: 'integer',
+    msg() {
+        return `expected integer`;
+    },
 };
 const INTEGER_SCHEMA = {
     kind: 'schema',
@@ -351,6 +355,9 @@ const INTEGER_SCHEMA = {
         }
         return undefined;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const integer = () => {
@@ -363,6 +370,24 @@ export const integerRange = (min, max = Infinity) => {
         code: 'invalid_integer_range',
         min: min,
         max: max,
+        msg() {
+            let message = `expected an integer `;
+            if (min > 0) {
+                if (max === min) {
+                    message += `of exactly ${min}`;
+                }
+                else if (max !== Infinity) {
+                    message += `between ${min} and ${max}`;
+                }
+                else {
+                    message += `of at least ${min}`;
+                }
+            }
+            else {
+                message += `of at most ${max}`;
+            }
+            return message;
+        },
     };
     return {
         kind: 'constraint',
@@ -384,6 +409,9 @@ const ISSUE_TYPE_STRING = {
     ok: false,
     code: 'invalid_type',
     expected: 'string',
+    msg() {
+        return `expected string`;
+    },
 };
 const STRING_SINGLETON = {
     kind: 'schema',
@@ -395,6 +423,9 @@ const STRING_SINGLETON = {
         }
         return undefined;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const string = () => {
@@ -406,6 +437,9 @@ const _formattedString = (format, validate) => {
         ok: false,
         code: 'invalid_string_format',
         expected: format,
+        msg() {
+            return `expected a ${format} formatted string`;
+        },
     };
     const schema = {
         kind: 'schema',
@@ -420,6 +454,9 @@ const _formattedString = (format, validate) => {
             }
             return undefined;
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
     return () => schema;
 };
@@ -442,6 +479,9 @@ export const stringLength = (minLength, maxLength = Infinity) => {
         code: 'invalid_string_length',
         minLength: minLength,
         maxLength: maxLength,
+        msg() {
+            return formatRangeMessage('a string', 'character', minLength, maxLength);
+        },
     };
     return {
         kind: 'constraint',
@@ -479,6 +519,9 @@ export const stringGraphemes = (minGraphemes, maxGraphemes = Infinity) => {
         code: 'invalid_string_graphemes',
         minGraphemes: minGraphemes,
         maxGraphemes: maxGraphemes,
+        msg() {
+            return formatRangeMessage('a string', 'grapheme', minGraphemes, maxGraphemes);
+        },
     };
     return {
         kind: 'constraint',
@@ -513,6 +556,9 @@ const ISSUE_EXPECTED_BLOB = {
     ok: false,
     code: 'invalid_type',
     expected: 'blob',
+    msg() {
+        return `expected blob`;
+    },
 };
 const BLOB_SCHEMA = {
     kind: 'schema',
@@ -531,10 +577,13 @@ const BLOB_SCHEMA = {
                 ref: { $link: input.cid },
                 size: -1,
             };
-            return { ok: true, value: blob };
+            return ok(blob);
         }
         return ISSUE_EXPECTED_BLOB;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const blob = () => {
@@ -544,6 +593,9 @@ const ISSUE_EXPECTED_BYTES = {
     ok: false,
     code: 'invalid_type',
     expected: 'bytes',
+    msg() {
+        return `expected bytes`;
+    },
 };
 const BYTES_SCHEMA = {
     kind: 'schema',
@@ -554,6 +606,9 @@ const BYTES_SCHEMA = {
         }
         return undefined;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const bytes = () => {
@@ -566,6 +621,9 @@ export const bytesSize = (minSize, maxSize = Infinity) => {
         code: 'invalid_bytes_size',
         minSize: minSize,
         maxSize: maxSize,
+        msg() {
+            return formatRangeMessage('a byte array', 'byte', minSize, maxSize);
+        },
     };
     return {
         kind: 'constraint',
@@ -602,6 +660,9 @@ const ISSUE_EXPECTED_CID_LINK = {
     ok: false,
     code: 'invalid_type',
     expected: 'cid-link',
+    msg() {
+        return `expected cid-link`;
+    },
 };
 const CID_LINK_SCHEMA = {
     kind: 'schema',
@@ -612,6 +673,9 @@ const CID_LINK_SCHEMA = {
         }
         return undefined;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const cidLink = () => {
@@ -629,6 +693,9 @@ export const nullable = (wrapped) => {
             }
             return wrapped['~run'](input, flags);
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 // #__NO_SIDE_EFFECTS__
@@ -644,10 +711,13 @@ export const optional = (wrapped, defaultValue) => {
                     return undefined;
                 }
                 const value = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
-                return { ok: true, value };
+                return ok(value);
             }
             return wrapped['~run'](input, flags);
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 const isOptionalSchema = (schema) => {
@@ -657,6 +727,9 @@ const ISSUE_TYPE_ARRAY = {
     ok: false,
     code: 'invalid_type',
     expected: 'array',
+    msg() {
+        return `expected array`;
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const array = (item) => {
@@ -699,12 +772,15 @@ export const array = (item) => {
                     return issues;
                 }
                 if (output !== undefined) {
-                    return { ok: true, value: output };
+                    return ok(output);
                 }
                 return undefined;
             };
             return lazyProperty(this, '~run', matcher);
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 // #__NO_SIDE_EFFECTS__
@@ -714,6 +790,9 @@ export const arrayLength = (minLength, maxLength = Infinity) => {
         code: 'invalid_array_length',
         minLength: minLength,
         maxLength: maxLength,
+        msg() {
+            return formatRangeMessage('an array', 'item', minLength, maxLength);
+        },
     };
     return {
         kind: 'constraint',
@@ -736,10 +815,16 @@ const ISSUE_TYPE_OBJECT = {
     ok: false,
     code: 'invalid_type',
     expected: 'object',
+    msg() {
+        return `expected object`;
+    },
 };
 const ISSUE_MISSING = {
     ok: false,
     code: 'missing_value',
+    msg() {
+        return `missing value`;
+    },
 };
 const set = (obj, key, value) => {
     if (key === '__proto__') {
@@ -782,6 +867,7 @@ export const object = (shape) => {
             const len = shape.length;
             const generateFastpass = () => {
                 const fields = [
+                    ['$ok', ok],
                     ['$joinIssues', joinIssues],
                     ['$prependPath', prependPath],
                 ];
@@ -820,7 +906,7 @@ export const object = (shape) => {
                     }
                     doc += `}`;
                 }
-                doc += `if($iss!==undefined)return $iss;if($out!==undefined)return{ok:true,value:$out};`;
+                doc += `if($iss!==undefined)return $iss;if($out!==undefined)return $ok($out);`;
                 const fn = new Function(`[${fields.map(([id]) => id).join(',')}]`, `return function matcher($in,$flags){${doc}}`);
                 return fn(fields.map(([, field]) => field));
             };
@@ -871,12 +957,15 @@ export const object = (shape) => {
                     return issues;
                 }
                 if (output !== undefined) {
-                    return { ok: true, value: output };
+                    return ok(output);
                 }
                 return undefined;
             };
             return lazyProperty(this, '~run', matcher);
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 // #__NO_SIDE_EFFECTS__
@@ -901,17 +990,13 @@ export const record = (key, object) => {
         '~run'(input, flags) {
             return lazyProperty(this, '~run', validatedObject.value['~run'])(input, flags);
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
-const ISSUE_VARIANT_MISSING = /*#__PURE__*/ prependPath('$type', {
-    ok: false,
-    code: 'missing_value',
-});
-const ISSUE_VARIANT_TYPE = /*#__PURE__*/ prependPath('$type', {
-    ok: false,
-    code: 'invalid_type',
-    expected: 'string',
-});
+const ISSUE_VARIANT_MISSING = /*#__PURE__*/ prependPath('$type', ISSUE_MISSING);
+const ISSUE_VARIANT_TYPE = /*#__PURE__*/ prependPath('$type', ISSUE_TYPE_STRING);
 // #__NO_SIDE_EFFECTS__
 export const variant = (members, closed = false) => {
     return {
@@ -934,6 +1019,9 @@ export const variant = (members, closed = false) => {
                 ok: false,
                 code: 'invalid_variant',
                 expected: Object.keys(map),
+                msg() {
+                    return `expected ${separatedList(Object.keys(map), 'or')}`;
+                },
             };
             const matcher = (input, flags) => {
                 if (!isObject(input)) {
@@ -957,12 +1045,18 @@ export const variant = (members, closed = false) => {
             };
             return lazyProperty(this, '~run', matcher);
         },
+        get '~standard'() {
+            return lazyProperty(this, '~standard', toStandardSchema(this));
+        },
     };
 };
 const ISSUE_TYPE_UNKNOWN = {
     ok: false,
     code: 'invalid_type',
     expected: 'unknown',
+    msg() {
+        return `expected unknown`;
+    },
 };
 const UNKNOWN_SCHEMA = {
     kind: 'schema',
@@ -973,6 +1067,9 @@ const UNKNOWN_SCHEMA = {
         }
         return undefined;
     },
+    get '~standard'() {
+        return lazyProperty(this, '~standard', toStandardSchema(this));
+    },
 };
 // #__NO_SIDE_EFFECTS__
 export const unknown = () => {