pema 0.6.0 → 0.7.0

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

@@ -13,7 +13,7 @@ export default class PartialType<D extends Partialable> extends VirtualType<D, I
     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

@@ -4,6 +4,7 @@ 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 {
@@ -21,7 +22,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

@@ -10,7 +10,7 @@ export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<
     constructor(k: Key, v: Value);
     optional(): OptionalType<this>;
     get name(): "record";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "record";
         key: {

package/lib/private/RecordType.js

@@ -4,6 +4,7 @@ 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";
 export default class RecordType extends GenericType {
     #key;
@@ -19,7 +20,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/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>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     partial(): PartialType<any>;
 }
 //# 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

@@ -14,7 +14,7 @@ export default class TupleType<T extends Parsed<unknown>[]> extends GenericType<
     constructor(items: T);
     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[];

package/lib/private/TupleType.js

@@ -1,7 +1,10 @@
 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 is from "@rcompat/is";
 export default class TupleType extends GenericType {
     #items;
     constructor(items) {
@@ -14,19 +17,23 @@ export default class TupleType extends GenericType {
     optional() {
         return new OptionalType(this);
     }
-    parse(x, options = {}) {
-        if (!Array.isArray(x))
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.array(x))
             throw E.invalid_type(x, "array", options);
+        const $options = this[Loose] !== undefined
+            ? { ...options, [Loose]: this[Loose] }
+            : options;
         const items = this.#items;
         const n = items.length;
         const out = new Array(n);
         // validate each expected item
         for (let i = 0; i < n; i++) {
-            out[i] = items[i].parse(x[i], next(i, options));
+            out[i] = items[i].parse(x[i], next(i, $options));
         }
         // reject extra items
         if (x.length > n)
-            throw E.invalid_type(x[n], "undefined", next(n, options));
+            throw E.invalid_type(x[n], "undefined", next(n, $options));
         return out;
     }
     toJSON() {

package/lib/private/UUIDType.d.ts

@@ -6,7 +6,7 @@ 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>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "string";
         datatype: "uuid";

package/lib/private/UUIDType.js

@@ -3,6 +3,7 @@ import Storable from "#Storable";
 import UUIDV4Type from "#UUIDV4Type";
 import UUIDV7Type from "#UUIDV7Type";
 import E from "#errors";
+import resolve from "#resolve";
 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();
@@ -14,7 +15,8 @@ export default class UUIDType extends PrimitiveType {
     get datatype() {
         return "uuid";
     }
-    parse(x) {
+    parse(u) {
+        const x = resolve(u);
         if (!is.string(x) || !re.test(x)) {
             throw E.invalid_format(x, `"${x}" is not a valid UUID`);
         }

package/lib/private/UUIDV4Type.d.ts

@@ -4,7 +4,7 @@ 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>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "string";
         datatype: "uuid_v4";

package/lib/private/UUIDV4Type.js

@@ -1,6 +1,7 @@
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
 import E from "#errors";
+import resolve from "#resolve";
 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 {
@@ -10,7 +11,8 @@ export default class UUIDV4Type extends PrimitiveType {
     get datatype() {
         return "uuid_v4";
     }
-    parse(x) {
+    parse(u) {
+        const x = resolve(u);
         if (!is.string(x) || !re.test(x)) {
             throw E.invalid_format(x, `"${x}" is not a valid UUID v4`);
         }

package/lib/private/UUIDV7Type.d.ts

@@ -4,7 +4,7 @@ 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>;
+    parse(u: unknown): Infer<this>;
     toJSON(): {
         type: "string";
         datatype: "uuid_v7";

package/lib/private/UUIDV7Type.js

@@ -1,6 +1,7 @@
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
 import E from "#errors";
+import resolve from "#resolve";
 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 {
@@ -10,7 +11,8 @@ export default class UUIDV7Type extends PrimitiveType {
     get datatype() {
         return "uuid_v7";
     }
-    parse(x) {
+    parse(u) {
+        const x = resolve(u);
         if (!is.string(x) || !re.test(x)) {
             throw E.invalid_format(x, `"${x}" is not a valid UUID v7`);
         }

package/lib/private/UintType.d.ts

@@ -11,6 +11,6 @@ export default class UintType<T extends UintDataType> extends NumericType<T, num
     * Value is a non-privileged port number (1000 - 65535).
     */
     port(): this;
-    parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
+    parse(u: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
 }
 //# sourceMappingURL=UintType.d.ts.map

package/lib/private/UintType.js

@@ -14,8 +14,8 @@ export default class UintType extends NumericType {
     port() {
         return this.derive({ validators: [port] });
     }
-    parse(x, options = {}) {
-        return super.parse(x, {
+    parse(u, options = {}) {
+        return super.parse(u, {
             ...options,
             validators: [integer],
         });

package/lib/private/UnionType.d.ts

@@ -19,7 +19,7 @@ export default class UnionType<T extends Parsed<unknown>[]> extends GenericType<
     get schema(): T;
     optional(): OptionalType<this>;
     default(value: (() => InferUnion<T>) | InferUnion<T>): DefaultType<this, InferUnion<T>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "union";
         of: import("./Serialized.js").default[];

package/lib/private/UnionType.js

@@ -1,13 +1,14 @@
 import DefaultType from "#DefaultType";
 import E from "#errors";
 import GenericType from "#GenericType";
-import isParsedType from "#is-parsed-type";
+import is_parsed from "#is-parsed";
 import OptionalType from "#OptionalType";
 import ParseError from "#ParseError";
+import resolve from "#resolve";
 import S from "#schema-errors";
 import assert from "@rcompat/assert";
 const print = (type) => {
-    const parsed = isParsedType(type);
+    const parsed = is_parsed(type);
     if (parsed) {
         return type.name;
     }
@@ -25,7 +26,7 @@ const print = (type) => {
     }
     return type;
 };
-const union_error = (types) => `\`${types.map(t => isParsedType(t) ? t.name : print(t)).join(" | ")}\``;
+const union_error = (types) => `\`${types.map(t => is_parsed(t) ? t.name : print(t)).join(" | ")}\``;
 export default class UnionType extends GenericType {
     #of;
     constructor(of) {
@@ -45,7 +46,8 @@ export default class UnionType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         for (const type of this.#of) {
             try {
                 type.parse(x, options);

package/lib/private/VirtualType.js

@@ -1,8 +1,8 @@
 import GenericType from "#GenericType";
-const storable = (x) => !!x && typeof x === "object" && "datatype" in x;
+import Storable from "#Storable";
 export default class VirtualType extends GenericType {
     get datatype() {
-        if (storable(this.schema))
+        if (Storable.is(this.schema))
             return this.schema.datatype;
         throw new Error("cannot be used in a store");
     }

package/lib/private/array.d.ts

@@ -1,8 +1,10 @@
 import ArrayType from "#ArrayType";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
-/**
-* Value is an array of the given type.
-*/
-export default function array<const S extends Schema>(of: S): ArrayType<NormalizeSchema<S>>;
+declare const array: {
+    strict: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+    loose: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+    vanilla: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+};
+export default array;
 //# sourceMappingURL=array.d.ts.map

package/lib/private/array.js

@@ -1,9 +1,22 @@
 import ArrayType from "#ArrayType";
+import Loose from "#Loose";
 import normalize from "#normalize";
 /**
 * Value is an array of the given type.
 */
-export default function array(of) {
+const vanilla = function array(of) {
     return new ArrayType(normalize(of));
-}
+};
+const loose = function array(of) {
+    const i = new ArrayType(normalize(of));
+    i[Loose] = true;
+    return i;
+};
+const strict = function array(of) {
+    const i = new ArrayType(normalize(of));
+    i[Loose] = false;
+    return i;
+};
+const array = { strict, loose, vanilla };
+export default array;
 //# sourceMappingURL=array.js.map

package/lib/private/blob.d.ts

@@ -1,4 +1,8 @@
 import BlobType from "#BlobType";
-declare const _default: BlobType;
-export default _default;
+declare const blob: {
+    vanilla: BlobType;
+    loose: BlobType;
+    strict: BlobType;
+};
+export default blob;
 //# sourceMappingURL=blob.d.ts.map

package/lib/private/blob.js

@@ -1,3 +1,10 @@
 import BlobType from "#BlobType";
-export default new BlobType();
+import Loose from "#Loose";
+const vanilla = new BlobType();
+const loose = new BlobType();
+loose[Loose] = true;
+const strict = new BlobType();
+strict[Loose] = false;
+const blob = { vanilla, loose, strict };
+export default blob;
 //# sourceMappingURL=blob.js.map

package/lib/private/boolean.d.ts

@@ -1,7 +1,8 @@
 import BooleanType from "#BooleanType";
-/**
-* Value is a boolean.
-*/
-declare const _default: BooleanType;
-export default _default;
+declare const boolean: {
+    vanilla: BooleanType;
+    loose: BooleanType;
+    strict: BooleanType;
+};
+export default boolean;
 //# sourceMappingURL=boolean.d.ts.map

package/lib/private/boolean.js

@@ -1,6 +1,10 @@
 import BooleanType from "#BooleanType";
-/**
-* Value is a boolean.
-*/
-export default new BooleanType();
+import Loose from "#Loose";
+const vanilla = new BooleanType();
+const loose = new BooleanType();
+loose[Loose] = true;
+const strict = new BooleanType();
+strict[Loose] = false;
+const boolean = { vanilla, loose, strict };
+export default boolean;
 //# sourceMappingURL=boolean.js.map

package/lib/private/coerce/date.js

@@ -1,3 +1,4 @@
+import is from "@rcompat/is";
 const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 // time with optional :ss and .ms, but TZ is REQUIRED (Z or ±HH:MM)
 const ISO_DATETIME_TZ = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})$/;
@@ -44,13 +45,10 @@ export default function coerceDate(x) {
     if (x instanceof Date)
         return x;
     // numbers are treated as epochs
-    if (typeof x === "number" && Number.isFinite(x)) {
+    if (is.finite(x))
         return fromNumber(x);
-    }
-    // strings
-    if (typeof x === "string") {
+    if (is.string(x))
         return fromString(x);
-    }
     return x;
 }
 //# sourceMappingURL=date.js.map

package/lib/private/coerce/int.js

@@ -3,7 +3,7 @@ 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))
+    if (is.int(n))
         return n;
     return x;
 }

package/lib/private/constructor.d.ts

@@ -1,8 +1,9 @@
 import ConstructorType from "#ConstructorType";
 import type { AbstractNewable } from "@rcompat/type";
-/**
- * Value is a constructed instance of the given class.
- */
-declare const _default: <const C extends AbstractNewable>(constructor: C) => ConstructorType<C>;
-export default _default;
+declare const constructor: {
+    vanilla: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+    loose: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+    strict: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+};
+export default constructor;
 //# sourceMappingURL=constructor.d.ts.map

package/lib/private/constructor.js

@@ -1,6 +1,21 @@
 import ConstructorType from "#ConstructorType";
+import Loose from "#Loose";
 /**
  * Value is a constructed instance of the given class.
  */
-export default (constructor) => new ConstructorType(constructor);
+const vanilla = function constructor(c) {
+    return new ConstructorType(c);
+};
+const loose = function constructor(c) {
+    const i = new ConstructorType(c);
+    i[Loose] = true;
+    return i;
+};
+const strict = function constructor(c) {
+    const i = new ConstructorType(c);
+    i[Loose] = false;
+    return i;
+};
+const constructor = { vanilla, loose, strict };
+export default constructor;
 //# sourceMappingURL=constructor.js.map

package/lib/private/date.d.ts

@@ -1,4 +1,8 @@
 import DateType from "#DateType";
-declare const _default: DateType;
-export default _default;
+declare const date: {
+    vanilla: DateType;
+    loose: DateType;
+    strict: DateType;
+};
+export default date;
 //# sourceMappingURL=date.d.ts.map

package/lib/private/date.js

@@ -1,3 +1,10 @@
 import DateType from "#DateType";
-export default new DateType();
+import Loose from "#Loose";
+const vanilla = new DateType();
+const loose = new DateType();
+loose[Loose] = true;
+const strict = new DateType();
+strict[Loose] = false;
+const date = { vanilla, loose, strict };
+export default date;
 //# sourceMappingURL=date.js.map