pema 0.6.1 → 0.8.0

package/lib/private/ObjectType.d.ts

@@ -1,6 +1,8 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type InferInputSchema from "#InferInputSchema";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
@@ -10,19 +12,20 @@ import type { Dict, Unpack } from "@rcompat/type";
 type ObjectInfer<P extends Dict<Parsed<unknown>>> = {
     [K in keyof P]: P[K]["infer"];
 };
-export default class ObjectType<P extends Dict<Parsed<unknown>>, I = ObjectInfer<P>> extends GenericType<P, I, "ObjectType"> implements OptionalTrait {
+export default class ObjectType<P extends Dict<Parsed<unknown>> = Dict<Parsed<unknown>>, M extends Mode = undefined, I = ObjectInfer<P>> extends GenericType<P, I, "ObjectType"> implements OptionalTrait {
     #private;
+    [Loose]: M;
     readonly Complement: ObjectType<Record<Exclude<string, keyof P>, Parsed<unknown>>>;
-    constructor(properties: P, options?: ParseOptions);
+    constructor(properties: P, mode?: M, options?: ParseOptions);
     get name(): string;
     get properties(): P;
     get input(): InferInputSchema<P>;
     optional(): OptionalType<this>;
-    shape<T>(): ObjectType<P, T>;
+    shape<T>(): ObjectType<P, M, 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>;
+    }>(extra: E | ObjectType<E, M>): ObjectType<Unpack<P & E>, M>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "object";
         properties: Dict<Serialized>;

package/lib/private/ObjectType.js

@@ -1,15 +1,19 @@
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import next from "#path/next";
+import resolve from "#resolve";
 import SE from "#schema-errors";
 import is from "@rcompat/is";
 export default class ObjectType extends GenericType {
     #properties;
     #options;
-    constructor(properties, options = {}) {
+    [Loose];
+    constructor(properties, mode, options = {}) {
         super();
         this.#properties = properties;
+        this[Loose] = mode;
         this.#options = options;
     }
     get name() {
@@ -26,13 +30,17 @@ export default class ObjectType extends GenericType {
     }
     #derive(options) {
         const Constructor = this.constructor;
-        return new Constructor(this.#properties, { ...this.#options, ...options });
+        const instance = new Constructor(this.#properties, this[Loose], {
+            ...this.#options, ...options,
+        });
+        instance[Loose] = this[Loose];
+        return instance;
     }
     optional() {
         return new OptionalType(this);
     }
     shape() {
-        return new ObjectType(this.#properties, this.#options);
+        return new ObjectType(this.#properties, this[Loose], this.#options);
     }
     extend(extra) {
         const properties = extra instanceof ObjectType ? extra.properties : extra;
@@ -40,10 +48,13 @@ export default class ObjectType extends GenericType {
             if (key in this.#properties)
                 throw SE.extend_key_collision(key);
         }
-        return new ObjectType({ ...this.#properties, ...properties }, this.#options);
+        return new ObjectType({ ...this.#properties, ...properties }, this[Loose], this.#options);
     }
-    parse(x, options = {}) {
-        const $options = { ...this.#options, ...options };
+    parse(u, options = {}) {
+        const x = resolve(u);
+        const $options = this[Loose] !== undefined
+            ? { ...this.#options, ...options, [Loose]: this[Loose] }
+            : { ...this.#options, ...options };
         if (is.defined(x) && !is.dict(x))
             throw E.invalid_type(x, "object", $options);
         const input = x ?? {};

package/lib/private/OmitType.d.ts

@@ -1,17 +1,20 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 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";
-export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P> extends GenericType<Omit<P, K>, Omit<{
+export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P, M extends Mode = undefined> extends GenericType<Omit<P, K>, Omit<{
     [Key in keyof P]: Infer<P[Key]>;
 }, K>, "OmitType"> {
     #private;
-    constructor(type: ObjectType<P>, keys: K[]);
+    [Loose]: M;
+    constructor(type: ObjectType<P>, keys: K[], mode?: M);
     get name(): "omit";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "omit";
         properties: Dict<Serialized>;

package/lib/private/OmitType.js

@@ -1,22 +1,27 @@
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import join from "#path/join";
+import resolve from "#resolve";
 import is from "@rcompat/is";
 export default class OmitType extends GenericType {
     #properties;
-    constructor(type, keys) {
+    [Loose];
+    constructor(type, keys, mode) {
         super();
         const props = { ...type.properties };
         for (const key of keys) {
             delete props[key];
         }
         this.#properties = props;
+        this[Loose] = mode;
     }
     get name() {
         return "omit";
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!is.dict(x))
             throw E.invalid_type(x, "object", options);
         const out = {};

package/lib/private/OptionalType.d.ts

@@ -8,7 +8,7 @@ export default class OptionalType<S extends Parsed<unknown>> extends VirtualType
     get name(): "optional";
     get schema(): S;
     get nullable(): boolean;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "optional";
         of: import("./Serialized.js").default;

package/lib/private/OptionalType.js

@@ -1,4 +1,6 @@
+import resolve from "#resolve";
 import VirtualType from "#VirtualType";
+import is from "@rcompat/is";
 export default class OptionalType extends VirtualType {
     #schema;
     constructor(s) {
@@ -14,13 +16,12 @@ export default class OptionalType extends VirtualType {
     get nullable() {
         return true;
     }
-    parse(x, options = {}) {
-        const s = this.#schema;
+    parse(u, options = {}) {
+        const x = resolve(u);
         // optional
-        if (x === undefined) {
+        if (is.undefined(x))
             return undefined;
-        }
-        return s.parse(x, options);
+        return this.#schema.parse(x, options);
     }
     toJSON() {
         return {

package/lib/private/ParseError.d.ts

@@ -5,7 +5,7 @@ declare const brand: unique symbol;
 export default class ParseError extends Error implements Serializable {
     #private;
     [brand]: boolean;
-    static is(error: unknown): error is ParseError;
+    static is(x: unknown): x is ParseError;
     constructor(issues: ParseIssue[]);
     get issues(): ParseIssue[];
     toJSON(): JSONPayload;

package/lib/private/ParseError.js

@@ -1,4 +1,5 @@
 import assert from "@rcompat/assert";
+import is from "@rcompat/is";
 function humanize(path) {
     return path === ""
         ? ""
@@ -16,12 +17,12 @@ function stringify(issue) {
         ? issue.message
         : `${humanize(issue.path)}: ${issue.message}`;
 }
-const brand = Symbol.for("pema/error/parse/v0");
+const brand = Symbol.for("pema/ParseError/v0");
 export default class ParseError extends Error {
     [brand] = true;
     #issues = [];
-    static is(error) {
-        return typeof error === "object" && error !== null && brand in error;
+    static is(x) {
+        return is.branded(x, brand);
     }
     constructor(issues) {
         super(stringify(issues[0]));
@@ -43,19 +44,19 @@ export default class ParseError extends Error {
                 messages,
             };
         }
-        const dict = {};
+        const payload = {};
         for (const i of issues) {
             const key = i.path;
-            if (!(key in dict))
-                dict[key] = {
+            if (!(key in payload))
+                payload[key] = {
                     type: i.type,
                     message: i.message,
                     messages: [],
                 };
-            const entry = dict[key];
+            const entry = payload[key];
             entry.messages.push(i.message);
         }
-        return dict;
+        return payload;
     }
 }
 //# sourceMappingURL=ParseError.js.map

package/lib/private/ParseOptions.d.ts

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

package/lib/private/Parsed.d.ts

@@ -1,4 +1,5 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
@@ -7,19 +8,19 @@ export default abstract class Parsed<StaticType> implements Serializable {
     get [ParsedKey](): "ParsedKey";
     get infer(): StaticType;
     get nullable(): boolean;
+    [Loose]: boolean | undefined;
     [CoerceKey](x: unknown): unknown;
     abstract get name(): string;
     /**
     * Parse the given value.
     *
-    * @param x Value to parse.
+    * @param u Value to parse.
     *
     * @throws `ParseError` if the value could not be parsed.
     *
     * @returns The parsed value, if successfully parsed.
     */
-    abstract parse(x: unknown, options?: ParseOptions): StaticType;
-    coerce(x: unknown, options?: ParseOptions): StaticType;
+    abstract parse(u: unknown, options?: ParseOptions): StaticType;
     abstract toJSON(): Serialized;
 }
 //# sourceMappingURL=Parsed.d.ts.map

package/lib/private/Parsed.js

@@ -1,4 +1,5 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 export default class Parsed {
     get [ParsedKey]() {
@@ -10,11 +11,9 @@ export default class Parsed {
     get nullable() {
         return false;
     }
+    [Loose] = undefined;
     [CoerceKey](x) {
         return x;
     }
-    coerce(x, options = {}) {
-        return this.parse(x, { ...options, coerce: true });
-    }
 }
 //# sourceMappingURL=Parsed.js.map

package/lib/private/PartialType.d.ts

@@ -1,5 +1,7 @@
 import DefaultType from "#DefaultType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type ParseOptions from "#ParseOptions";
 import type Partialable from "#Partialable";
 import type DefaultTrait from "#trait/Default";
@@ -7,13 +9,14 @@ import VirtualType from "#VirtualType";
 type InferPartial<D extends Partialable> = {
     -readonly [K in keyof D]?: NonNullable<Infer<D[K]>>;
 };
-export default class PartialType<D extends Partialable> extends VirtualType<D, InferPartial<D>, "PartialType"> implements DefaultTrait<InferPartial<D>> {
+export default class PartialType<D extends Partialable, M extends Mode = undefined> extends VirtualType<D, InferPartial<D>, "PartialType"> implements DefaultTrait<InferPartial<D>> {
     #private;
-    constructor(spec: D);
+    [Loose]: M;
+    constructor(spec: D, mode?: M);
     get name(): "partial";
     get schema(): D;
     default(value: (() => InferPartial<D>) | InferPartial<D>): DefaultType<this, InferPartial<D>>;
-    parse(x: unknown, options?: ParseOptions): InferPartial<D>;
+    parse(u: unknown, options?: ParseOptions): InferPartial<D>;
     toJSON(): {
         type: "partial";
         of: {

package/lib/private/PartialType.js

@@ -1,16 +1,20 @@
 import DefaultType from "#DefaultType";
 import E from "#errors";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import join from "#path/join";
 import next from "#path/next";
+import resolve from "#resolve";
 import VirtualType from "#VirtualType";
 import is from "@rcompat/is";
 export default class PartialType extends VirtualType {
     #spec;
-    constructor(spec) {
+    [Loose];
+    constructor(spec, mode) {
         super();
         this.#spec = spec;
+        this[Loose] = mode;
     }
     get name() {
         return "partial";
@@ -21,7 +25,8 @@ export default class PartialType extends VirtualType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!is.dict(x))
             throw E.invalid_type(x, "object", options);
         const input = x;

package/lib/private/PrimitiveType.d.ts

@@ -12,7 +12,7 @@ export default abstract class PrimitiveType<StaticType, Name extends string> ext
     get options(): ParseOptions<unknown>;
     get validators(): Validator<StaticType>[];
     derive(next: Next<StaticType>): this;
-    parse(x: unknown, options?: ParseOptions<StaticType>): Infer<this>;
+    parse(u: unknown, options?: ParseOptions<StaticType>): Infer<this>;
 }
 export {};
 //# sourceMappingURL=PrimitiveType.d.ts.map

package/lib/private/PrimitiveType.js

@@ -1,7 +1,9 @@
 import CoerceKey from "#CoerceKey";
 import E from "#errors";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
+import resolve from "#resolve";
 import Type from "#Type";
 export default class PrimitiveType extends Type {
     #validators;
@@ -21,10 +23,10 @@ export default class PrimitiveType extends Type {
         const Constructor = this.constructor;
         return new Constructor([...this.#validators, ...next.validators ?? []], { ...this.#options, ...next.options ?? {} });
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         // hotpath: avoid object spread when possible
-        const has_instance_options = this.#options.coerce !== undefined
-            || this.#options[ParsedKey] !== undefined;
+        const has_instance_options = this.#options[ParsedKey] !== undefined;
         const $options = has_instance_options
             ? { ...this.#options, ...options }
             : options;
@@ -33,7 +35,8 @@ export default class PrimitiveType extends Type {
         const validators = option_validators && option_validators.length > 0
             ? option_validators.concat(this.#validators)
             : this.#validators;
-        const $x = $options.coerce === true ? this[CoerceKey](x) : x;
+        const loose = this[Loose] ?? $options[Loose] ?? false;
+        const $x = loose ? this[CoerceKey](x) : x;
         if (typeof $x !== this.name)
             throw E.invalid_type($x, this.name, $options);
         const base = $options[ParsedKey] ?? "";

package/lib/private/PureType.d.ts

@@ -7,7 +7,7 @@ export default class PureType<Type, Name extends string = "PureType"> extends Pa
     get name(): string;
     get Name(): Name;
     optional(): OptionalType<this>;
-    parse(x: unknown): Infer<this>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "pure";
     };

package/lib/private/PureType.js

@@ -10,9 +10,9 @@ export default class PureType extends Parsed {
     optional() {
         return new OptionalType(this);
     }
-    parse(x) {
+    parse(u) {
         // no parsing of static types
-        return x;
+        return u;
     }
     toJSON() {
         return { type: "pure" };

package/lib/private/RecordType.d.ts

@@ -5,22 +5,25 @@ import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type RecordTypeKey from "#RecordTypeKey";
 import type OptionalTrait from "#trait/Optional";
-export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<unknown>> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> implements OptionalTrait {
+import type Mode from "#Mode";
+import Loose from "#Loose";
+export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<unknown>, M extends Mode = undefined> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> implements OptionalTrait {
     #private;
-    constructor(k: Key, v: Value);
+    [Loose]: M;
+    constructor(k: Key, v: Value, mode?: M);
     optional(): OptionalType<this>;
     get name(): "record";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "record";
         key: {
             type: "string";
             datatype: "string";
-        } | {
-            type: "symbol";
         } | {
             type: "number" | "bigint";
             datatype: "f64";
+        } | {
+            type: "symbol";
         };
         value: import("./Serialized.js").default;
     };

package/lib/private/RecordType.js

@@ -4,14 +4,18 @@ import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
 import join from "#path/join";
 import next from "#path/next";
+import resolve from "#resolve";
 import is from "@rcompat/is";
+import Loose from "#Loose";
 export default class RecordType extends GenericType {
     #key;
     #value;
-    constructor(k, v) {
+    [Loose];
+    constructor(k, v, mode) {
         super();
         this.#key = k;
         this.#value = v;
+        this[Loose] = mode;
     }
     optional() {
         return new OptionalType(this);
@@ -19,7 +23,8 @@ export default class RecordType extends GenericType {
     get name() {
         return "record";
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         const path = options[ParsedKey] ?? "";
         if (!is.dict(x))
             throw E.invalid_type(x, "object", path);

package/lib/private/Serialized.d.ts

@@ -2,31 +2,31 @@ import type { Dict, JSONValue } from "@rcompat/type";
 type DT<D extends string = string> = {
     datatype?: D;
 };
-type PrimitiveSerialized = {
+type PrimitiveSerialized = ({
     type: "string";
-} & DT | {
+} & DT) | ({
     type: "boolean";
-} & DT | {
+} & DT) | ({
     type: "symbol";
-} & DT | {
+} & DT) | ({
     type: "null";
-} & DT | {
+} & DT) | ({
     type: "undefined";
-} & DT | {
+} & DT) | ({
     type: "date";
-} & DT | {
+} & DT) | ({
     type: "blob";
-} & DT | {
+} & DT) | ({
     type: "file";
-} & DT | {
+} & DT) | ({
     type: "url";
-} & DT | {
+} & DT) | ({
     type: "uuid";
-} & DT | {
+} & DT) | ({
     type: "uuid_v4";
-} & DT | {
+} & DT) | ({
     type: "uuid_v7";
-} & DT | {
+} & DT) | {
     type: "function";
 };
 type NumberSerialized = {

package/lib/private/Storable.d.ts

@@ -11,5 +11,6 @@ export default abstract class Storable<TKey extends K = K, TValue = unknown> ext
         type: N;
         datatype: T;
     };
+    static is(x: unknown): x is Storable;
 }
 //# sourceMappingURL=Storable.d.ts.map

package/lib/private/Storable.js

@@ -1,7 +1,11 @@
 import Parsed from "#Parsed";
+import is from "@rcompat/is";
 export default class Storable extends Parsed {
     static serialize(s) {
         return { type: s.name, datatype: s.datatype };
     }
+    static is(x) {
+        return is.object(x) && "datatype" in x;
+    }
 }
 //# sourceMappingURL=Storable.js.map

package/lib/private/StoreType.d.ts

@@ -7,7 +7,7 @@ export default class StoreType<S extends StoreSchema> extends ObjectType<S> {
     #private;
     constructor(properties: S, pk?: string | null);
     get name(): string;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
-    partial(): PartialType<any>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
+    partial(): PartialType<any, undefined>;
 }
 //# sourceMappingURL=StoreType.d.ts.map

package/lib/private/StoreType.js

@@ -2,6 +2,7 @@ import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
 import E from "#errors";
 import next from "#path/next";
+import resolve from "#resolve";
 import is from "@rcompat/is";
 export default class StoreType extends ObjectType {
     #pk;
@@ -12,9 +13,10 @@ export default class StoreType extends ObjectType {
     get name() {
         return "store";
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         const $options = { ...options };
-        if (x !== undefined && !is.dict(x))
+        if (is.defined(x) && !is.dict(x))
             throw E.invalid_type(x, "object", $options);
         const input = x ?? {};
         const out = {};

package/lib/private/TupleType.d.ts

@@ -1,5 +1,7 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type NormalizeSchema from "#NormalizeSchema";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
@@ -9,12 +11,13 @@ import type OptionalTrait from "#trait/Optional";
 type InferTuple<T extends Schema[]> = {
     [K in keyof T]: T[K] extends Schema ? NormalizeSchema<T[K]>["infer"] : "tuple-never";
 };
-export default class TupleType<T extends Parsed<unknown>[]> extends GenericType<T, InferTuple<T>, "TupleType"> implements OptionalTrait {
+export default class TupleType<T extends Parsed<unknown>[], M extends Mode = undefined> extends GenericType<T, InferTuple<T>, "TupleType"> implements OptionalTrait {
     #private;
-    constructor(items: T);
+    [Loose]: M;
+    constructor(items: T, mode?: M);
     get name(): "tuple";
     optional(): OptionalType<this>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "tuple";
         of: import("./Serialized.js").default[];