pema 0.5.0 → 0.6.0

package/lib/private/ArrayType.d.ts

@@ -25,6 +25,7 @@ export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T,
      * @returns ArrayType<T>
      */
     unique(this: Infer<T> extends Primitive ? ArrayType<T> : never): ArrayType<T>;
+    uniqueBy<K>(select: (value: Infer<T>) => K): this;
     min(limit: number): this;
     max(limit: number): this;
     length(from: number, to: number): this;

package/lib/private/ArrayType.js

@@ -1,7 +1,6 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
-import schemafail from "#error/schemafail";
-import fail from "#fail";
+import EnumType from "#EnumType";
+import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
@@ -10,12 +9,14 @@ import join from "#path/join";
 import next from "#path/next";
 import rebase from "#path/rebase";
 import PrimitiveType from "#PrimitiveType";
+import S from "#schema-errors";
 import length from "#validator/length";
 import max from "#validator/max";
 import min from "#validator/min";
 import unique from "#validator/unique";
+import uniqueBy from "#validator/unique-by";
 function isPrimitive(x) {
-    return x instanceof PrimitiveType;
+    return x instanceof PrimitiveType || x instanceof EnumType;
 }
 export default class ArrayType extends GenericType {
     #item;
@@ -46,56 +47,51 @@ export default class ArrayType extends GenericType {
      */
     unique() {
         if (!isPrimitive(this.#item)) {
-            throw schemafail("unique: subtype {0} must be primitive", this.#item.name);
+            throw S.unique_subtype_not_primitive(this.#item.name);
         }
         return this.derive({ validators: [unique] });
     }
+    uniqueBy(select) {
+        return this.derive({ validators: [uniqueBy(select)] });
+    }
     min(limit) {
-        if (limit < 0) {
-            throw schemafail("min: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw S.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 S.max_negative(limit);
         return this.derive({ validators: [max(limit)] });
     }
     length(from, to) {
         return this.derive({ validators: [length(from, to)] });
     }
     parse(x, options = {}) {
+        const path = options[ParsedKey] ?? "";
         if (!Array.isArray(x))
-            throw fail("array", x, options);
-        const base = options[ParsedKey] ?? "";
+            throw E.invalid_type(x, "array", path);
         const item = this.#item;
         const len = x.length;
+        const out = new Array(len);
         for (let i = 0; i < len; i++) {
-            // sparse array check
-            if (!(i in x)) {
-                throw new ParseError([{
-                        ...error(item.name, undefined, options)[0],
-                        path: join(base, i),
-                    }]);
-            }
-            item.parse(x[i], next(i, options));
+            if (!(i in x))
+                throw E.invalid_type(undefined, item.name, join(path, i));
+            out[i] = item.parse(x[i], next(i, options));
         }
         const validators = this.#validators;
         for (let i = 0; i < validators.length; i++) {
             try {
-                validators[i](x);
+                validators[i](out);
             }
             catch (e) {
-                if (e instanceof ParseError) {
-                    const rebased = (e.issues ?? [])
-                        .map(issue => ({ ...issue, path: rebase(base, issue.path) }));
-                    throw new ParseError(rebased);
+                if (ParseError.is(e)) {
+                    throw new ParseError(e.issues.map(issue => ({ ...issue, path: rebase(path, issue.path) })));
                 }
                 throw e;
             }
         }
-        return x;
+        return out;
     }
     toJSON() {
         return { type: this.name, of: this.#item.toJSON() };

package/lib/private/BuiltinType.d.ts

@@ -6,7 +6,6 @@ export default abstract class BuiltinType<StaticType, Name extends string> exten
     #private;
     abstract get Type(): AbstractNewable;
     constructor(options?: ParseOptions);
-    get coerce(): this;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
 }
 //# sourceMappingURL=BuiltinType.d.ts.map

package/lib/private/BuiltinType.js

@@ -1,5 +1,5 @@
 import CoerceKey from "#CoerceKey";
-import fail from "#fail";
+import E from "#errors";
 import Type from "#Type";
 export default class BuiltinType extends Type {
     #options;
@@ -11,14 +11,11 @@ export default class BuiltinType extends Type {
         const Constructor = this.constructor;
         return new Constructor({ ...this.#options, ...next });
     }
-    get coerce() {
-        return this.#derive({ coerce: true });
-    }
     parse(x, options = {}) {
         const $options = { ...this.#options, ...options };
         const $x = $options.coerce === true ? this[CoerceKey](x) : x;
         if (!($x instanceof this.Type))
-            throw fail(this.name, $x, $options);
+            throw E.invalid_type($x, this.name, $options);
         return $x;
     }
 }

package/lib/private/ConstructorType.d.ts

@@ -1,13 +1,16 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
 import type DefaultTrait from "#trait/Default";
+import type OptionalTrait from "#trait/Optional";
 import type { AbstractNewable } from "@rcompat/type";
-export default class ConstructorType<C extends AbstractNewable> extends GenericType<C, InstanceType<C>, "InstanceType"> implements DefaultTrait<InstanceType<C>> {
+export default class ConstructorType<C extends AbstractNewable> extends GenericType<C, InstanceType<C>, "InstanceType"> implements OptionalTrait, DefaultTrait<InstanceType<C>> {
     #private;
     constructor(t: C);
     get name(): string;
+    optional(): OptionalType<this>;
     default(value: (() => InstanceType<C>) | InstanceType<C>): DefaultType<this, InstanceType<C>>;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {

package/lib/private/ConstructorType.js

@@ -1,6 +1,7 @@
 import DefaultType from "#DefaultType";
-import fail from "#fail";
+import E from "#errors";
 import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
 export default class ConstructorType extends GenericType {
     #type;
     constructor(t) {
@@ -10,12 +11,15 @@ export default class ConstructorType extends GenericType {
     get name() {
         return "constructor";
     }
+    optional() {
+        return new OptionalType(this);
+    }
     default(value) {
         return new DefaultType(this, value);
     }
     parse(x, options = {}) {
         if (!(x instanceof this.#type))
-            throw fail(this.name, x, options);
+            throw E.invalid_type(x, this.name, options);
         return x;
     }
     toJSON() {

package/lib/private/DataType.d.ts

@@ -1,3 +1,4 @@
+import type { JSONValue } from "@rcompat/type";
 type DataType = {
     blob: Blob;
     boolean: boolean;
@@ -9,6 +10,7 @@ type DataType = {
     i32: number;
     i64: bigint;
     i8: number;
+    json: JSONValue;
     string: string;
     time: string;
     u128: bigint;
@@ -17,6 +19,9 @@ type DataType = {
     u64: bigint;
     u8: number;
     url: URL;
+    uuid: string;
+    uuid_v4: string;
+    uuid_v7: string;
 };
 export type { DataType as default };
 //# sourceMappingURL=DataType.d.ts.map

package/lib/private/DefaultType.js

@@ -1,8 +1,5 @@
 import VirtualType from "#VirtualType";
-function isDefaultFunction(x) {
-    return typeof x === "function";
-}
-;
+import is from "@rcompat/is";
 export default class DefaultType extends VirtualType {
     #schema;
     #default;
@@ -23,8 +20,8 @@ export default class DefaultType extends VirtualType {
     parse(x, options = {}) {
         let $x = x;
         // default fallback
-        if ($x === undefined) {
-            $x = isDefaultFunction(this.#default) ? this.#default() : this.#default;
+        if (is.undefined($x)) {
+            $x = is.function(this.#default) ? this.#default() : this.#default;
         }
         return this.#schema.parse($x, options);
     }

package/lib/private/EnumType.d.ts

@@ -0,0 +1,21 @@
+import DefaultType from "#DefaultType";
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import type ParseOptions from "#ParseOptions";
+import type OptionalTrait from "#trait/Optional";
+type Literal = string;
+export default class EnumType<T extends readonly Literal[]> extends GenericType<T, T[number], "EnumType"> implements OptionalTrait {
+    #private;
+    constructor(values: T);
+    get name(): string;
+    optional(): OptionalType<this>;
+    default<D extends T[number]>(value: (() => D) | D): DefaultType<EnumType<T>, D>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "enum";
+        values: T[number][];
+    };
+}
+export {};
+//# sourceMappingURL=EnumType.d.ts.map

package/lib/private/EnumType.js

@@ -0,0 +1,30 @@
+import DefaultType from "#DefaultType";
+import E from "#errors";
+import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+export default class EnumType extends GenericType {
+    #values;
+    constructor(values) {
+        super();
+        this.#values = values;
+    }
+    get name() {
+        return this.#values.map(v => `"${v}"`).join(" | ");
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
+        if (typeof x !== "string" || !this.#values.includes(x)) {
+            throw E.invalid_type(x, this.name, options);
+        }
+        return x;
+    }
+    toJSON() {
+        return { type: "enum", values: [...this.#values] };
+    }
+}
+//# sourceMappingURL=EnumType.js.map

package/lib/private/FunctionType.d.ts

@@ -0,0 +1,15 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import type ParseOptions from "#ParseOptions";
+import type OptionalTrait from "#trait/Optional";
+import type { UnknownFunction } from "@rcompat/type";
+export default class FunctionType extends GenericType<UnknownFunction, UnknownFunction, "FunctionType"> implements OptionalTrait {
+    get name(): "function";
+    optional(): OptionalType<this>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "function";
+    };
+}
+//# sourceMappingURL=FunctionType.d.ts.map

package/lib/private/FunctionType.js

@@ -0,0 +1,20 @@
+import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+import E from "#errors";
+export default class FunctionType extends GenericType {
+    get name() {
+        return "function";
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    parse(x, options = {}) {
+        if (typeof x !== "function")
+            throw E.invalid_type(x, this.name, options);
+        return x;
+    }
+    toJSON() {
+        return { type: this.name };
+    }
+}
+//# sourceMappingURL=FunctionType.js.map

package/lib/private/IsType.d.ts

@@ -0,0 +1,19 @@
+import DefaultType from "#DefaultType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type DefaultTrait from "#trait/Default";
+import type OptionalTrait from "#trait/Optional";
+export default class IsType<T> extends Parsed<T> implements OptionalTrait, DefaultTrait<T> {
+    #private;
+    constructor(predicate: (x: unknown) => x is T);
+    get name(): "is";
+    optional(): OptionalType<this>;
+    default(value: (() => T) | T): DefaultType<this, T>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "is";
+    };
+}
+//# sourceMappingURL=IsType.d.ts.map

package/lib/private/IsType.js

@@ -0,0 +1,29 @@
+import DefaultType from "#DefaultType";
+import E from "#errors";
+import OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+export default class IsType extends Parsed {
+    #predicate;
+    constructor(predicate) {
+        super();
+        this.#predicate = predicate;
+    }
+    get name() {
+        return "is";
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
+        if (!this.#predicate(x))
+            throw E.invalid_type(x, this.name, options);
+        return x;
+    }
+    toJSON() {
+        return { type: this.name };
+    }
+}
+//# sourceMappingURL=IsType.js.map

package/lib/private/Issue.d.ts

@@ -1,5 +1,7 @@
+import type IssueType from "#IssueType";
 import type { JSONPointer } from "@rcompat/type";
 export default interface Issue {
+    readonly type: IssueType;
     readonly message: string;
     readonly path: JSONPointer;
 }

package/lib/private/IssueType.d.ts

@@ -0,0 +1,3 @@
+type IssueType = "invalid_type" | "invalid_format" | "too_small" | "too_large" | "out_of_range" | "not_in_set" | "duplicate" | "network_error";
+export type { IssueType as default };
+//# sourceMappingURL=IssueType.d.ts.map

package/lib/private/IssueType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IssueType.js.map

package/lib/private/JSONType.d.ts

@@ -0,0 +1,26 @@
+import DefaultType from "#DefaultType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import Storable from "#Storable";
+import type { JSONValue } from "@rcompat/type";
+export type ParsedJSON = Parsed<JSONValue>;
+type JSONInput = ParsedJSON | undefined;
+type JSONInfer<S extends JSONInput> = S extends ParsedJSON ? Infer<S> : JSONValue;
+export default class JSONType<S extends JSONInput = undefined> extends Storable<"json", JSONInfer<S>> {
+    #private;
+    constructor(inner?: S);
+    get name(): "json";
+    get datatype(): "json";
+    optional(): OptionalType<this>;
+    default(value: (() => Infer<this>) | Infer<this>): DefaultType<this, Infer<this>>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        of?: import("./Serialized.js").default | undefined;
+        type: "json";
+        datatype: "json";
+    };
+}
+export {};
+//# sourceMappingURL=JSONType.d.ts.map

package/lib/private/JSONType.js

@@ -0,0 +1,41 @@
+import DefaultType from "#DefaultType";
+import E from "#errors";
+import OptionalType from "#OptionalType";
+import Storable from "#Storable";
+import is from "@rcompat/is";
+export default class JSONType extends Storable {
+    #inner;
+    constructor(inner) {
+        super();
+        this.#inner = inner;
+    }
+    get name() {
+        return "json";
+    }
+    get datatype() {
+        return "json";
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
+        if (this.#inner !== undefined) {
+            // delegate to inner schema for typed validation
+            return this.#inner.parse(x, options);
+        }
+        if (!is.json(x))
+            throw E.invalid_type(x, "json", options);
+        return JSON.parse(JSON.stringify(x));
+    }
+    toJSON() {
+        return {
+            type: "json",
+            datatype: "json",
+            ...(this.#inner !== undefined && { of: this.#inner.toJSON() }),
+        };
+    }
+}
+//# sourceMappingURL=JSONType.js.map

package/lib/private/LiteralType.d.ts

@@ -1,5 +1,7 @@
+import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
 type Literal = string | boolean | number;
 export default class LiteralType<T extends Literal> extends GenericType<T, T, "LiteralType"> {
@@ -8,6 +10,8 @@ export default class LiteralType<T extends Literal> extends GenericType<T, T, "L
     static new<T extends Literal>(literal: T): LiteralType<T>;
     static get Literal(): Literal;
     get name(): string;
+    optional(): OptionalType<this>;
+    default(value: (() => T) | T): DefaultType<this, T>;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "literal";

package/lib/private/LiteralType.js

@@ -1,5 +1,7 @@
-import fail from "#fail";
+import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+import E from "#errors";
 export default class LiteralType extends GenericType {
     #literal;
     constructor(literal) {
@@ -15,9 +17,15 @@ export default class LiteralType extends GenericType {
     get name() {
         return JSON.stringify(this.#literal);
     }
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
     parse(x, options = {}) {
         if (x !== this.#literal)
-            throw fail(this.name, x, options);
+            throw E.invalid_type(x, this.name, options);
         return x;
     }
     toJSON() {

package/lib/private/NormalizeSchema.d.ts

@@ -11,7 +11,7 @@ import type { AbstractNewable } from "@rcompat/type";
 type NormalizeSchemaArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
-type NormalizeSchemaObject<T extends Record<string, unknown>> = {
+export type NormalizeSchemaObject<T extends Record<string, unknown>> = {
     -readonly [K in keyof T]: NormalizeSchema<T[K]>;
 };
 type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string | number | boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [Schema] ? ArrayType<NormalizeSchema<S[0]>> : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;

package/lib/private/NullType.js

@@ -1,12 +1,12 @@
-import fail from "#fail";
 import PrimitiveType from "#PrimitiveType";
+import E from "#errors";
 export default class NullType extends PrimitiveType {
     get name() {
         return "null";
     }
     parse(x, options = {}) {
         if (x !== null)
-            throw fail(this.name, x, options);
+            throw E.invalid_type(x, this.name, options);
         return x;
     }
     toJSON() {

package/lib/private/NumberType.d.ts

@@ -1,7 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import type FloatDataType from "#FloatDataType";
 import NumericType from "#NumericType";
-import coerce from "#coerce/int";
+import coerce from "#coerce/float";
 export default class NumberType<T extends FloatDataType = "f64"> extends NumericType<T, number, "NumberType"> {
     [CoerceKey]: typeof coerce;
     get name(): "number";

package/lib/private/NumberType.js

@@ -1,6 +1,6 @@
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
-import coerce from "#coerce/int";
+import coerce from "#coerce/float";
 export default class NumberType extends NumericType {
     [CoerceKey] = coerce;
     get name() {

package/lib/private/ObjectType.d.ts

@@ -1,23 +1,32 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type InferInputSchema from "#InferInputSchema";
+import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
-import type { Dict } from "@rcompat/type";
-export default class ObjectType<P extends Dict<Parsed<unknown>>> extends GenericType<P, {
+import type OptionalTrait from "#trait/Optional";
+import type { Dict, Unpack } from "@rcompat/type";
+type ObjectInfer<P extends Dict<Parsed<unknown>>> = {
     [K in keyof P]: P[K]["infer"];
-}, "ObjectType"> {
+};
+export default class ObjectType<P extends Dict<Parsed<unknown>>, I = ObjectInfer<P>> extends GenericType<P, I, "ObjectType"> implements OptionalTrait {
     #private;
+    readonly Complement: ObjectType<Record<Exclude<string, keyof P>, Parsed<unknown>>>;
     constructor(properties: P, options?: ParseOptions);
     get name(): string;
     get properties(): P;
     get input(): InferInputSchema<P>;
-    get coerce(): this;
+    optional(): OptionalType<this>;
+    shape<T>(): ObjectType<P, T>;
+    extend<E extends {
+        [K in keyof E]: K extends keyof P ? never : Parsed<unknown>;
+    }>(extra: E | ObjectType<E>): ObjectType<Unpack<P & E>>;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "object";
         properties: Dict<Serialized>;
     };
 }
+export {};
 //# sourceMappingURL=ObjectType.d.ts.map

package/lib/private/ObjectType.js

@@ -1,6 +1,8 @@
-import fail from "#fail";
+import E from "#errors";
 import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
 import next from "#path/next";
+import SE from "#schema-errors";
 import is from "@rcompat/is";
 export default class ObjectType extends GenericType {
     #properties;
@@ -26,13 +28,24 @@ export default class ObjectType extends GenericType {
         const Constructor = this.constructor;
         return new Constructor(this.#properties, { ...this.#options, ...options });
     }
-    get coerce() {
-        return this.#derive({ coerce: true });
+    optional() {
+        return new OptionalType(this);
+    }
+    shape() {
+        return new ObjectType(this.#properties, this.#options);
+    }
+    extend(extra) {
+        const properties = extra instanceof ObjectType ? extra.properties : extra;
+        for (const key of Object.keys(properties)) {
+            if (key in this.#properties)
+                throw SE.extend_key_collision(key);
+        }
+        return new ObjectType({ ...this.#properties, ...properties }, this.#options);
     }
     parse(x, options = {}) {
         const $options = { ...this.#options, ...options };
-        if (x !== undefined && !is.dict(x))
-            throw fail("object", x, $options);
+        if (is.defined(x) && !is.dict(x))
+            throw E.invalid_type(x, "object", $options);
         const input = x ?? {};
         const out = {};
         for (const k in this.#properties) {

package/lib/private/OmitType.js

@@ -1,7 +1,8 @@
-import fail from "#fail";
+import E from "#errors";
 import GenericType from "#GenericType";
 import ParsedKey from "#ParsedKey";
 import join from "#path/join";
+import is from "@rcompat/is";
 export default class OmitType extends GenericType {
     #properties;
     constructor(type, keys) {
@@ -16,8 +17,8 @@ export default class OmitType extends GenericType {
         return "omit";
     }
     parse(x, options = {}) {
-        if (typeof x !== "object" || x === null)
-            throw fail("object", x, options);
+        if (!is.dict(x))
+            throw E.invalid_type(x, "object", options);
         const out = {};
         const props = this.#properties;
         for (const k in props) {