pema 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/private/ArrayType.d.ts

@@ -1,12 +1,35 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import OptionalType from "#OptionalType";
-import type Validated from "#Validated";
-export default class ArrayType<T extends Validated<unknown>> extends GenericType<T, Infer<T>[], "ArrayType"> {
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type OptionalTrait from "#trait/Optional";
+import type Validator from "#Validator";
+import type Primitive from "@rcompat/type/Primitive";
+type Next<T> = {
+    validators?: Validator<T>[];
+};
+export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait {
     #private;
-    constructor(subtype: T);
+    constructor(item: T, validators?: Validator<Array<Infer<T>>>[]);
+    get name(): "array";
     optional(): OptionalType<this>;
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    derive(_next: Next<Array<Infer<T>>>): this;
+    /**
+     * Member values are unique — only for primitive subtypes.
+     *
+     * @throws `SchemaError` if the subtype is not a primitive.
+     * @returns ArrayType<T>
+     */
+    unique(this: Infer<T> extends Primitive ? ArrayType<T> : never): ArrayType<T>;
+    min(limit: number): this;
+    max(limit: number): this;
+    length(from: number, to: number): this;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "array";
+        of: import("./Serialized.js").default;
+    };
 }
+export {};
 //# sourceMappingURL=ArrayType.d.ts.map

package/lib/private/ArrayType.js

@@ -1,48 +1,108 @@
-import expected from "#expected";
+import error from "#error";
+import schemafail from "#error/schemafail";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-const member_error = (i, key) => {
-    return key === undefined
-        ? `[${i}]`
-        : `${key}[${i}]`;
-};
-const error = (message, key) => {
-    return key === undefined
-        ? message
-        : `${key}: ${message}`;
-};
+import ParsedKey from "#ParsedKey";
+import ParseError from "#ParseError";
+import join from "#path/join";
+import next from "#path/next";
+import rebase from "#path/rebase";
+import PrimitiveType from "#PrimitiveType";
+import length from "#validator/length";
+import max from "#validator/max";
+import min from "#validator/min";
+import unique from "#validator/unique";
+function isPrimitive(x) {
+    return x instanceof PrimitiveType;
+}
 const is = (x, validator) => validator(x);
 export default class ArrayType extends GenericType {
-    #subtype;
-    constructor(subtype) {
+    #item;
+    #validators;
+    constructor(item, validators = []) {
         super();
-        this.#subtype = subtype;
+        this.#item = item;
+        this.#validators = validators;
+    }
+    get name() {
+        return "array";
     }
     optional() {
         return new OptionalType(this);
     }
-    get name() {
-        return "array";
+    derive(_next) {
+        const Constructor = this.constructor;
+        return new Constructor(this.#item, [...this.#validators, ..._next.validators ?? []]);
+    }
+    /**
+     * Member values are unique — only for primitive subtypes.
+     *
+     * @throws `SchemaError` if the subtype is not a primitive.
+     * @returns ArrayType<T>
+     */
+    unique() {
+        if (!isPrimitive(this.#item)) {
+            throw schemafail("unique: subtype {0} must be primitive", this.#item.name);
+        }
+        return this.derive({ validators: [unique] });
     }
-    validate(x, key) {
+    min(limit) {
+        if (limit < 0) {
+            throw schemafail("min: {0} must be positive", limit);
+        }
+        return this.derive({ validators: [min(limit)] });
+    }
+    max(limit) {
+        if (limit < 0) {
+            throw schemafail("max: {0} must be positive", limit);
+        }
+        return this.derive({ validators: [max(limit)] });
+    }
+    length(from, to) {
+        return this.derive({ validators: [length(from, to)] });
+    }
+    parse(x, options = {}) {
         if (!is(x, _ => !!x && Array.isArray(x))) {
-            throw new Error(error(expected("array", x), key));
+            throw new ParseError(error("array", x, options));
         }
+        const base = options[ParsedKey] ?? "";
         let last = 0;
         x.forEach((v, i) => {
             // sparse array check
             if (i > last) {
-                throw new Error(error(expected(this.#subtype.name, undefined), `[${last}]`));
+                throw new ParseError([{
+                        ...error(this.#item.name, undefined, options)[0],
+                        path: join(base, last),
+                    }]);
             }
-            const validator = this.#subtype;
-            validator.validate(v, `${member_error(i, key)}`);
+            const validator = this.#item;
+            validator.parse(v, next(i, options));
             last++;
         });
         // sparse array with end slots
         if (x.length > last) {
-            throw new Error(error(expected(this.#subtype.name, undefined), `[${last}]`));
+            throw new ParseError([{
+                    ...error(this.#item.name, undefined, options)[0],
+                    path: join(base, last),
+                }]);
+        }
+        for (const v of this.#validators) {
+            try {
+                v(x);
+            }
+            catch (e) {
+                if (e instanceof ParseError) {
+                    const rebased = (e.issues ?? [])
+                        .map(i => ({ ...i, path: rebase(base, i.path) }));
+                    throw new ParseError(rebased);
+                }
+                throw e;
+            }
         }
         return x;
     }
+    toJSON() {
+        return { type: this.name, of: this.#item.toJSON() };
+    }
 }
 //# sourceMappingURL=ArrayType.js.map

package/lib/private/BigIntDataType.d.ts

@@ -0,0 +1,3 @@
+type BigintDataType = "i128" | "i64";
+export type { BigintDataType as default };
+//# sourceMappingURL=BigIntDataType.d.ts.map

package/lib/private/BigIntDataType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BigIntDataType.js.map

package/lib/private/BigIntType.d.ts

@@ -1,5 +1,10 @@
-import PrimitiveType from "#PrimitiveType";
-export default class BigIntType extends PrimitiveType<bigint, "BigIntType"> {
-    constructor();
+import type BigIntDataType from "#BigIntDataType";
+import coerce from "#coerce/bigint";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+import type Storeable from "#Storeable";
+export default class BigIntType<T extends BigIntDataType = "i64"> extends NumericType<T, bigint, "BigIntType"> implements Storeable<T> {
+    [CoerceKey]: typeof coerce;
+    get name(): string;
 }
 //# sourceMappingURL=BigIntType.d.ts.map

package/lib/private/BigIntType.js

@@ -1,7 +1,10 @@
-import PrimitiveType from "#PrimitiveType";
-export default class BigIntType extends PrimitiveType {
-    constructor() {
-        super("bigint");
+import coerce from "#coerce/bigint";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+export default class BigIntType extends NumericType {
+    [CoerceKey] = coerce;
+    get name() {
+        return "bigint";
     }
 }
 //# sourceMappingURL=BigIntType.js.map

package/lib/private/BigUintDataType.d.ts

@@ -0,0 +1,3 @@
+type BigUintDataType = "u128" | "u64";
+export type { BigUintDataType as default };
+//# sourceMappingURL=BigUintDataType.d.ts.map

package/lib/private/BigUintDataType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BigUintDataType.js.map

package/lib/private/BigUintType.d.ts

@@ -0,0 +1,10 @@
+import type BigUintDataType from "#BigUintDataType";
+import coerce from "#coerce/bigint";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+import type Storeable from "#Storeable";
+export default class BigUintType<T extends BigUintDataType = "u64"> extends NumericType<T, bigint, "BigUintType"> implements Storeable<T> {
+    [CoerceKey]: typeof coerce;
+    get name(): string;
+}
+//# sourceMappingURL=BigUintType.d.ts.map

package/lib/private/BigUintType.js

@@ -0,0 +1,10 @@
+import coerce from "#coerce/bigint";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+export default class BigUintType extends NumericType {
+    [CoerceKey] = coerce;
+    get name() {
+        return "bigint";
+    }
+}
+//# sourceMappingURL=BigUintType.js.map

package/lib/private/BlobType.d.ts

@@ -1,5 +1,15 @@
 import BuiltinType from "#BuiltinType";
-export default class BlobType extends BuiltinType<Blob, "BlobType"> {
-    constructor();
+import Storeable from "#Storeable";
+export default class BlobType extends BuiltinType<Blob, "BlobType"> implements Storeable<"blob"> {
+    get Type(): {
+        new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+        prototype: Blob;
+    };
+    get name(): "blob";
+    get datatype(): "blob";
+    toJSON(): {
+        type: "blob";
+        datatype: "blob";
+    };
 }
 //# sourceMappingURL=BlobType.d.ts.map

package/lib/private/BlobType.js

@@ -1,7 +1,17 @@
 import BuiltinType from "#BuiltinType";
+import Storeable from "#Storeable";
 export default class BlobType extends BuiltinType {
-    constructor() {
-        super("blob", Blob);
+    get Type() {
+        return Blob;
+    }
+    get name() {
+        return "blob";
+    }
+    get datatype() {
+        return "blob";
+    }
+    toJSON() {
+        return Storeable.serialize(this);
     }
 }
 //# sourceMappingURL=BlobType.js.map

package/lib/private/BooleanType.d.ts

@@ -1,5 +1,13 @@
+import CoerceKey from "#CoerceKey";
 import PrimitiveType from "#PrimitiveType";
-export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> {
-    constructor();
+import Storeable from "#Storeable";
+export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storeable<"boolean"> {
+    get name(): "boolean";
+    get datatype(): "boolean";
+    [CoerceKey](x: unknown): unknown;
+    toJSON(): {
+        type: "boolean";
+        datatype: "boolean";
+    };
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/lib/private/BooleanType.js

@@ -1,7 +1,19 @@
+import CoerceKey from "#CoerceKey";
 import PrimitiveType from "#PrimitiveType";
+import Storeable from "#Storeable";
+import boolish from "@rcompat/is/boolish";
 export default class BooleanType extends PrimitiveType {
-    constructor() {
-        super("boolean");
+    get name() {
+        return "boolean";
+    }
+    get datatype() {
+        return "boolean";
+    }
+    [CoerceKey](x) {
+        return boolish(x) ? x === "true" : x;
+    }
+    toJSON() {
+        return Storeable.serialize(this);
     }
 }
 //# sourceMappingURL=BooleanType.js.map

package/lib/private/BuiltinType.d.ts

@@ -1,10 +1,12 @@
 import type Infer from "#Infer";
+import type ParseOptions from "#ParseOptions";
 import Type from "#Type";
-import type AbstractorController from "@rcompat/type/AbstractConstructor";
-export default class BuiltinType<StaticType, Name extends string> extends Type<StaticType, Name> {
+import type AbstractNewable from "@rcompat/type/AbstractNewable";
+export default abstract class BuiltinType<StaticType, Name extends string> extends Type<StaticType, Name> {
     #private;
-    constructor(name: string, type: AbstractorController);
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    abstract get Type(): AbstractNewable;
+    constructor(options?: ParseOptions);
+    get coerce(): this;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
 }
 //# sourceMappingURL=BuiltinType.d.ts.map

package/lib/private/BuiltinType.js

@@ -1,26 +1,27 @@
+import CoerceKey from "#CoerceKey";
+import error from "#error";
+import ParseError from "#ParseError";
 import Type from "#Type";
-const error_message = (name, x, key) => {
-    const base = `expected ${name}, got \`${x}\` (${(typeof x)})`;
-    return key === undefined
-        ? base
-        : `${key}: ${base}`;
-};
 export default class BuiltinType extends Type {
-    #name;
-    #type;
-    constructor(name, type) {
+    #options;
+    constructor(options = {}) {
         super();
-        this.#name = name;
-        this.#type = type;
+        this.#options = options;
     }
-    get name() {
-        return this.#name;
+    #derive(next) {
+        const Constructor = this.constructor;
+        return new Constructor({ ...this.#options, ...next });
     }
-    validate(x, key) {
-        if (!(x instanceof this.#type)) {
-            throw new Error(error_message(this.#name, x, key));
+    get coerce() {
+        return this.#derive({ coerce: true });
+    }
+    parse(x, options = {}) {
+        const $options = { ...this.#options, ...options };
+        const $x = $options.coerce === true ? this[CoerceKey](x) : x;
+        if (!($x instanceof this.Type)) {
+            throw new ParseError(error(this.name, $x, $options));
         }
-        return x;
+        return $x;
     }
 }
 //# sourceMappingURL=BuiltinType.js.map

package/lib/private/CoerceKey.d.ts

@@ -0,0 +1,4 @@
+declare const CoerceKey: unique symbol;
+type CoerceKey = typeof CoerceKey;
+export { CoerceKey as default };
+//# sourceMappingURL=CoerceKey.d.ts.map

package/lib/private/CoerceKey.js

@@ -0,0 +1,3 @@
+const CoerceKey = Symbol("CoerceKey");
+export { CoerceKey as default };
+//# sourceMappingURL=CoerceKey.js.map

package/lib/private/ConstructorType.d.ts

@@ -1,12 +1,18 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
-import type AbstractConstructor from "@rcompat/type/AbstractConstructor";
-export default class ConstructorType<C extends AbstractConstructor> extends GenericType<C, InstanceType<C>, "InstanceType"> {
+import type ParseOptions from "#ParseOptions";
+import type DefaultTrait from "#trait/Default";
+import type AbstractNewable from "@rcompat/type/AbstractNewable";
+export default class ConstructorType<C extends AbstractNewable> extends GenericType<C, InstanceType<C>, "InstanceType"> implements DefaultTrait<InstanceType<C>> {
     #private;
     constructor(t: C);
-    default(value: InstanceType<C> | (() => InstanceType<C>)): DefaultType<this, InstanceType<C>>;
     get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    default(value: (() => InstanceType<C>) | InstanceType<C>): DefaultType<this, InstanceType<C>>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "newable";
+        of: string;
+    };
 }
 //# sourceMappingURL=ConstructorType.d.ts.map

package/lib/private/ConstructorType.js

@@ -1,28 +1,30 @@
 import DefaultType from "#DefaultType";
+import error from "#error";
 import GenericType from "#GenericType";
-const error_message = (name, x, key) => {
-    const base = `expected ${name}, got \`${x}\` (${(typeof x)})`;
-    return key === undefined
-        ? base
-        : `${key}: ${base}`;
-};
+import ParseError from "#ParseError";
 export default class ConstructorType extends GenericType {
     #type;
     constructor(t) {
         super();
         this.#type = t;
     }
-    default(value) {
-        return new DefaultType(this, value);
-    }
     get name() {
         return "constructor";
     }
-    validate(x, key) {
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
         if (!(x instanceof this.#type)) {
-            throw new Error(error_message(this.name, x, key));
+            throw new ParseError(error(this.name, x, options));
         }
         return x;
     }
+    toJSON() {
+        return {
+            type: "newable",
+            of: this.#type.name,
+        };
+    }
 }
 //# sourceMappingURL=ConstructorType.js.map

package/lib/private/DataKey.d.ts

@@ -0,0 +1,4 @@
+import type DataType from "#DataType";
+type DataKey = keyof DataType;
+export type { DataKey as default };
+//# sourceMappingURL=DataKey.d.ts.map

package/lib/private/DataKey.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataKey.js.map

package/lib/private/DataType.d.ts

@@ -0,0 +1,23 @@
+type DataType = {
+    blob: Blob;
+    boolean: boolean;
+    datetime: Date;
+    f32: number;
+    f64: number;
+    i128: bigint;
+    i16: number;
+    i32: number;
+    i64: bigint;
+    i8: number;
+    primary: string;
+    string: string;
+    time: string;
+    u128: bigint;
+    u16: number;
+    u32: number;
+    u64: bigint;
+    u8: number;
+    url: URL;
+};
+export type { DataType as default };
+//# sourceMappingURL=DataType.d.ts.map

package/lib/private/DataType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataType.js.map

package/lib/private/DateType.d.ts

@@ -1,5 +1,15 @@
 import BuiltinType from "#BuiltinType";
-export default class DateType extends BuiltinType<Date, "DateType"> {
-    constructor();
+import coerce from "#coerce/date";
+import CoerceKey from "#CoerceKey";
+import Storeable from "#Storeable";
+export default class DateType extends BuiltinType<Date, "DateType"> implements Storeable<"datetime"> {
+    [CoerceKey]: typeof coerce;
+    get Type(): DateConstructor;
+    get name(): "date";
+    get datatype(): "datetime";
+    toJSON(): {
+        type: "date";
+        datatype: "datetime";
+    };
 }
 //# sourceMappingURL=DateType.d.ts.map

package/lib/private/DateType.js

@@ -1,7 +1,20 @@
 import BuiltinType from "#BuiltinType";
+import coerce from "#coerce/date";
+import CoerceKey from "#CoerceKey";
+import Storeable from "#Storeable";
 export default class DateType extends BuiltinType {
-    constructor() {
-        super("date", Date);
+    [CoerceKey] = coerce;
+    get Type() {
+        return Date;
+    }
+    get name() {
+        return "date";
+    }
+    get datatype() {
+        return "datetime";
+    }
+    toJSON() {
+        return Storeable.serialize(this);
     }
 }
 //# sourceMappingURL=DateType.js.map

package/lib/private/DecrementDepth.d.ts

@@ -0,0 +1,3 @@
+type DecrementDepth = [never, 0, 1, 2, 3];
+export type { DecrementDepth as default };
+//# sourceMappingURL=DecrementDepth.d.ts.map

package/lib/private/DecrementDepth.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DecrementDepth.js.map

package/lib/private/DefaultType.d.ts

@@ -1,10 +1,17 @@
-import GenericType from "#GenericType";
 import type Infer from "#Infer";
-import type Validated from "#Validated";
-export default class DefaultType<S extends Validated<unknown>, D extends Infer<S>> extends GenericType<S, Infer<S>, "DefaultType"> {
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import VirtualType from "#VirtualType";
+export default class DefaultType<S extends Parsed<unknown>, D extends Infer<S>> extends VirtualType<S, Infer<S>, "DefaultType"> {
     #private;
-    constructor(s: S, d: D | (() => D));
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    constructor(s: S, d: (() => D) | D);
+    get name(): "default";
+    get schema(): S;
+    get input(): Infer<S> | undefined;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "default";
+        of: import("./Serialized.js").default;
+    };
 }
 //# sourceMappingURL=DefaultType.d.ts.map

package/lib/private/DefaultType.js

@@ -1,8 +1,9 @@
-import GenericType from "#GenericType";
-const is_default_function = (x) => {
+import VirtualType from "#VirtualType";
+function isDefaultFunction(x) {
     return typeof x === "function";
-};
-export default class DefaultType extends GenericType {
+}
+;
+export default class DefaultType extends VirtualType {
     #schema;
     #default;
     constructor(s, d) {
@@ -13,15 +14,22 @@ export default class DefaultType extends GenericType {
     get name() {
         return "default";
     }
-    validate(x, key) {
+    get schema() {
+        return this.#schema;
+    }
+    get input() {
+        return undefined;
+    }
+    parse(x, options = {}) {
+        let $x = x;
         // default fallback
-        if (x === undefined) {
-            if (is_default_function(this.#default)) {
-                return this.#default();
-            }
-            return this.#default;
+        if ($x === undefined) {
+            $x = isDefaultFunction(this.#default) ? this.#default() : this.#default;
         }
-        return this.#schema.validate(x, key);
+        return this.#schema.parse($x, options);
+    }
+    toJSON() {
+        return { type: this.name, of: this.#schema.toJSON() };
     }
 }
 //# sourceMappingURL=DefaultType.js.map