pema 0.4.0 → 0.6.0

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,14 +1,17 @@
+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;
-type InferLiteral<T extends Literal> = T;
-export default class LiteralType<T extends Literal> extends GenericType<T, InferLiteral<T>, "LiteralType"> {
+export default class LiteralType<T extends Literal> extends GenericType<T, T, "LiteralType"> {
     #private;
     constructor(literal: T);
     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,6 +1,7 @@
-import error from "#error";
+import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
-import ParseError from "#ParseError";
+import OptionalType from "#OptionalType";
+import E from "#errors";
 export default class LiteralType extends GenericType {
     #literal;
     constructor(literal) {
@@ -16,10 +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 new ParseError(error(this.name, x, options));
-        }
+        if (x !== this.#literal)
+            throw E.invalid_type(x, this.name, options);
         return x;
     }
     toJSON() {

package/lib/private/NormalizeSchema.d.ts

@@ -7,15 +7,13 @@ import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type TupleType from "#TupleType";
 import type UndefinedType from "#UndefinedType";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
-import type EO from "@rcompat/type/EO";
-type IsEmptyObject<T> = keyof T extends never ? true : false;
+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>> = IsEmptyObject<T> extends true ? EO : {
-    -readonly [K in keyof T]: T[K] extends Parsed<unknown> ? T[K] : NormalizeSchema<T[K]>;
+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 ? LiteralType<S> : S extends number ? LiteralType<S> : S extends boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [infer O] ? O extends Schema ? ArrayType<NormalizeSchema<O>> : never : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;
+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;
 export type { NormalizeSchema as default };
 //# sourceMappingURL=NormalizeSchema.d.ts.map

package/lib/private/NullType.js

@@ -1,14 +1,12 @@
-import error from "#error";
-import ParseError from "#ParseError";
 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 new ParseError(error(this.name, x, options));
-        }
+        if (x !== null)
+            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/NumericType.d.ts

@@ -1,13 +1,13 @@
 import type DataKey from "#DataKey";
 import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
-import type Storeable from "#Storeable";
+import type Storable from "#Storable";
 import type Validator from "#Validator";
 type Next<T> = {
     options?: ParseOptions;
     validators?: Validator<T>[];
 };
-export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storeable<Key> {
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storable<Key> {
     #private;
     constructor(datatype: Key, validators?: Validator<T>[], options?: ParseOptions);
     derive(next: Next<T>): this;

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/Dict";
-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,5 +1,9 @@
+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;
     #options;
@@ -20,25 +24,34 @@ export default class ObjectType extends GenericType {
     get input() {
         return undefined;
     }
-    #derive(next) {
+    #derive(options) {
         const Constructor = this.constructor;
-        return new Constructor(this.#properties, { ...this.#options, ...next });
+        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 };
-        let _x = x;
-        if (typeof x !== "object" || x === null) {
-            _x = {};
-        }
+        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) {
-            const parsed = this.#properties[k].parse(_x[k], next(k, $options));
-            if (parsed !== undefined) {
+            const parsed = this.#properties[k].parse(input[k], next(k, $options));
+            if (parsed !== undefined)
                 out[k] = parsed;
-            }
         }
         return out;
     }

package/lib/private/OmitType.d.ts

@@ -4,7 +4,7 @@ import type ObjectType from "#ObjectType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P> extends GenericType<Omit<P, K>, Omit<{
     [Key in keyof P]: Infer<P[Key]>;
 }, K>, "OmitType"> {

package/lib/private/OmitType.js

@@ -1,6 +1,8 @@
+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) {
@@ -15,10 +17,9 @@ export default class OmitType extends GenericType {
         return "omit";
     }
     parse(x, options = {}) {
-        if (typeof x !== "object" || x === null) {
-            throw new Error("Expected object");
-        }
-        const result = {};
+        if (!is.dict(x))
+            throw E.invalid_type(x, "object", options);
+        const out = {};
         const props = this.#properties;
         for (const k in props) {
             const field = props[k];
@@ -26,10 +27,10 @@ export default class OmitType extends GenericType {
                 ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
             });
             if (r !== undefined) {
-                result[k] = r;
+                out[k] = r;
             }
         }
-        return result;
+        return out;
     }
     toJSON() {
         const properties = {};

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/Serializable";
+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 isForm = issues.some(i => i.path !== "");
-        if (!isForm) {
+        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/ParseOptions.d.ts

@@ -1,6 +1,6 @@
 import type ParsedKey from "#ParsedKey";
 import type Validator from "#Validator";
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type { JSONPointer } from "@rcompat/type";
 export default interface ParseOptions<T = unknown> {
     coerce?: boolean;
     [ParsedKey]?: JSONPointer;

package/lib/private/Parsed.d.ts

@@ -2,7 +2,7 @@ import CoerceKey from "#CoerceKey";
 import ParsedKey from "#ParsedKey";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
-import type Serializable from "@rcompat/type/Serializable";
+import type { Serializable } from "@rcompat/type";
 export default abstract class Parsed<StaticType> implements Serializable {
     get [ParsedKey](): "ParsedKey";
     get infer(): StaticType;
@@ -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,11 +1,11 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
+import E from "#errors";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import join from "#path/join";
 import next from "#path/next";
 import VirtualType from "#VirtualType";
-import isDict from "@rcompat/is/dict";
+import is from "@rcompat/is";
 export default class PartialType extends VirtualType {
     #spec;
     constructor(spec) {
@@ -22,9 +22,8 @@ export default class PartialType extends VirtualType {
         return new DefaultType(this, value);
     }
     parse(x, options = {}) {
-        if (!isDict(x)) {
-            throw new ParseError(error("object", x, options));
-        }
+        if (!is.dict(x))
+            throw E.invalid_type(x, "object", options);
         const input = x;
         const out = {};
         const issues = [];
@@ -38,11 +37,10 @@ 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 {
                     // wrap non-ParseError into a properly-pathed issue at /<key>
@@ -51,15 +49,15 @@ export default class PartialType extends VirtualType {
                         : String(e);
                     issues.push({
                         input: input[key],
+                        type: "invalid_type",
                         message: message,
                         path: join(options[ParsedKey] ?? "", key),
                     });
                 }
             }
         }
-        if (issues.length > 0) {
+        if (issues.length > 0)
             throw new ParseError(issues);
-        }
         return out;
     }
     toJSON() {

package/lib/private/Partialable.d.ts

@@ -1,5 +1,5 @@
 import type Parsed from "#Parsed";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type Partialable = Dict<Parsed<unknown>>;
 export type { Partialable as default };
 //# sourceMappingURL=Partialable.d.ts.map

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,41 +21,42 @@ 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 = {}) {
-        const $options = { ...this.#options, ...options };
-        const validators = [...$options.validators ?? [], ...this.#validators];
+        // hotpath: avoid object spread when possible
+        const has_instance_options = this.#options.coerce !== undefined
+            || this.#options[ParsedKey] !== undefined;
+        const $options = has_instance_options
+            ? { ...this.#options, ...options }
+            : options;
+        // hotpath: avoid array spread when no option validators
+        const option_validators = $options.validators;
+        const validators = option_validators && option_validators.length > 0
+            ? 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 (const v of validators) {
+        for (let i = 0; i < validators.length; i++) {
             try {
-                v($x);
+                validators[i]($x);
             }
             catch (e) {
-                if (e instanceof ParseError) {
+                if (ParseError.is(e)) {
                     // rebase each issue path under `base`
-                    const rebased = (e.issues ?? []).map(i => ({
-                        ...i,
-                        path: i.path === ""
+                    const rebased = e.issues.map(issue => ({
+                        ...issue,
+                        path: issue.path === ""
                             ? base
-                            : (base === "" ? i.path : (base + i.path)),
+                            : (base === "" ? issue.path : (base + issue.path)),
                     }));
                     throw new ParseError(rebased);
                 }
-                // non a ParseError - wrap with proper path
+                // not a ParseError - wrap with proper path
                 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/PureType.d.ts

@@ -2,7 +2,7 @@ import type Infer from "#Infer";
 import OptionalType from "#OptionalType";
 import Parsed from "#Parsed";
 import type OptionalTrait from "#trait/Optional";
-import type Printable from "@rcompat/type/Printable";
+import type { Printable } from "@rcompat/type";
 export default class PureType<Type, Name extends string = "PureType"> extends Parsed<Type> implements Printable, OptionalTrait {
     get name(): string;
     get Name(): Name;