pema 0.1.0

package/lib/private/AbstractConstructor.d.ts

@@ -0,0 +1,3 @@
+type AbstractConstructor<T = object> = abstract new (...args: never) => T;
+export type { AbstractConstructor as default };
+//# sourceMappingURL=AbstractConstructor.d.ts.map

package/lib/private/AbstractConstructor.js

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

package/lib/private/ArrayType.d.ts

@@ -0,0 +1,12 @@
+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"> {
+    #private;
+    constructor(subtype: T);
+    optional(): OptionalType<this>;
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=ArrayType.d.ts.map

package/lib/private/ArrayType.js

@@ -0,0 +1,48 @@
+import expected from "#expected";
+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}`;
+};
+const is = (x, validator) => validator(x);
+export default class ArrayType extends GenericType {
+    #subtype;
+    constructor(subtype) {
+        super();
+        this.#subtype = subtype;
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    get name() {
+        return "array";
+    }
+    validate(x, key) {
+        if (!is(x, _ => !!x && Array.isArray(x))) {
+            throw new Error(error(expected("array", x), key));
+        }
+        let last = 0;
+        x.forEach((v, i) => {
+            // sparse array check
+            if (i > last) {
+                throw new Error(error(expected(this.#subtype.name, undefined), `[${last}]`));
+            }
+            const validator = this.#subtype;
+            validator.validate(v, `${member_error(i, key)}`);
+            last++;
+        });
+        // sparse array with end slots
+        if (x.length > last) {
+            throw new Error(error(expected(this.#subtype.name, undefined), `[${last}]`));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=ArrayType.js.map

package/lib/private/BigIntType.d.ts

@@ -0,0 +1,5 @@
+import PrimitiveType from "#PrimitiveType";
+export default class BigIntType extends PrimitiveType<bigint, "BigIntType"> {
+    constructor();
+}
+//# sourceMappingURL=BigIntType.d.ts.map

package/lib/private/BigIntType.js

@@ -0,0 +1,7 @@
+import PrimitiveType from "#PrimitiveType";
+export default class BigIntType extends PrimitiveType {
+    constructor() {
+        super("bigint");
+    }
+}
+//# sourceMappingURL=BigIntType.js.map

package/lib/private/BlobType.d.ts

@@ -0,0 +1,5 @@
+import BuiltinType from "#BuiltinType";
+export default class BlobType extends BuiltinType<Blob, "BlobType"> {
+    constructor();
+}
+//# sourceMappingURL=BlobType.d.ts.map

package/lib/private/BlobType.js

@@ -0,0 +1,7 @@
+import BuiltinType from "#BuiltinType";
+export default class BlobType extends BuiltinType {
+    constructor() {
+        super("blob", Blob);
+    }
+}
+//# sourceMappingURL=BlobType.js.map

package/lib/private/BooleanType.d.ts

@@ -0,0 +1,5 @@
+import PrimitiveType from "#PrimitiveType";
+export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> {
+    constructor();
+}
+//# sourceMappingURL=BooleanType.d.ts.map

package/lib/private/BooleanType.js

@@ -0,0 +1,7 @@
+import PrimitiveType from "#PrimitiveType";
+export default class BooleanType extends PrimitiveType {
+    constructor() {
+        super("boolean");
+    }
+}
+//# sourceMappingURL=BooleanType.js.map

package/lib/private/BuiltinType.d.ts

@@ -0,0 +1,10 @@
+import type Infer from "#Infer";
+import Type from "#Type";
+import type AbstractorController from "@rcompat/type/AbstractConstructor";
+export default 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>;
+}
+//# sourceMappingURL=BuiltinType.d.ts.map

package/lib/private/BuiltinType.js

@@ -0,0 +1,26 @@
+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) {
+        super();
+        this.#name = name;
+        this.#type = type;
+    }
+    get name() {
+        return this.#name;
+    }
+    validate(x, key) {
+        if (!(x instanceof this.#type)) {
+            throw new Error(error_message(this.#name, x, key));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=BuiltinType.js.map

package/lib/private/ConstructorType.d.ts

@@ -0,0 +1,12 @@
+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"> {
+    #private;
+    constructor(t: C);
+    default(value: InstanceType<C> | (() => InstanceType<C>)): DefaultType<this, InstanceType<C>>;
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=ConstructorType.d.ts.map

package/lib/private/ConstructorType.js

@@ -0,0 +1,28 @@
+import DefaultType from "#DefaultType";
+import GenericType from "#GenericType";
+const error_message = (name, x, key) => {
+    const base = `expected ${name}, got \`${x}\` (${(typeof x)})`;
+    return key === undefined
+        ? base
+        : `${key}: ${base}`;
+};
+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) {
+        if (!(x instanceof this.#type)) {
+            throw new Error(error_message(this.name, x, key));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=ConstructorType.js.map

package/lib/private/DateType.d.ts

@@ -0,0 +1,5 @@
+import BuiltinType from "#BuiltinType";
+export default class DateType extends BuiltinType<Date, "DateType"> {
+    constructor();
+}
+//# sourceMappingURL=DateType.d.ts.map

package/lib/private/DateType.js

@@ -0,0 +1,7 @@
+import BuiltinType from "#BuiltinType";
+export default class DateType extends BuiltinType {
+    constructor() {
+        super("date", Date);
+    }
+}
+//# sourceMappingURL=DateType.js.map

package/lib/private/DefaultType.d.ts

@@ -0,0 +1,10 @@
+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"> {
+    #private;
+    constructor(s: S, d: D | (() => D));
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=DefaultType.d.ts.map

package/lib/private/DefaultType.js

@@ -0,0 +1,27 @@
+import GenericType from "#GenericType";
+const is_default_function = (x) => {
+    return typeof x === "function";
+};
+export default class DefaultType extends GenericType {
+    #schema;
+    #default;
+    constructor(s, d) {
+        super();
+        this.#schema = s;
+        this.#default = d;
+    }
+    get name() {
+        return "default";
+    }
+    validate(x, key) {
+        // default fallback
+        if (x === undefined) {
+            if (is_default_function(this.#default)) {
+                return this.#default();
+            }
+            return this.#default;
+        }
+        return this.#schema.validate(x, key);
+    }
+}
+//# sourceMappingURL=DefaultType.js.map

package/lib/private/FileType.d.ts

@@ -0,0 +1,5 @@
+import BuiltinType from "#BuiltinType";
+export default class FileType extends BuiltinType<File, "FileType"> {
+    constructor();
+}
+//# sourceMappingURL=FileType.d.ts.map

package/lib/private/FileType.js

@@ -0,0 +1,7 @@
+import BuiltinType from "#BuiltinType";
+export default class FileType extends BuiltinType {
+    constructor() {
+        super("file", File);
+    }
+}
+//# sourceMappingURL=FileType.js.map

package/lib/private/GenericType.d.ts

@@ -0,0 +1,7 @@
+import Validated from "#Validated";
+import type PrintableGeneric from "@rcompat/type/PrintableGeneric";
+export default abstract class GenericType<Type, Inferred, Name extends string> extends Validated<Inferred> implements PrintableGeneric<Type> {
+    get Name(): Name;
+    get Type(): Type;
+}
+//# sourceMappingURL=GenericType.d.ts.map

package/lib/private/GenericType.js

@@ -0,0 +1,10 @@
+import Validated from "#Validated";
+export default class GenericType extends Validated {
+    get Name() {
+        return undefined;
+    }
+    get Type() {
+        return undefined;
+    }
+}
+//# sourceMappingURL=GenericType.js.map

package/lib/private/Infer.d.ts

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

package/lib/private/Infer.js

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

package/lib/private/InferSchema.d.ts

@@ -0,0 +1,20 @@
+import type ArrayType from "#ArrayType";
+import type Infer from "#Infer";
+import type NullType from "#NullType";
+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> = [
+    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;
+}>> : S extends {
+    [key: string]: Schema;
+} ? UndefinedToOptional<{
+    [K in keyof S]: InferSchema<S[K], DecrementDepth[Depth]>;
+}> : never;
+export type { InferSchema as default };
+//# sourceMappingURL=InferSchema.d.ts.map

package/lib/private/InferSchema.js

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

package/lib/private/IntType.d.ts

@@ -0,0 +1,7 @@
+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>;
+}
+//# sourceMappingURL=IntType.d.ts.map

package/lib/private/IntType.js

@@ -0,0 +1,16 @@
+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");
+    }
+    validate(x, key) {
+        if (!is_int(x)) {
+            throw new Error(error(expected("int", x), key));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=IntType.js.map

package/lib/private/LiteralType.d.ts

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

package/lib/private/LiteralType.js

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

package/lib/private/MaybeInt.d.ts

@@ -0,0 +1,3 @@
+type MaybeInt = number | bigint;
+export type { MaybeInt as default };
+//# sourceMappingURL=MaybeInt.d.ts.map

package/lib/private/MaybeInt.js

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

package/lib/private/NormalizeSchema.d.ts

@@ -0,0 +1,16 @@
+import type ArrayType from "#ArrayType";
+import type ConstructorType from "#ConstructorType";
+import type LiteralType from "#LiteralType";
+import type NullType from "#NullType";
+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;
+export type { NormalizeSchema as default };
+//# sourceMappingURL=NormalizeSchema.d.ts.map

package/lib/private/NormalizeSchema.js

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

package/lib/private/NullType.d.ts

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

package/lib/private/NullType.js

@@ -0,0 +1,20 @@
+import expected from "#expected";
+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");
+    }
+    validate(x, key) {
+        if (x !== null) {
+            throw new Error(error_message(this.name, x, key));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=NullType.js.map

package/lib/private/NumberType.d.ts

@@ -0,0 +1,5 @@
+import PrimitiveType from "#PrimitiveType";
+export default class NumberType extends PrimitiveType<number, "NumberType"> {
+    constructor();
+}
+//# sourceMappingURL=NumberType.d.ts.map

package/lib/private/NumberType.js

@@ -0,0 +1,7 @@
+import PrimitiveType from "#PrimitiveType";
+export default class NumberType extends PrimitiveType {
+    constructor() {
+        super("number");
+    }
+}
+//# sourceMappingURL=NumberType.js.map

package/lib/private/OptionalType.d.ts

@@ -0,0 +1,10 @@
+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"> {
+    #private;
+    constructor(s: S);
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=OptionalType.d.ts.map

package/lib/private/OptionalType.js

@@ -0,0 +1,20 @@
+import GenericType from "#GenericType";
+export default class OptionalType extends GenericType {
+    #schema;
+    constructor(s) {
+        super();
+        this.#schema = s;
+    }
+    get name() {
+        return "optional";
+    }
+    validate(x, key) {
+        const s = this.#schema;
+        // optional
+        if (x === undefined) {
+            return undefined;
+        }
+        return s.validate(x, key);
+    }
+}
+//# sourceMappingURL=OptionalType.js.map

package/lib/private/PrimitiveType.d.ts

@@ -0,0 +1,11 @@
+import type Infer from "#Infer";
+import Type from "#Type";
+import type Validator from "#Validator";
+export default class PrimitiveType<StaticType, Name extends string> extends Type<StaticType, Name> {
+    #private;
+    constructor(name: string, validators?: Validator<StaticType>[]);
+    get validators(): Validator<StaticType>[];
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=PrimitiveType.d.ts.map

package/lib/private/PrimitiveType.js

@@ -0,0 +1,31 @@
+import expected from "#expected";
+import Type from "#Type";
+const error_message = (name, x, key) => {
+    const base = expected(name, x);
+    return key === undefined
+        ? base
+        : `${key}: ${base}`;
+};
+export default class PrimitiveType extends Type {
+    #name;
+    #validators;
+    constructor(name, validators = []) {
+        super();
+        this.#name = name;
+        this.#validators = validators;
+    }
+    get validators() {
+        return this.#validators;
+    }
+    get name() {
+        return this.#name;
+    }
+    validate(x, key) {
+        if (typeof x !== this.name) {
+            throw new Error(error_message(this.name, x, key));
+        }
+        this.#validators.forEach(validator => validator(x));
+        return x;
+    }
+}
+//# sourceMappingURL=PrimitiveType.js.map

package/lib/private/RecordType.d.ts

@@ -0,0 +1,13 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import type RecordTypeKey from "#RecordTypeKey";
+import type Validated from "#Validated";
+export default class RecordType<Key extends RecordTypeKey, Value extends Validated<unknown>> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> {
+    #private;
+    constructor(k: Key, v: Value);
+    optional(): OptionalType<this>;
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=RecordType.d.ts.map

package/lib/private/RecordType.js

@@ -0,0 +1,58 @@
+import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+import expected from "#expected";
+const error = (k, key) => {
+    return key === undefined
+        ? `.${k}`
+        : `${key}.${k}`;
+};
+const is_numeric = (string) => /^-?\d+(\.\d+)?$/.test(string);
+export default class RecordType extends GenericType {
+    #key;
+    #value;
+    constructor(k, v) {
+        super();
+        this.#key = k;
+        this.#value = v;
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    get name() {
+        return "record";
+    }
+    validate(x, key) {
+        if (typeof x !== "object" || x === null) {
+            throw new Error("Expected object");
+        }
+        const key_name = this.#key.name;
+        const keys = Object.keys(x);
+        const symbols = Object.getOwnPropertySymbols(x);
+        if (key_name === "string" || key_name === "number") {
+            // no key may be a symbol
+            if (symbols.length > 0) {
+                throw new Error(expected(`${key_name} key`, symbols[0]));
+            }
+            keys.forEach(k => {
+                if (key_name === "string" && is_numeric(k)) {
+                    throw new Error(expected("string key", +k));
+                }
+                if (key_name === "number" && !is_numeric(k)) {
+                    throw new Error(expected("number key", k));
+                }
+                this.#value.validate(x[k], error(k.toString(), key));
+            });
+        }
+        if (key_name === "symbol") {
+            // no key may not be a symbol
+            if (keys.length > 0) {
+                throw new Error(expected("symbol key", keys[0]));
+            }
+            symbols.forEach(k => {
+                this.#value.validate(x[k], error(k.toString(), key));
+            });
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=RecordType.js.map

package/lib/private/RecordTypeKey.d.ts

@@ -0,0 +1,6 @@
+import type NumberType from "#NumberType";
+import type StringType from "#StringType";
+import type SymbolType from "#SymbolType";
+type KeyType = StringType | NumberType | SymbolType;
+export type { KeyType as default };
+//# sourceMappingURL=RecordTypeKey.d.ts.map

package/lib/private/RecordTypeKey.js

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

package/lib/private/Schema.d.ts

@@ -0,0 +1,7 @@
+import type Validated from "#Validated";
+import type AbstractConstructor from "@rcompat/type/AbstractConstructor";
+type Schema = Validated<unknown> | Schema[] | null | undefined | string | AbstractConstructor | {
+    [k: string]: Schema;
+};
+export type { Schema as default };
+//# sourceMappingURL=Schema.d.ts.map

package/lib/private/Schema.js

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