pema 0.4.0 → 0.6.0

package/lib/private/RecordType.js

@@ -1,17 +1,10 @@
-import error from "#error";
-import expected from "#expected";
+import E from "#errors";
 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,48 +20,30 @@ export default class RecordType extends GenericType {
         return "record";
     }
     parse(x, options = {}) {
-        if (typeof x !== "object" || x === null) {
-            throw new ParseError(error("object", x, options));
-        }
+        const path = options[ParsedKey] ?? "";
+        if (!is.dict(x))
+            throw E.invalid_type(x, "object", path);
         const key_name = this.#key.name;
         const keys = Object.keys(x);
         const symbols = Object.getOwnPropertySymbols(x);
-        const base = options[ParsedKey] ?? "";
         if (key_name === "string" || key_name === "number") {
             // no key may be a symbol
-            if (symbols.length > 0) {
-                throw new ParseError([{
-                        input: x,
-                        message: expected(`${key_name} key`, symbols[0]),
-                        path: base,
-                    }]);
-            }
+            if (symbols.length > 0)
+                throw E.invalid_type(x, `${key_name} key`, path);
             keys.forEach(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 === "string" && is.numeric(k)) {
+                    throw E.invalid_type(x, "string key", join(path, k));
                 }
-                if (key_name === "number" && !is_numeric(k)) {
-                    throw new ParseError([{
-                            input: x,
-                            message: expected("number key", k),
-                            path: join(base, k),
-                        }]);
+                if (key_name === "number" && !is.numeric(k)) {
+                    throw E.invalid_type(x, "number key", join(path, k));
                 }
-                this.#value.parse(x[k], nextOptions(k, options));
+                this.#value.parse(x[k], next(k, options));
             });
         }
         if (key_name === "symbol") {
             // disallow any non-symbol keys
             if (keys.length > 0) {
-                throw new ParseError([{
-                        input: x,
-                        message: expected("symbol key", keys[0]),
-                        path: join(base, keys[0]),
-                    }]);
+                throw E.invalid_type(keys[0], "symbol key", join(path, keys[0]));
             }
             symbols.forEach(k => {
                 this.#value.parse(x[k], options);

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;
 };
@@ -21,7 +20,15 @@ type PrimitiveSerialized = {
     type: "file";
 } & DT | {
     type: "url";
-} & DT;
+} & DT | {
+    type: "uuid";
+} & DT | {
+    type: "uuid_v4";
+} & DT | {
+    type: "uuid_v7";
+} & DT | {
+    type: "function";
+};
 type NumberSerialized = {
     type: "number";
 } & DT;
@@ -62,13 +69,20 @@ type StructuralSerialized = {
 } | {
     type: "schema";
     of: Serialized;
+} | {
+    type: "json";
+    datatype: "json";
+    of?: Serialized;
 } | {
     type: "omit";
     properties: Dict<Serialized>;
+} | {
+    type: "enum";
+    values: string[];
 } | {
     type: "pure";
 } | {
-    type: "primary";
+    type: "is";
 };
 type Serialized = PrimitiveSerialized | NumberSerialized | BigIntSerialized | StructuralSerialized;
 export type { Serialized as default };

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

@@ -1,8 +1,8 @@
 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> {
-    abstract get datatype(): T;
+export default abstract class Storable<TKey extends K = K, TValue = unknown> extends Parsed<TValue> {
+    abstract get datatype(): TKey;
     abstract toJSON(): Serialized;
     static serialize<N extends string, T extends K>(s: {
         name: N;
@@ -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,9 +1,13 @@
+import type Infer from "#Infer";
 import ObjectType from "#ObjectType";
+import type ParseOptions from "#ParseOptions";
 import PartialType from "#PartialType";
 import type StoreSchema from "#StoreSchema";
 export default class StoreType<S extends StoreSchema> extends ObjectType<S> {
-    constructor(spec: S);
+    #private;
+    constructor(properties: S, pk?: string | null);
     get name(): string;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
     partial(): PartialType<any>;
 }
 //# sourceMappingURL=StoreType.d.ts.map

package/lib/private/StoreType.js

@@ -1,12 +1,32 @@
 import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
+import E from "#errors";
+import next from "#path/next";
+import is from "@rcompat/is";
 export default class StoreType extends ObjectType {
-    constructor(spec) {
-        super(spec);
+    #pk;
+    constructor(properties, pk = null) {
+        super(properties);
+        this.#pk = pk;
     }
     get name() {
         return "store";
     }
+    parse(x, options = {}) {
+        const $options = { ...options };
+        if (x !== undefined && !is.dict(x))
+            throw E.invalid_type(x, "object", $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;
+        }
+        return out;
+    }
     partial() {
         return new PartialType(this.properties);
     }

package/lib/private/StringType.d.ts

@@ -1,12 +1,11 @@
 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;
     regex(pattern: RegExp): this;
     email(): this;
-    uuid(): this;
     startsWith(prefix: string): this;
     endsWith(suffix: string): this;
     min(limit: number): this;

package/lib/private/StringType.js

@@ -1,6 +1,6 @@
-import schemafail from "#error/schemafail";
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
+import E from "#schema-errors";
+import Storable from "#Storable";
 import email from "#validator/email";
 import ends_with from "#validator/ends-with";
 import isotime from "#validator/isotime";
@@ -9,7 +9,6 @@ import max from "#validator/max";
 import min from "#validator/min";
 import regex from "#validator/regex";
 import starts_with from "#validator/starts-with";
-import uuid from "#validator/uuid";
 export default class StringType extends PrimitiveType {
     get name() {
         return "string";
@@ -26,9 +25,6 @@ export default class StringType extends PrimitiveType {
     email() {
         return this.derive({ validators: [email] });
     }
-    uuid() {
-        return this.derive({ validators: [uuid] });
-    }
     startsWith(prefix) {
         return this.derive({ validators: [starts_with(prefix)] });
     }
@@ -36,22 +32,20 @@ export default class StringType extends PrimitiveType {
         return this.derive({ validators: [ends_with(suffix)] });
     }
     min(limit) {
-        if (limit < 0) {
-            throw schemafail("min: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw E.min_negative(limit);
         return this.derive({ validators: [min(limit)] });
     }
     max(limit) {
-        if (limit < 0) {
-            throw schemafail("max: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw E.max_negative(limit);
         return this.derive({ validators: [max(limit)] });
     }
     length(from, to) {
         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 E from "#errors";
 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,25 @@ 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));
+        if (!Array.isArray(x))
+            throw E.invalid_type(x, "array", 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));
         }
-        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)));
-            }
-        });
-        return x;
+        // reject extra items
+        if (x.length > n)
+            throw E.invalid_type(x[n], "undefined", next(n, options));
+        return out;
+    }
+    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/UUIDType.d.ts

@@ -0,0 +1,17 @@
+import type Infer from "#Infer";
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import UUIDV4Type from "#UUIDV4Type";
+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>;
+    toJSON(): {
+        type: "string";
+        datatype: "uuid";
+    };
+    v4(): UUIDV4Type;
+    v7(): UUIDV7Type;
+}
+//# sourceMappingURL=UUIDType.d.ts.map

package/lib/private/UUIDType.js

@@ -0,0 +1,33 @@
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import UUIDV4Type from "#UUIDV4Type";
+import UUIDV7Type from "#UUIDV7Type";
+import E from "#errors";
+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();
+const v7 = new UUIDV7Type();
+export default class UUIDType extends PrimitiveType {
+    get name() {
+        return "string";
+    }
+    get datatype() {
+        return "uuid";
+    }
+    parse(x) {
+        if (!is.string(x) || !re.test(x)) {
+            throw E.invalid_format(x, `"${x}" is not a valid UUID`);
+        }
+        return x;
+    }
+    toJSON() {
+        return Storable.serialize(this);
+    }
+    v4() {
+        return v4;
+    }
+    v7() {
+        return v7;
+    }
+}
+//# sourceMappingURL=UUIDType.js.map

package/lib/private/UUIDV4Type.d.ts

@@ -0,0 +1,13 @@
+import type Infer from "#Infer";
+import PrimitiveType from "#PrimitiveType";
+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>;
+    toJSON(): {
+        type: "string";
+        datatype: "uuid_v4";
+    };
+}
+//# sourceMappingURL=UUIDV4Type.d.ts.map

package/lib/private/UUIDV4Type.js

@@ -0,0 +1,23 @@
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import E from "#errors";
+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 {
+    get name() {
+        return "string";
+    }
+    get datatype() {
+        return "uuid_v4";
+    }
+    parse(x) {
+        if (!is.string(x) || !re.test(x)) {
+            throw E.invalid_format(x, `"${x}" is not a valid UUID v4`);
+        }
+        return x;
+    }
+    toJSON() {
+        return Storable.serialize(this);
+    }
+}
+//# sourceMappingURL=UUIDV4Type.js.map

package/lib/private/UUIDV7Type.d.ts

@@ -0,0 +1,13 @@
+import type Infer from "#Infer";
+import PrimitiveType from "#PrimitiveType";
+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>;
+    toJSON(): {
+        type: "string";
+        datatype: "uuid_v7";
+    };
+}
+//# sourceMappingURL=UUIDV7Type.d.ts.map

package/lib/private/UUIDV7Type.js

@@ -0,0 +1,23 @@
+import PrimitiveType from "#PrimitiveType";
+import Storable from "#Storable";
+import E from "#errors";
+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 {
+    get name() {
+        return "string";
+    }
+    get datatype() {
+        return "uuid_v7";
+    }
+    parse(x) {
+        if (!is.string(x) || !re.test(x)) {
+            throw E.invalid_format(x, `"${x}" is not a valid UUID v7`);
+        }
+        return x;
+    }
+    toJSON() {
+        return Storable.serialize(this);
+    }
+}
+//# sourceMappingURL=UUIDV7Type.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,10 +1,10 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
+import E from "#errors";
 import GenericType from "#GenericType";
-import schema from "#index";
 import isParsedType from "#is-parsed-type";
 import OptionalType from "#OptionalType";
 import ParseError from "#ParseError";
+import S from "#schema-errors";
 import assert from "@rcompat/assert";
 const print = (type) => {
     const parsed = isParsedType(type);
@@ -29,7 +29,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, S.union_at_least_two_members());
         super();
         this.#of = of;
     }
@@ -46,21 +46,19 @@ 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 (!ParseError.is(e))
+                    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 E.invalid_type(x, union_error(this.#of), 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.d.ts

@@ -1,2 +1,2 @@
-export default function coerceBigInt(x: unknown): unknown;
+export default function coerce_bigint(x: unknown): unknown;
 //# sourceMappingURL=bigint.d.ts.map

package/lib/private/coerce/bigint.js

@@ -1,12 +1,10 @@
-import integer from "@rcompat/is/integer";
-import numeric from "@rcompat/is/numeric";
-export default function coerceBigInt(x) {
+import is from "@rcompat/is";
+export default function coerce_bigint(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;
 }