pema 0.1.0 → 0.2.0

package/lib/private/FileType.d.ts

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

package/lib/private/FileType.js

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

package/lib/private/FloatDataType.d.ts

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

package/lib/private/FloatDataType.js

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

package/lib/private/GenericType.d.ts

@@ -1,6 +1,6 @@
-import Validated from "#Validated";
+import Parsed from "#Parsed";
 import type PrintableGeneric from "@rcompat/type/PrintableGeneric";
-export default abstract class GenericType<Type, Inferred, Name extends string> extends Validated<Inferred> implements PrintableGeneric<Type> {
+export default abstract class GenericType<Type, Inferred, Name extends string> extends Parsed<Inferred> implements PrintableGeneric<Type> {
     get Name(): Name;
     get Type(): Type;
 }

package/lib/private/GenericType.js

@@ -1,5 +1,5 @@
-import Validated from "#Validated";
-export default class GenericType extends Validated {
+import Parsed from "#Parsed";
+export default class GenericType extends Parsed {
     get Name() {
         return undefined;
     }

package/lib/private/Id.d.ts

@@ -0,0 +1,3 @@
+type Id = string;
+export type { Id as default };
+//# sourceMappingURL=Id.d.ts.map

package/lib/private/Id.js

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

package/lib/private/Infer.d.ts

@@ -1,4 +1,4 @@
-import type Validated from "#Validated";
-type Infer<T extends Validated<unknown>> = T["infer"];
+import type Parsed from "#Parsed";
+type Infer<T extends Parsed<unknown>> = T["infer"];
 export { Infer as default };
 //# sourceMappingURL=Infer.d.ts.map

package/lib/private/InferInputSchema.d.ts

@@ -0,0 +1,26 @@
+import type ArrayType from "#ArrayType";
+import type DecrementDepth from "#DecrementDepth";
+import type DefaultType from "#DefaultType";
+import type Infer from "#Infer";
+import type NullType from "#NullType";
+import type ObjectType from "#ObjectType";
+import type OptionalType from "#OptionalType";
+import type Parsed from "#Parsed";
+import type Schema from "#Schema";
+import type TupleType from "#TupleType";
+import type UndefinedType from "#UndefinedType";
+import type ImpliedOptional from "@rcompat/type/ImpliedOptional";
+import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
+type InferInputSchema<S, Depth extends number = 3> = [
+    Depth
+] extends [never] ? never : S extends DefaultType<infer T, unknown> ? Infer<T> | undefined : S extends OptionalType<infer T> ? Infer<T> | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
+    [K in keyof P]: InferInputSchema<P[K], DecrementDepth[Depth]>;
+}>> : S extends Parsed<unknown> ? Infer<S> : S extends null ? Infer<NullType> : S extends undefined ? Infer<UndefinedType> : S extends [infer Only] ? Only extends Parsed<unknown> ? Infer<ArrayType<Only>> : never : S extends Schema[] ? InferInputSchema<TupleType<{
+    [K in keyof S]: S[K] extends Parsed<unknown> ? InferInputSchema<S[K], DecrementDepth[Depth]> : never;
+}>> : S extends {
+    [key: string]: Schema;
+} ? ImpliedOptional<UndefinedToOptional<{
+    [K in keyof S]: InferInputSchema<S[K], DecrementDepth[Depth]>;
+}>> : never;
+export type { InferInputSchema as default };
+//# sourceMappingURL=InferInputSchema.d.ts.map

package/lib/private/InferInputSchema.js

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

package/lib/private/InferSchema.d.ts

@@ -1,16 +1,16 @@
 import type ArrayType from "#ArrayType";
+import type DecrementDepth from "#DecrementDepth";
 import type Infer from "#Infer";
 import type NullType from "#NullType";
+import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type TupleType from "#TupleType";
 import type UndefinedType from "#UndefinedType";
-import type Validated from "#Validated";
 import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
-type DecrementDepth = [never, 0, 1, 2, 3, 4];
-type InferSchema<S, Depth extends number = 4> = [
+type InferSchema<S, Depth extends number = 3> = [
     Depth
-] extends [never] ? never : S extends Validated<unknown> ? Infer<S> : S extends null ? Infer<NullType> : S extends undefined ? Infer<UndefinedType> : S extends [infer Only] ? Only extends Validated<unknown> ? Infer<ArrayType<Only>> : never : S extends Schema[] ? InferSchema<TupleType<{
-    [K in keyof S]: S[K] extends Validated<unknown> ? InferSchema<S[K], DecrementDepth[Depth]> : never;
+] extends [never] ? never : S extends Parsed<unknown> ? Infer<S> : S extends null ? Infer<NullType> : S extends undefined ? Infer<UndefinedType> : S extends [infer Only] ? Only extends Parsed<unknown> ? Infer<ArrayType<Only>> : never : S extends Schema[] ? InferSchema<TupleType<{
+    [K in keyof S]: S[K] extends Parsed<unknown> ? InferSchema<S[K], DecrementDepth[Depth]> : never;
 }>> : S extends {
     [key: string]: Schema;
 } ? UndefinedToOptional<{

package/lib/private/InferStore.d.ts

@@ -0,0 +1,9 @@
+import type Parsed from "#Parsed";
+import type StoreSchema from "#StoreSchema";
+import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
+type StoreValue<T> = T extends Parsed<infer U> ? U : never;
+type InferStore<T extends StoreSchema> = UndefinedToOptional<{
+    [K in keyof T]: StoreValue<T[K]>;
+}>;
+export type { InferStore as default };
+//# sourceMappingURL=InferStore.d.ts.map

package/lib/private/InferStore.js

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

package/lib/private/InferStoreOut.d.ts

@@ -0,0 +1,8 @@
+import type InferStore from "#InferStore";
+import type StoreId from "#StoreId";
+import type StoreSchema from "#StoreSchema";
+type InferStoreOut<T extends StoreSchema> = Omit<InferStore<T>, "id"> & {
+    id: StoreId<T>;
+};
+export type { InferStoreOut as default };
+//# sourceMappingURL=InferStoreOut.d.ts.map

package/lib/private/InferStoreOut.js

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

package/lib/private/IntDataType.d.ts

@@ -0,0 +1,3 @@
+type IntDataType = "i16" | "i32" | "i8";
+export type { IntDataType as default };
+//# sourceMappingURL=IntDataType.d.ts.map

package/lib/private/IntDataType.js

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

package/lib/private/IntType.d.ts

@@ -1,7 +1,12 @@
-import type Infer from "#Infer";
-import PrimitiveType from "#PrimitiveType";
-export default class IntType extends PrimitiveType<number | bigint, "IntType"> {
-    constructor();
-    validate(x: unknown, key?: string): Infer<this>;
+import coerce from "#coerce/int";
+import CoerceKey from "#CoerceKey";
+import type IntDataType from "#IntDataType";
+import NumericType from "#NumericType";
+import type ParseOptions from "#ParseOptions";
+import type Storeable from "#Storeable";
+export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storeable<T> {
+    [CoerceKey]: typeof coerce;
+    get name(): string;
+    parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/lib/private/IntType.js

@@ -1,16 +1,17 @@
-import PrimitiveType from "#PrimitiveType";
-import error from "#error";
-import expected from "#expected";
-import is_int from "#is-int";
-export default class IntType extends PrimitiveType {
-    constructor() {
-        super("int");
+import coerce from "#coerce/int";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+import integer from "#validator/integer";
+export default class IntType extends NumericType {
+    [CoerceKey] = coerce;
+    get name() {
+        return "number";
     }
-    validate(x, key) {
-        if (!is_int(x)) {
-            throw new Error(error(expected("int", x), key));
-        }
-        return x;
+    parse(x, options = {}) {
+        return super.parse(x, {
+            ...options,
+            validators: [integer],
+        });
     }
 }
 //# sourceMappingURL=IntType.js.map

package/lib/private/Issue.d.ts

@@ -0,0 +1,6 @@
+import type JSONPointer from "@rcompat/type/JSONPointer";
+export default interface Issue {
+    readonly message: string;
+    readonly path: JSONPointer;
+}
+//# sourceMappingURL=Issue.d.ts.map

package/lib/private/Issue.js

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

package/lib/private/LiteralType.d.ts

@@ -1,12 +1,19 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
-type Literal = string;
+import type ParseOptions from "#ParseOptions";
+type Literal = string | boolean | number;
 type InferLiteral<T extends Literal> = T;
 export default class LiteralType<T extends Literal> extends GenericType<T, InferLiteral<T>, "LiteralType"> {
     #private;
     constructor(literal: T);
+    static new<T extends Literal>(literal: T): LiteralType<T>;
+    static get Literal(): Literal;
     get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "literal";
+        value: T;
+    };
 }
 export {};
 //# sourceMappingURL=LiteralType.d.ts.map

package/lib/private/LiteralType.js

@@ -1,24 +1,32 @@
+import error from "#error";
 import GenericType from "#GenericType";
-import expected from "#expected";
-const error = (message, key) => {
-    return key === undefined
-        ? message
-        : `${key}: ${message}`;
-};
+import ParseError from "#ParseError";
 export default class LiteralType extends GenericType {
     #literal;
     constructor(literal) {
         super();
         this.#literal = literal;
     }
+    static new(literal) {
+        return new LiteralType(literal);
+    }
+    static get Literal() {
+        return undefined;
+    }
     get name() {
-        return "literal";
+        return JSON.stringify(this.#literal);
     }
-    validate(x, key) {
+    parse(x, options = {}) {
         if (x !== this.#literal) {
-            throw new Error(error(expected(`literal '${this.#literal}'`, x), key));
+            throw new ParseError(error(this.name, x, options));
         }
         return x;
     }
+    toJSON() {
+        return {
+            type: "literal",
+            value: this.#literal,
+        };
+    }
 }
 //# sourceMappingURL=LiteralType.js.map

package/lib/private/NormalizeSchema.d.ts

@@ -2,15 +2,20 @@ import type ArrayType from "#ArrayType";
 import type ConstructorType from "#ConstructorType";
 import type LiteralType from "#LiteralType";
 import type NullType from "#NullType";
+import type ObjectType from "#ObjectType";
+import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type TupleType from "#TupleType";
 import type UndefinedType from "#UndefinedType";
-import type Validated from "#Validated";
-import type AbstractConstructor from "@rcompat/type/AbstractConstructor";
-type NormalizeSchema<S> = S extends [] ? TupleType<[]> : S extends Validated<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends AbstractConstructor ? ConstructorType<S> : S extends string ? LiteralType<S> : S extends [infer O] ? O extends Validated<unknown> ? ArrayType<NormalizeSchema<O>> : never : S extends Schema[] ? TupleType<S> : S extends {
-    [K: string]: Schema;
-} ? {
-    -readonly [K in keyof S]: NormalizeSchema<S[K]>;
-} : never;
+import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type EO from "@rcompat/type/EO";
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+type NormalizeSchemaArray<T extends Schema[]> = {
+    [K in keyof T]: NormalizeSchema<T[K]>;
+};
+type NormalizeSchemaObject<T extends Record<string, unknown>> = IsEmptyObject<T> extends true ? EO : {
+    -readonly [K in keyof T]: T[K] extends Parsed<unknown> ? T[K] : NormalizeSchema<T[K]>;
+};
+type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string ? LiteralType<S> : S extends number ? LiteralType<S> : S extends boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [infer O] ? O extends Schema ? ArrayType<NormalizeSchema<O>> : never : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;
 export type { NormalizeSchema as default };
 //# sourceMappingURL=NormalizeSchema.d.ts.map

package/lib/private/NullType.d.ts

@@ -1,7 +1,11 @@
 import type Infer from "#Infer";
+import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 export default class NullType extends PrimitiveType<null, "NullType"> {
-    constructor();
-    validate(x: unknown, key?: string): Infer<this>;
+    get name(): "null";
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "null";
+    };
 }
 //# sourceMappingURL=NullType.d.ts.map

package/lib/private/NullType.js

@@ -1,20 +1,20 @@
-import expected from "#expected";
+import error from "#error";
+import ParseError from "#ParseError";
 import PrimitiveType from "#PrimitiveType";
-const error_message = (name, x, key) => {
-    const base = expected(name, x);
-    return key === undefined
-        ? base
-        : `${key}: ${base}`;
-};
 export default class NullType extends PrimitiveType {
-    constructor() {
-        super("null");
+    get name() {
+        return "null";
     }
-    validate(x, key) {
+    parse(x, options = {}) {
         if (x !== null) {
-            throw new Error(error_message(this.name, x, key));
+            throw new ParseError(error(this.name, x, options));
         }
         return x;
     }
+    toJSON() {
+        return {
+            type: this.name,
+        };
+    }
 }
 //# sourceMappingURL=NullType.js.map

package/lib/private/NumberType.d.ts

@@ -1,5 +1,9 @@
-import PrimitiveType from "#PrimitiveType";
-export default class NumberType extends PrimitiveType<number, "NumberType"> {
-    constructor();
+import CoerceKey from "#CoerceKey";
+import type FloatDataType from "#FloatDataType";
+import NumericType from "#NumericType";
+import coerce from "#coerce/int";
+export default class NumberType<T extends FloatDataType = "f64"> extends NumericType<T, number, "NumberType"> {
+    [CoerceKey]: typeof coerce;
+    get name(): "number";
 }
 //# sourceMappingURL=NumberType.d.ts.map

package/lib/private/NumberType.js

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

package/lib/private/NumericType.d.ts

@@ -0,0 +1,25 @@
+import type DataKey from "#DataKey";
+import type ParseOptions from "#ParseOptions";
+import PrimitiveType from "#PrimitiveType";
+import type Storeable from "#Storeable";
+import type Validator from "#Validator";
+type Next<T> = {
+    options?: ParseOptions;
+    validators?: Validator<T>[];
+};
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storeable<Key> {
+    #private;
+    constructor(datatype: Key, validators?: Validator<T>[], options?: ParseOptions);
+    derive(next: Next<T>): this;
+    values(anyof: Record<string, T>): this;
+    range(from: T, to: T): this;
+    min(from: T): this;
+    max(to: T): this;
+    get datatype(): Key;
+    toJSON(): {
+        type: "number" | "bigint";
+        datatype: Key;
+    };
+}
+export {};
+//# sourceMappingURL=NumericType.d.ts.map

package/lib/private/NumericType.js

@@ -0,0 +1,38 @@
+import PrimitiveType from "#PrimitiveType";
+import max from "#validator/max";
+import min from "#validator/min";
+import range from "#validator/range";
+import values from "#validator/values";
+export default class NumericType extends PrimitiveType {
+    #datatype;
+    constructor(datatype, validators = [], options = {}) {
+        super(validators, options);
+        this.#datatype = datatype;
+    }
+    derive(next) {
+        const Constructor = this.constructor;
+        return new Constructor(this.#datatype, [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
+    }
+    values(anyof) {
+        return this.derive({ validators: [values(anyof)] });
+    }
+    range(from, to) {
+        return this.derive({ validators: [range(from, to)] });
+    }
+    min(from) {
+        return this.derive({ validators: [min(from)] });
+    }
+    max(to) {
+        return this.derive({ validators: [max(to)] });
+    }
+    get datatype() {
+        return this.#datatype;
+    }
+    toJSON() {
+        return {
+            type: this.name,
+            datatype: this.#datatype,
+        };
+    }
+}
+//# sourceMappingURL=NumericType.js.map

package/lib/private/ObjectType.d.ts

@@ -0,0 +1,23 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import type InferInputSchema from "#InferInputSchema";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type Serialized from "#Serialized";
+import type Dict from "@rcompat/type/Dict";
+export default class ObjectType<P extends Dict<Parsed<unknown>>> extends GenericType<P, {
+    [K in keyof P]: P[K]["infer"];
+}, "ObjectType"> {
+    #private;
+    constructor(properties: P, options?: ParseOptions);
+    get name(): string;
+    get properties(): P;
+    get input(): InferInputSchema<P>;
+    get coerce(): this;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "object";
+        properties: Dict<Serialized>;
+    };
+}
+//# sourceMappingURL=ObjectType.d.ts.map

package/lib/private/ObjectType.js

@@ -0,0 +1,53 @@
+import GenericType from "#GenericType";
+import next from "#path/next";
+export default class ObjectType extends GenericType {
+    #properties;
+    #options;
+    constructor(properties, options = {}) {
+        super();
+        this.#properties = properties;
+        this.#options = options;
+    }
+    get name() {
+        const props = Object.entries(this.#properties)
+            .map(([k, v]) => `${k}: ${v.name}`)
+            .join(", ");
+        return `{ ${props} }`;
+    }
+    get properties() {
+        return this.#properties;
+    }
+    get input() {
+        return undefined;
+    }
+    #derive(next) {
+        const Constructor = this.constructor;
+        return new Constructor(this.#properties, { ...this.#options, ...next });
+    }
+    get coerce() {
+        return this.#derive({ coerce: true });
+    }
+    parse(x, options = {}) {
+        const $options = { ...this.#options, ...options };
+        let _x = x;
+        if (typeof x !== "object" || x === null) {
+            _x = {};
+        }
+        const out = {};
+        for (const k in this.#properties) {
+            const parsed = this.#properties[k].parse(_x[k], next(k, $options));
+            if (parsed !== undefined) {
+                out[k] = parsed;
+            }
+        }
+        return out;
+    }
+    toJSON() {
+        const properties = {};
+        for (const [k, v] of Object.entries(this.#properties)) {
+            properties[k] = v.toJSON();
+        }
+        return { type: "object", properties };
+    }
+}
+//# sourceMappingURL=ObjectType.js.map

package/lib/private/OptionalType.d.ts

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

package/lib/private/OptionalType.js

@@ -1,5 +1,5 @@
-import GenericType from "#GenericType";
-export default class OptionalType extends GenericType {
+import VirtualType from "#VirtualType";
+export default class OptionalType extends VirtualType {
     #schema;
     constructor(s) {
         super();
@@ -8,13 +8,25 @@ export default class OptionalType extends GenericType {
     get name() {
         return "optional";
     }
-    validate(x, key) {
+    get schema() {
+        return this.#schema;
+    }
+    get nullable() {
+        return true;
+    }
+    parse(x, options = {}) {
         const s = this.#schema;
         // optional
         if (x === undefined) {
             return undefined;
         }
-        return s.validate(x, key);
+        return s.parse(x, options);
+    }
+    toJSON() {
+        return {
+            type: this.name,
+            of: this.schema.toJSON(),
+        };
     }
 }
 //# sourceMappingURL=OptionalType.js.map

package/lib/private/ParseError.d.ts

@@ -0,0 +1,10 @@
+import type JSONPayload from "#json/JSONPayload";
+import type ParseIssue from "#ParseIssue";
+import type Serializable from "@rcompat/type/Serializable";
+export default class ParseError extends Error implements Serializable {
+    #private;
+    constructor(issues: ParseIssue[]);
+    get issues(): ParseIssue[] | undefined;
+    toJSON(): JSONPayload;
+}
+//# sourceMappingURL=ParseError.d.ts.map