pema 0.3.0 → 0.5.0

package/lib/private/PartialType.js

@@ -1,11 +1,11 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
+import fail from "#fail";
 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 fail("object", x, options);
         const input = x;
         const out = {};
         const issues = [];
@@ -40,9 +39,8 @@ export default class PartialType extends VirtualType {
             catch (e) {
                 if (e instanceof ParseError) {
                     // child already rebased to /<key> via nextOptions -> just collect
-                    if (e.issues && e.issues.length) {
+                    if (e.issues && e.issues.length)
                         issues.push(...e.issues);
-                    }
                 }
                 else {
                     // wrap non-ParseError into a properly-pathed issue at /<key>
@@ -57,9 +55,8 @@ export default class PartialType extends VirtualType {
                 }
             }
         }
-        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.js

@@ -25,29 +25,38 @@ export default class PrimitiveType extends Type {
         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));
         }
         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) {
                     // 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);

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;

package/lib/private/RecordType.js

@@ -1,17 +1,12 @@
-import error from "#error";
 import expected from "#expected";
+import fail from "#fail";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import join from "#path/join";
-const nextOptions = (k, options) => {
-    const base = options?.[ParsedKey] ?? "";
-    return options === undefined
-        ? { [ParsedKey]: join("", k) }
-        : { ...options, [ParsedKey]: join(base, k) };
-};
-const is_numeric = (string) => /^-?\d+(\.\d+)?$/.test(string);
+import next from "#path/next";
+import is from "@rcompat/is";
 export default class RecordType extends GenericType {
     #key;
     #value;
@@ -27,9 +22,8 @@ export default class RecordType extends GenericType {
         return "record";
     }
     parse(x, options = {}) {
-        if (typeof x !== "object" || x === null) {
-            throw new ParseError(error("object", x, options));
-        }
+        if (!is.dict(x))
+            throw fail("object", x, options);
         const key_name = this.#key.name;
         const keys = Object.keys(x);
         const symbols = Object.getOwnPropertySymbols(x);
@@ -44,21 +38,21 @@ export default class RecordType extends GenericType {
                     }]);
             }
             keys.forEach(k => {
-                if (key_name === "string" && is_numeric(k)) {
+                if (key_name === "string" && is.numeric(k)) {
                     throw new ParseError([{
                             input: x,
                             message: expected("string key", +k),
                             path: join(base, k),
                         }]);
                 }
-                if (key_name === "number" && !is_numeric(k)) {
+                if (key_name === "number" && !is.numeric(k)) {
                     throw new ParseError([{
                             input: x,
                             message: expected("number key", k),
                             path: join(base, k),
                         }]);
                 }
-                this.#value.parse(x[k], nextOptions(k, options));
+                this.#value.parse(x[k], next(k, options));
             });
         }
         if (key_name === "symbol") {

package/lib/private/Schema.d.ts

@@ -1,5 +1,5 @@
 import type Parsed from "#Parsed";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type { AbstractNewable } from "@rcompat/type";
 type Schema = Parsed<unknown> | AbstractNewable | null | undefined | string | number | boolean | Schema[] | {
     [k: string]: Schema;
 };

package/lib/private/Serialized.d.ts

@@ -1,5 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
-import type JSONValue from "@rcompat/type/JSONValue";
+import type { Dict, JSONValue } from "@rcompat/type";
 type DT<D extends string = string> = {
     datatype?: D;
 };
@@ -63,9 +62,10 @@ type StructuralSerialized = {
     type: "schema";
     of: Serialized;
 } | {
-    type: "pure";
+    type: "omit";
+    properties: Dict<Serialized>;
 } | {
-    type: "primary";
+    type: "pure";
 };
 type Serialized = PrimitiveSerialized | NumberSerialized | BigIntSerialized | StructuralSerialized;
 export type { Serialized as default };

package/lib/private/{Storeable.d.ts → Storable.d.ts}

@@ -1,7 +1,7 @@
 import type K from "#DataKey";
 import Parsed from "#Parsed";
 import type Serialized from "#Serialized";
-export default abstract class Storeable<T extends K = K> extends Parsed<unknown> {
+export default abstract class Storable<T extends K = K> extends Parsed<unknown> {
     abstract get datatype(): T;
     abstract toJSON(): Serialized;
     static serialize<N extends string, T extends K>(s: {
@@ -12,4 +12,4 @@ export default abstract class Storeable<T extends K = K> extends Parsed<unknown>
         datatype: T;
     };
 }
-//# sourceMappingURL=Storeable.d.ts.map
+//# sourceMappingURL=Storable.d.ts.map

package/lib/private/{Storeable.js → Storable.js}

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

package/lib/private/StoreSchema.d.ts

@@ -1,8 +1,5 @@
-import type Storeable from "#Storeable";
-type StoreSchema = {
-    [k: string]: Storeable;
-} & {
-    id: Storeable;
-};
+import type Storable from "#Storable";
+import type { Dict } from "@rcompat/type";
+type StoreSchema = Dict<Storable>;
 export type { StoreSchema as default };
 //# sourceMappingURL=StoreSchema.d.ts.map

package/lib/private/StoreType.d.ts

@@ -1,21 +1,13 @@
-import GenericType from "#GenericType";
 import type Infer from "#Infer";
-import type InferStore from "#InferStore";
+import ObjectType from "#ObjectType";
 import type ParseOptions from "#ParseOptions";
 import PartialType from "#PartialType";
-import type Serialized from "#Serialized";
 import type StoreSchema from "#StoreSchema";
-import type Dict from "@rcompat/type/Dict";
-export default class StoreType<T extends StoreSchema> extends GenericType<T, InferStore<T>, "StoreType"> {
+export default class StoreType<S extends StoreSchema> extends ObjectType<S> {
     #private;
-    constructor(spec: T);
+    constructor(properties: S, pk?: string | null);
     get name(): string;
-    get schema(): T;
-    partial(): PartialType<T>;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
-    toJSON(): {
-        type: "object";
-        properties: Dict<Serialized>;
-    };
+    partial(): PartialType<any>;
 }
 //# sourceMappingURL=StoreType.d.ts.map

package/lib/private/StoreType.js

@@ -1,45 +1,34 @@
-import GenericType from "#GenericType";
-import ParsedKey from "#ParsedKey";
+import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
-import join from "#path/join";
-export default class StoreType extends GenericType {
-    #properties;
-    constructor(spec) {
-        super();
-        this.#properties = spec;
+import fail from "#fail";
+import next from "#path/next";
+import is from "@rcompat/is";
+export default class StoreType extends ObjectType {
+    #pk;
+    constructor(properties, pk = null) {
+        super(properties);
+        this.#pk = pk;
     }
     get name() {
         return "store";
     }
-    get schema() {
-        return this.#properties;
-    }
-    partial() {
-        return new PartialType(this.#properties);
-    }
     parse(x, options = {}) {
-        const spec = this.#properties;
-        if (typeof x !== "object" || x === null) {
-            throw new Error("Expected object");
+        const $options = { ...options };
+        if (x !== undefined && !is.dict(x))
+            throw fail("object", x, $options);
+        const input = x ?? {};
+        const out = {};
+        for (const k in this.properties) {
+            if (k === this.#pk && !(k in input))
+                continue;
+            const parsed = this.properties[k].parse(input[k], next(k, $options));
+            if (parsed !== undefined)
+                out[k] = parsed;
         }
-        const result = {};
-        for (const k in spec) {
-            const r = spec[k].parse(x[k], {
-                ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
-            });
-            // exclude undefined (optionals)
-            if (r !== undefined) {
-                result[k] = r;
-            }
-        }
-        return x;
+        return out;
     }
-    toJSON() {
-        const properties = {};
-        for (const [k, v] of Object.entries(this.#properties)) {
-            properties[k] = v.toJSON();
-        }
-        return { type: "object", properties };
+    partial() {
+        return new PartialType(this.properties);
     }
 }
 //# sourceMappingURL=StoreType.js.map

package/lib/private/StringType.d.ts

@@ -1,6 +1,6 @@
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-export default class StringType extends PrimitiveType<string, "StringType"> implements Storeable<"string"> {
+import Storable from "#Storable";
+export default class StringType extends PrimitiveType<string, "StringType"> implements Storable<"string"> {
     get name(): "string";
     get datatype(): "string";
     isotime(): this;

package/lib/private/StringType.js

@@ -1,6 +1,6 @@
 import schemafail from "#error/schemafail";
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 import email from "#validator/email";
 import ends_with from "#validator/ends-with";
 import isotime from "#validator/isotime";
@@ -51,7 +51,7 @@ export default class StringType extends PrimitiveType {
         return this.derive({ validators: [length(from, to)] });
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=StringType.js.map

package/lib/private/TupleType.d.ts

@@ -1,13 +1,13 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
-import type InferSchema from "#InferSchema";
+import type NormalizeSchema from "#NormalizeSchema";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Schema from "#Schema";
 import type OptionalTrait from "#trait/Optional";
 type InferTuple<T extends Schema[]> = {
-    [K in keyof T]: T[K] extends Schema ? InferSchema<T[K]> : "tuple-never";
+    [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 {
     #private;

package/lib/private/TupleType.js

@@ -1,7 +1,6 @@
-import error from "#error";
+import fail from "#fail";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-import ParseError from "#ParseError";
 import next from "#path/next";
 export default class TupleType extends GenericType {
     #items;
@@ -16,19 +15,23 @@ export default class TupleType extends GenericType {
         return new OptionalType(this);
     }
     parse(x, options = {}) {
-        if (!(!!x && Array.isArray(x))) {
-            throw new ParseError(error("array", x, options));
-        }
-        this.#items.forEach((v, i) => {
-            v.parse(x[i], next(i, options));
-        });
-        x.forEach((v, i) => {
-            if (i >= this.#items.length) {
-                throw new ParseError(error("undefined", v, next(i, options)));
-            }
-        });
+        if (!Array.isArray(x))
+            throw fail("array", x, options);
+        const items = this.#items;
+        const len = items.length;
+        // validate each expected item
+        for (let i = 0; i < len; i++)
+            items[i].parse(x[i], next(i, options));
+        // reject extra items
+        if (x.length > len)
+            throw fail("undefined", x[len], next(len, options));
         return x;
     }
-    toJSON() { return { type: this.name, of: this.#items.map(i => i.toJSON()) }; }
+    toJSON() {
+        return {
+            type: this.name,
+            of: this.#items.map(i => i.toJSON()),
+        };
+    }
 }
 //# sourceMappingURL=TupleType.js.map

package/lib/private/Type.d.ts

@@ -3,7 +3,7 @@ import OptionalType from "#OptionalType";
 import Parsed from "#Parsed";
 import type DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
-import type Printable from "@rcompat/type/Printable";
+import type { Printable } from "@rcompat/type";
 export default abstract class Type<T, Name extends string> extends Parsed<T> implements Printable, DefaultTrait<T>, OptionalTrait {
     optional(): OptionalType<this>;
     default<S extends T>(value: (() => S) | S): DefaultType<this, S>;

package/lib/private/URLType.d.ts

@@ -1,6 +1,6 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
-export default class URLType extends BuiltinType<URL, "URLType"> implements Storeable<"url"> {
+import Storable from "#Storable";
+export default class URLType extends BuiltinType<URL, "URLType"> implements Storable<"url"> {
     get Type(): {
         new (url: string | URL, base?: string | URL): URL;
         prototype: URL;

package/lib/private/URLType.js

@@ -1,5 +1,5 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class URLType extends BuiltinType {
     get Type() {
         return URL;
@@ -11,7 +11,7 @@ export default class URLType extends BuiltinType {
         return "url";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=URLType.js.map

package/lib/private/UintType.d.ts

@@ -2,9 +2,9 @@ import coerce from "#coerce/int";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
-import type Storeable from "#Storeable";
+import type Storable from "#Storable";
 import type UintDataType from "#UintDataType";
-export default class UintType<T extends UintDataType> extends NumericType<T, number, "UintType"> implements Storeable<T> {
+export default class UintType<T extends UintDataType> extends NumericType<T, number, "UintType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
     /**

package/lib/private/UnionType.d.ts

@@ -1,16 +1,16 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
-import type InferSchema from "#InferSchema";
+import type NormalizeSchema from "#NormalizeSchema";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Schema from "#Schema";
 import type DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
-import type TupleToUnion from "@rcompat/type/TupleToUnion";
+import type { TupleToUnion } from "@rcompat/type";
 type InferUnion<T extends Schema[]> = TupleToUnion<{
-    [K in keyof T]: T[K] extends Schema ? InferSchema<T[K]> : "union-never";
+    [K in keyof T]: T[K] extends Schema ? NormalizeSchema<T[K]>["infer"] : "union-never";
 }>;
 export default class UnionType<T extends Parsed<unknown>[]> extends GenericType<T, InferUnion<T>, "UnionType"> implements OptionalTrait, DefaultTrait<InferUnion<T>> {
     #private;

package/lib/private/UnionType.js

@@ -1,7 +1,6 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
+import fail from "#fail";
 import GenericType from "#GenericType";
-import schema from "#index";
 import isParsedType from "#is-parsed-type";
 import OptionalType from "#OptionalType";
 import ParseError from "#ParseError";
@@ -29,7 +28,7 @@ const union_error = (types) => `\`${types.map(t => isParsedType(t) ? t.name : pr
 export default class UnionType extends GenericType {
     #of;
     constructor(of) {
-        assert(of.length > 1, "union type must have at least two members");
+        assert.true(of.length > 1, "union type must have at least two members");
         super();
         this.#of = of;
     }
@@ -46,21 +45,20 @@ export default class UnionType extends GenericType {
         return new DefaultType(this, value);
     }
     parse(x, options = {}) {
-        // union parses when any of its members parses
-        const parsed = this.#of.map(type => {
-            const validator = isParsedType(type) ? type : schema(type);
+        for (const type of this.#of) {
             try {
-                validator.parse(x, options);
-                return true;
+                type.parse(x, options);
+                return x;
             }
             catch (e) {
-                return e;
+                if (!(e instanceof ParseError)) {
+                    throw e;
+                }
+                // continue to next
             }
-        });
-        if (!parsed.some(r => r === true)) {
-            throw new ParseError(error(union_error(this.#of), x, options));
         }
-        return x;
+        // all types failed
+        throw fail(union_error(this.#of), x, options);
     }
     toJSON() {
         return { type: this.name, of: this.#of.map(t => t.toJSON()) };

package/lib/private/VirtualType.js

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

package/lib/private/coerce/bigint.js

@@ -1,12 +1,10 @@
-import integer from "@rcompat/is/integer";
-import numeric from "@rcompat/is/numeric";
+import is from "@rcompat/is";
 export default function coerceBigInt(x) {
     // normalize from string to number; other types unaffected
-    const n = numeric(x) ? Number(x) : x;
+    const n = is.numeric(x) ? Number(x) : x;
     // normalize from number to bigint; other types unaffected
-    if (integer(n)) {
+    if (is.int(n))
         return BigInt(n);
-    }
     // bigint or invalid
     return x;
 }

package/lib/private/coerce/int.js

@@ -1,8 +1,7 @@
-import numeric from "@rcompat/is/numeric";
+import is from "@rcompat/is";
 export default function coerceInt(x) {
-    if (numeric(x)) {
+    if (is.numeric(x))
         return Number(x);
-    }
     return x;
 }
 //# sourceMappingURL=int.js.map

package/lib/private/constructor.d.ts

@@ -1,5 +1,5 @@
 import ConstructorType from "#ConstructorType";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type { AbstractNewable } from "@rcompat/type";
 /**
  * Value is a constructed instance of the given class.
  */

package/lib/private/dict.d.ts

@@ -0,0 +1,11 @@
+import type Parsed from "#Parsed";
+import type RecordType from "#RecordType";
+import type StringType from "#StringType";
+/**
+ * Value is a dictionary (record with string keys) of the given type.
+ *
+ * @param of - The value type (defaults to p.string)
+ */
+export default function dict(): RecordType<StringType, StringType>;
+export default function dict<const Value extends Parsed<unknown>>(of: Value): RecordType<StringType, Value>;
+//# sourceMappingURL=dict.d.ts.map

package/lib/private/dict.js

@@ -0,0 +1,6 @@
+import record from "#record";
+import string from "#string";
+export default function dict(of = string) {
+    return record(string, of);
+}
+//# sourceMappingURL=dict.js.map

package/lib/private/fail.d.ts

@@ -0,0 +1,4 @@
+import error from "#error";
+import ParseError from "#ParseError";
+export default function fail(...args: Parameters<typeof error>): ParseError;
+//# sourceMappingURL=fail.d.ts.map

package/lib/private/fail.js

@@ -0,0 +1,6 @@
+import error from "#error";
+import ParseError from "#ParseError";
+export default function fail(...args) {
+    return new ParseError(error(...args));
+}
+//# sourceMappingURL=fail.js.map