pema 0.5.0 → 0.6.0

package/lib/private/ParseError.d.ts

@@ -1,10 +1,14 @@
 import type JSONPayload from "#json/JSONPayload";
 import type ParseIssue from "#ParseIssue";
 import type { Serializable } from "@rcompat/type";
+declare const brand: unique symbol;
 export default class ParseError extends Error implements Serializable {
     #private;
+    [brand]: boolean;
+    static is(error: unknown): error is ParseError;
     constructor(issues: ParseIssue[]);
-    get issues(): ParseIssue[] | undefined;
+    get issues(): ParseIssue[];
     toJSON(): JSONPayload;
 }
+export {};
 //# sourceMappingURL=ParseError.d.ts.map

package/lib/private/ParseError.js

@@ -1,3 +1,4 @@
+import assert from "@rcompat/assert";
 function humanize(path) {
     return path === ""
         ? ""
@@ -9,14 +10,19 @@ function humanize(path) {
             .join("");
 }
 function stringify(issue) {
-    // For root (scalar) errors, keep just the message;
+    // for root (scalar) errors, keep just the message;
     // otherwise prefix with humanized path
     return issue.path === ""
         ? issue.message
         : `${humanize(issue.path)}: ${issue.message}`;
 }
+const brand = Symbol.for("pema/error/parse/v0");
 export default class ParseError extends Error {
-    #issues;
+    [brand] = true;
+    #issues = [];
+    static is(error) {
+        return typeof error === "object" && error !== null && brand in error;
+    }
     constructor(issues) {
         super(stringify(issues[0]));
         this.name = "ParseError";
@@ -26,24 +32,28 @@ export default class ParseError extends Error {
         return this.#issues;
     }
     toJSON() {
-        const issues = this.#issues ?? [];
-        if (issues.length === 0) {
-            return { message: "Parsing failed", messages: ["Parsing failed"] };
-        }
+        const issues = this.#issues;
+        assert.uint(issues.length);
         const is_form = issues.some(i => i.path !== "");
         if (!is_form) {
             const messages = issues.map(i => i.message);
-            return { message: messages[0], messages };
+            return {
+                type: issues[0].type,
+                message: messages[0],
+                messages,
+            };
         }
         const dict = {};
         for (const i of issues) {
             const key = i.path;
-            if (!dict[key])
-                dict[key] = { message: i.message, messages: [] };
-            dict[key].messages.push(i.message);
-            // Keep the first as the short message
-            if (dict[key].messages.length === 1)
-                dict[key].message = i.message;
+            if (!(key in dict))
+                dict[key] = {
+                    type: i.type,
+                    message: i.message,
+                    messages: [],
+                };
+            const entry = dict[key];
+            entry.messages.push(i.message);
         }
         return dict;
     }

package/lib/private/Parsed.d.ts

@@ -19,6 +19,7 @@ export default abstract class Parsed<StaticType> implements Serializable {
     * @returns The parsed value, if successfully parsed.
     */
     abstract parse(x: unknown, options?: ParseOptions): StaticType;
+    coerce(x: unknown, options?: ParseOptions): StaticType;
     abstract toJSON(): Serialized;
 }
 //# sourceMappingURL=Parsed.d.ts.map

package/lib/private/Parsed.js

@@ -13,5 +13,8 @@ export default class Parsed {
     [CoerceKey](x) {
         return x;
     }
+    coerce(x, options = {}) {
+        return this.parse(x, { ...options, coerce: true });
+    }
 }
 //# sourceMappingURL=Parsed.js.map

package/lib/private/PartialType.js

@@ -1,5 +1,5 @@
 import DefaultType from "#DefaultType";
-import fail from "#fail";
+import E from "#errors";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import join from "#path/join";
@@ -23,7 +23,7 @@ export default class PartialType extends VirtualType {
     }
     parse(x, options = {}) {
         if (!is.dict(x))
-            throw fail("object", x, options);
+            throw E.invalid_type(x, "object", options);
         const input = x;
         const out = {};
         const issues = [];
@@ -37,9 +37,9 @@ export default class PartialType extends VirtualType {
                     out[key] = parsed;
             }
             catch (e) {
-                if (e instanceof ParseError) {
+                if (ParseError.is(e)) {
                     // child already rebased to /<key> via nextOptions -> just collect
-                    if (e.issues && e.issues.length)
+                    if (e.issues.length > 0)
                         issues.push(...e.issues);
                 }
                 else {
@@ -49,6 +49,7 @@ export default class PartialType extends VirtualType {
                         : String(e);
                     issues.push({
                         input: input[key],
+                        type: "invalid_type",
                         message: message,
                         path: join(options[ParsedKey] ?? "", key),
                     });

package/lib/private/PrimitiveType.d.ts

@@ -12,7 +12,6 @@ export default abstract class PrimitiveType<StaticType, Name extends string> ext
     get options(): ParseOptions<unknown>;
     get validators(): Validator<StaticType>[];
     derive(next: Next<StaticType>): this;
-    get coerce(): this;
     parse(x: unknown, options?: ParseOptions<StaticType>): Infer<this>;
 }
 export {};

package/lib/private/PrimitiveType.js

@@ -1,5 +1,5 @@
 import CoerceKey from "#CoerceKey";
-import error from "#error";
+import E from "#errors";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import Type from "#Type";
@@ -21,9 +21,6 @@ export default class PrimitiveType extends Type {
         const Constructor = this.constructor;
         return new Constructor([...this.#validators, ...next.validators ?? []], { ...this.#options, ...next.options ?? {} });
     }
-    get coerce() {
-        return this.derive({ options: { coerce: true } });
-    }
     parse(x, options = {}) {
         // hotpath: avoid object spread when possible
         const has_instance_options = this.#options.coerce !== undefined
@@ -37,18 +34,17 @@ export default class PrimitiveType extends Type {
             ? option_validators.concat(this.#validators)
             : this.#validators;
         const $x = $options.coerce === true ? this[CoerceKey](x) : x;
-        if (typeof $x !== this.name) {
-            throw new ParseError(error(this.name, $x, $options));
-        }
+        if (typeof $x !== this.name)
+            throw E.invalid_type($x, this.name, $options);
         const base = $options[ParsedKey] ?? "";
         for (let i = 0; i < validators.length; i++) {
             try {
                 validators[i]($x);
             }
             catch (e) {
-                if (e instanceof ParseError) {
+                if (ParseError.is(e)) {
                     // rebase each issue path under `base`
-                    const rebased = (e.issues ?? []).map(issue => ({
+                    const rebased = e.issues.map(issue => ({
                         ...issue,
                         path: issue.path === ""
                             ? base
@@ -60,11 +56,7 @@ export default class PrimitiveType extends Type {
                 const message = e && typeof e.message === "string"
                     ? e.message
                     : String(e);
-                throw new ParseError([{
-                        input: x,
-                        message,
-                        path: base,
-                    }]);
+                throw E.invalid_type(x, message, base);
             }
         }
         return $x;

package/lib/private/RecordType.js

@@ -1,9 +1,7 @@
-import expected from "#expected";
-import fail from "#fail";
+import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
-import ParseError from "#ParseError";
 import join from "#path/join";
 import next from "#path/next";
 import is from "@rcompat/is";
@@ -22,35 +20,22 @@ export default class RecordType extends GenericType {
         return "record";
     }
     parse(x, options = {}) {
+        const path = options[ParsedKey] ?? "";
         if (!is.dict(x))
-            throw fail("object", x, options);
+            throw E.invalid_type(x, "object", path);
         const key_name = this.#key.name;
         const keys = Object.keys(x);
         const symbols = Object.getOwnPropertySymbols(x);
-        const base = options[ParsedKey] ?? "";
         if (key_name === "string" || key_name === "number") {
             // no key may be a symbol
-            if (symbols.length > 0) {
-                throw new ParseError([{
-                        input: x,
-                        message: expected(`${key_name} key`, symbols[0]),
-                        path: base,
-                    }]);
-            }
+            if (symbols.length > 0)
+                throw E.invalid_type(x, `${key_name} key`, path);
             keys.forEach(k => {
                 if (key_name === "string" && is.numeric(k)) {
-                    throw new ParseError([{
-                            input: x,
-                            message: expected("string key", +k),
-                            path: join(base, k),
-                        }]);
+                    throw E.invalid_type(x, "string key", join(path, k));
                 }
                 if (key_name === "number" && !is.numeric(k)) {
-                    throw new ParseError([{
-                            input: x,
-                            message: expected("number key", k),
-                            path: join(base, k),
-                        }]);
+                    throw E.invalid_type(x, "number key", join(path, k));
                 }
                 this.#value.parse(x[k], next(k, options));
             });
@@ -58,11 +43,7 @@ export default class RecordType extends GenericType {
         if (key_name === "symbol") {
             // disallow any non-symbol keys
             if (keys.length > 0) {
-                throw new ParseError([{
-                        input: x,
-                        message: expected("symbol key", keys[0]),
-                        path: join(base, keys[0]),
-                    }]);
+                throw E.invalid_type(keys[0], "symbol key", join(path, keys[0]));
             }
             symbols.forEach(k => {
                 this.#value.parse(x[k], options);

package/lib/private/Serialized.d.ts

@@ -20,7 +20,15 @@ type PrimitiveSerialized = {
     type: "file";
 } & DT | {
     type: "url";
-} & DT;
+} & DT | {
+    type: "uuid";
+} & DT | {
+    type: "uuid_v4";
+} & DT | {
+    type: "uuid_v7";
+} & DT | {
+    type: "function";
+};
 type NumberSerialized = {
     type: "number";
 } & DT;
@@ -61,11 +69,20 @@ type StructuralSerialized = {
 } | {
     type: "schema";
     of: Serialized;
+} | {
+    type: "json";
+    datatype: "json";
+    of?: Serialized;
 } | {
     type: "omit";
     properties: Dict<Serialized>;
+} | {
+    type: "enum";
+    values: string[];
 } | {
     type: "pure";
+} | {
+    type: "is";
 };
 type Serialized = PrimitiveSerialized | NumberSerialized | BigIntSerialized | StructuralSerialized;
 export type { Serialized as default };

package/lib/private/Storable.d.ts

@@ -1,8 +1,8 @@
 import type K from "#DataKey";
 import Parsed from "#Parsed";
 import type Serialized from "#Serialized";
-export default abstract class Storable<T extends K = K> extends Parsed<unknown> {
-    abstract get datatype(): T;
+export default abstract class Storable<TKey extends K = K, TValue = unknown> extends Parsed<TValue> {
+    abstract get datatype(): TKey;
     abstract toJSON(): Serialized;
     static serialize<N extends string, T extends K>(s: {
         name: N;

package/lib/private/StoreType.js

@@ -1,6 +1,6 @@
 import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
-import fail from "#fail";
+import E from "#errors";
 import next from "#path/next";
 import is from "@rcompat/is";
 export default class StoreType extends ObjectType {
@@ -15,7 +15,7 @@ export default class StoreType extends ObjectType {
     parse(x, options = {}) {
         const $options = { ...options };
         if (x !== undefined && !is.dict(x))
-            throw fail("object", x, $options);
+            throw E.invalid_type(x, "object", $options);
         const input = x ?? {};
         const out = {};
         for (const k in this.properties) {

package/lib/private/StringType.d.ts

@@ -6,7 +6,6 @@ export default class StringType extends PrimitiveType<string, "StringType"> impl
     isotime(): this;
     regex(pattern: RegExp): this;
     email(): this;
-    uuid(): this;
     startsWith(prefix: string): this;
     endsWith(suffix: string): this;
     min(limit: number): this;

package/lib/private/StringType.js

@@ -1,5 +1,5 @@
-import schemafail from "#error/schemafail";
 import PrimitiveType from "#PrimitiveType";
+import E from "#schema-errors";
 import Storable from "#Storable";
 import email from "#validator/email";
 import ends_with from "#validator/ends-with";
@@ -9,7 +9,6 @@ import max from "#validator/max";
 import min from "#validator/min";
 import regex from "#validator/regex";
 import starts_with from "#validator/starts-with";
-import uuid from "#validator/uuid";
 export default class StringType extends PrimitiveType {
     get name() {
         return "string";
@@ -26,9 +25,6 @@ export default class StringType extends PrimitiveType {
     email() {
         return this.derive({ validators: [email] });
     }
-    uuid() {
-        return this.derive({ validators: [uuid] });
-    }
     startsWith(prefix) {
         return this.derive({ validators: [starts_with(prefix)] });
     }
@@ -36,15 +32,13 @@ export default class StringType extends PrimitiveType {
         return this.derive({ validators: [ends_with(suffix)] });
     }
     min(limit) {
-        if (limit < 0) {
-            throw schemafail("min: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw E.min_negative(limit);
         return this.derive({ validators: [min(limit)] });
     }
     max(limit) {
-        if (limit < 0) {
-            throw schemafail("max: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw E.max_negative(limit);
         return this.derive({ validators: [max(limit)] });
     }
     length(from, to) {

package/lib/private/TupleType.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import next from "#path/next";
@@ -16,16 +16,18 @@ export default class TupleType extends GenericType {
     }
     parse(x, options = {}) {
         if (!Array.isArray(x))
-            throw fail("array", x, options);
+            throw E.invalid_type(x, "array", options);
         const items = this.#items;
-        const len = items.length;
+        const n = items.length;
+        const out = new Array(n);
         // validate each expected item
-        for (let i = 0; i < len; i++)
-            items[i].parse(x[i], next(i, options));
+        for (let i = 0; i < n; i++) {
+            out[i] = items[i].parse(x[i], next(i, options));
+        }
         // reject extra items
-        if (x.length > len)
-            throw fail("undefined", x[len], next(len, options));
-        return x;
+        if (x.length > n)
+            throw E.invalid_type(x[n], "undefined", next(n, options));
+        return out;
     }
     toJSON() {
         return {

package/lib/private/UUIDType.d.ts

@@ -0,0 +1,17 @@
+import type Infer from "#Infer";
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import UUIDV4Type from "#UUIDV4Type";
+import UUIDV7Type from "#UUIDV7Type";
+export default class UUIDType extends PrimitiveType<string, "UUIDType"> implements Storable<"uuid"> {
+    get name(): "string";
+    get datatype(): "uuid";
+    parse(x: unknown): Infer<this>;
+    toJSON(): {
+        type: "string";
+        datatype: "uuid";
+    };
+    v4(): UUIDV4Type;
+    v7(): UUIDV7Type;
+}
+//# sourceMappingURL=UUIDType.d.ts.map

package/lib/private/UUIDType.js

@@ -0,0 +1,33 @@
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import UUIDV4Type from "#UUIDV4Type";
+import UUIDV7Type from "#UUIDV7Type";
+import E from "#errors";
+import is from "@rcompat/is";
+const re = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i;
+const v4 = new UUIDV4Type();
+const v7 = new UUIDV7Type();
+export default class UUIDType extends PrimitiveType {
+    get name() {
+        return "string";
+    }
+    get datatype() {
+        return "uuid";
+    }
+    parse(x) {
+        if (!is.string(x) || !re.test(x)) {
+            throw E.invalid_format(x, `"${x}" is not a valid UUID`);
+        }
+        return x;
+    }
+    toJSON() {
+        return Storable.serialize(this);
+    }
+    v4() {
+        return v4;
+    }
+    v7() {
+        return v7;
+    }
+}
+//# sourceMappingURL=UUIDType.js.map

package/lib/private/UUIDV4Type.d.ts

@@ -0,0 +1,13 @@
+import type Infer from "#Infer";
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+export default class UUIDV4Type extends PrimitiveType<string, "UUIDV4Type"> implements Storable<"uuid_v4"> {
+    get name(): "string";
+    get datatype(): "uuid_v4";
+    parse(x: unknown): Infer<this>;
+    toJSON(): {
+        type: "string";
+        datatype: "uuid_v4";
+    };
+}
+//# sourceMappingURL=UUIDV4Type.d.ts.map

package/lib/private/UUIDV4Type.js

@@ -0,0 +1,23 @@
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import E from "#errors";
+import is from "@rcompat/is";
+const re = /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
+export default class UUIDV4Type extends PrimitiveType {
+    get name() {
+        return "string";
+    }
+    get datatype() {
+        return "uuid_v4";
+    }
+    parse(x) {
+        if (!is.string(x) || !re.test(x)) {
+            throw E.invalid_format(x, `"${x}" is not a valid UUID v4`);
+        }
+        return x;
+    }
+    toJSON() {
+        return Storable.serialize(this);
+    }
+}
+//# sourceMappingURL=UUIDV4Type.js.map

package/lib/private/UUIDV7Type.d.ts

@@ -0,0 +1,13 @@
+import type Infer from "#Infer";
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+export default class UUIDV7Type extends PrimitiveType<string, "UUIDV7Type"> implements Storable<"uuid_v7"> {
+    get name(): "string";
+    get datatype(): "uuid_v7";
+    parse(x: unknown): Infer<this>;
+    toJSON(): {
+        type: "string";
+        datatype: "uuid_v7";
+    };
+}
+//# sourceMappingURL=UUIDV7Type.d.ts.map

package/lib/private/UUIDV7Type.js

@@ -0,0 +1,23 @@
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import E from "#errors";
+import is from "@rcompat/is";
+const re = /^[\da-f]{8}-[\da-f]{4}-7[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
+export default class UUIDV7Type extends PrimitiveType {
+    get name() {
+        return "string";
+    }
+    get datatype() {
+        return "uuid_v7";
+    }
+    parse(x) {
+        if (!is.string(x) || !re.test(x)) {
+            throw E.invalid_format(x, `"${x}" is not a valid UUID v7`);
+        }
+        return x;
+    }
+    toJSON() {
+        return Storable.serialize(this);
+    }
+}
+//# sourceMappingURL=UUIDV7Type.js.map

package/lib/private/UnionType.js

@@ -1,9 +1,10 @@
 import DefaultType from "#DefaultType";
-import fail from "#fail";
+import E from "#errors";
 import GenericType from "#GenericType";
 import isParsedType from "#is-parsed-type";
 import OptionalType from "#OptionalType";
 import ParseError from "#ParseError";
+import S from "#schema-errors";
 import assert from "@rcompat/assert";
 const print = (type) => {
     const parsed = isParsedType(type);
@@ -28,7 +29,7 @@ const union_error = (types) => `\`${types.map(t => isParsedType(t) ? t.name : pr
 export default class UnionType extends GenericType {
     #of;
     constructor(of) {
-        assert.true(of.length > 1, "union type must have at least two members");
+        assert.true(of.length > 1, S.union_at_least_two_members());
         super();
         this.#of = of;
     }
@@ -51,14 +52,13 @@ export default class UnionType extends GenericType {
                 return x;
             }
             catch (e) {
-                if (!(e instanceof ParseError)) {
+                if (!ParseError.is(e))
                     throw e;
-                }
                 // continue to next
             }
         }
         // all types failed
-        throw fail(union_error(this.#of), x, options);
+        throw E.invalid_type(x, union_error(this.#of), options);
     }
     toJSON() {
         return { type: this.name, of: this.#of.map(t => t.toJSON()) };

package/lib/private/coerce/bigint.d.ts

@@ -1,2 +1,2 @@
-export default function coerceBigInt(x: unknown): unknown;
+export default function coerce_bigint(x: unknown): unknown;
 //# sourceMappingURL=bigint.d.ts.map

package/lib/private/coerce/bigint.js

@@ -1,5 +1,5 @@
 import is from "@rcompat/is";
-export default function coerceBigInt(x) {
+export default function coerce_bigint(x) {
     // normalize from string to number; other types unaffected
     const n = is.numeric(x) ? Number(x) : x;
     // normalize from number to bigint; other types unaffected

package/lib/private/coerce/float.d.ts

@@ -0,0 +1,2 @@
+export default function coerceFloat(x: unknown): unknown;
+//# sourceMappingURL=float.d.ts.map

package/lib/private/coerce/float.js

@@ -0,0 +1,8 @@
+import is from "@rcompat/is";
+export default function coerceFloat(x) {
+    const n = is.numeric(x) ? Number(x) : x;
+    if (is.number(n))
+        return n;
+    return x;
+}
+//# sourceMappingURL=float.js.map

package/lib/private/coerce/int.d.ts

@@ -1,2 +1,2 @@
-export default function coerceInt(x: unknown): unknown;
+export default function coerce_int(x: unknown): unknown;
 //# sourceMappingURL=int.d.ts.map

package/lib/private/coerce/int.js

@@ -1,7 +1,10 @@
 import is from "@rcompat/is";
-export default function coerceInt(x) {
-    if (is.numeric(x))
-        return Number(x);
+export default function coerce_int(x) {
+    // normalize from string to number; other types unaffected
+    const n = is.numeric(x) ? Number(x) : x;
+    // if is integer, return it
+    if (typeof n === "number" && is.int(n))
+        return n;
     return x;
 }
 //# sourceMappingURL=int.js.map

package/lib/private/enum.d.ts

@@ -0,0 +1,3 @@
+import EnumType from "#EnumType";
+export default function _enum<T extends readonly string[]>(values: T): EnumType<T>;
+//# sourceMappingURL=enum.d.ts.map

package/lib/private/enum.js

@@ -0,0 +1,5 @@
+import EnumType from "#EnumType";
+export default function _enum(values) {
+    return new EnumType(values);
+}
+//# sourceMappingURL=enum.js.map