pema 0.1.0

package/lib/private/SchemaType.d.ts

@@ -0,0 +1,13 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import type InferSchema from "#InferSchema";
+import OptionalType from "#OptionalType";
+import type Schema from "#Schema";
+export default class SchemaType<S extends Schema> extends GenericType<S, InferSchema<S>, "SchemaType"> {
+    #private;
+    constructor(s: S);
+    optional(): OptionalType<this>;
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+//# sourceMappingURL=SchemaType.d.ts.map

package/lib/private/SchemaType.js

@@ -0,0 +1,63 @@
+import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+import Validated from "#Validated";
+import schema from "#index";
+export default class SchemaType extends GenericType {
+    #schema;
+    constructor(s) {
+        super();
+        this.#schema = s;
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    get name() {
+        return "schema";
+    }
+    validate(x, key) {
+        const s = this.#schema;
+        if (s instanceof Validated) {
+            return s.validate(x, key);
+        }
+        if (Array.isArray(s)) {
+            if (s.length === 1) {
+                if (!Array.isArray(x))
+                    throw new Error("Expected array");
+                return x.map((item) => schema(s[0]).validate(item, key));
+            }
+            else {
+                if (!Array.isArray(x))
+                    throw new Error("Expected tuple");
+                if (x.length !== s.length)
+                    throw new Error("Tuple length mismatch");
+                return s.map((sch, i) => schema(sch).validate(x[i], key));
+            }
+        }
+        if (typeof s === "object" && s !== null) {
+            if (typeof x !== "object" || x === null) {
+                throw new Error("Expected object");
+            }
+            const result = {};
+            for (const k in s) {
+                const r = schema(s[k]).validate(x[k], `.${k}`);
+                // exclude undefined (optionals)
+                if (r !== undefined) {
+                    result[k] = r;
+                }
+            }
+            return result;
+        }
+        if (s === null) {
+            if (x !== null)
+                throw new Error("Expected null");
+            return null;
+        }
+        if (s === undefined) {
+            if (x !== undefined)
+                throw new Error("Expected undefined");
+            return undefined;
+        }
+        throw new Error("Invalid schema structure");
+    }
+}
+//# sourceMappingURL=SchemaType.js.map

package/lib/private/StringType.d.ts

@@ -0,0 +1,8 @@
+import PrimitiveType from "#PrimitiveType";
+import type Validator from "#Validator";
+export default class StringType extends PrimitiveType<string, "StringType"> {
+    constructor(validators?: Validator<string>[]);
+    startsWith(prefix: string): StringType;
+    endsWith(suffix: string): StringType;
+}
+//# sourceMappingURL=StringType.d.ts.map

package/lib/private/StringType.js

@@ -0,0 +1,23 @@
+import PrimitiveType from "#PrimitiveType";
+const starts_with_validator = (prefix) => (x) => {
+    if (!x.startsWith(prefix)) {
+        throw new Error(`"${x}" does not start with "${prefix}"`);
+    }
+};
+const ends_with_validator = (suffix) => (x) => {
+    if (!x.endsWith(suffix)) {
+        throw new Error(`"${x}" does not end with "${suffix}"`);
+    }
+};
+export default class StringType extends PrimitiveType {
+    constructor(validators) {
+        super("string", validators);
+    }
+    startsWith(prefix) {
+        return new StringType([...this.validators, starts_with_validator(prefix)]);
+    }
+    endsWith(suffix) {
+        return new StringType([...this.validators, ends_with_validator(suffix)]);
+    }
+}
+//# sourceMappingURL=StringType.js.map

package/lib/private/SymbolType.d.ts

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

package/lib/private/SymbolType.js

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

package/lib/private/TupleType.d.ts

@@ -0,0 +1,17 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import type InferSchema from "#InferSchema";
+import OptionalType from "#OptionalType";
+import type Schema from "#Schema";
+type InferTuple<T extends Schema[]> = {
+    [K in keyof T]: T[K] extends Schema ? InferSchema<T[K]> : "tuple-never";
+};
+export default class TupleType<T extends Schema[]> extends GenericType<T, InferTuple<T>, "TupleType"> {
+    #private;
+    constructor(members: T);
+    optional(): OptionalType<this>;
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+export {};
+//# sourceMappingURL=TupleType.d.ts.map

package/lib/private/TupleType.js

@@ -0,0 +1,40 @@
+import error from "#error";
+import expected from "#expected";
+import GenericType from "#GenericType";
+import schema from "#index";
+import is_validated_type from "#is_validated_type";
+import OptionalType from "#OptionalType";
+const member_error = (i, key) => {
+    return key === undefined
+        ? `[${i}]`
+        : `${key}[${i}]`;
+};
+export default class TupleType extends GenericType {
+    #members;
+    constructor(members) {
+        super();
+        this.#members = members;
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    get name() {
+        return "tuple";
+    }
+    validate(x, key) {
+        if (!(!!x && Array.isArray(x))) {
+            throw new Error(error(expected("array", x), key));
+        }
+        this.#members.forEach((v, i) => {
+            const validator = is_validated_type(v) ? v : schema(v);
+            validator.validate(x[i], `${member_error(i, key)}`);
+        });
+        x.forEach((v, i) => {
+            const member = this.#members[i];
+            const validator = is_validated_type(member) ? member : schema(member);
+            validator.validate(v, `${member_error(i, key)}`);
+        });
+        return x;
+    }
+}
+//# sourceMappingURL=TupleType.js.map

package/lib/private/Type.d.ts

@@ -0,0 +1,10 @@
+import DefaultType from "#DefaultType";
+import OptionalType from "#OptionalType";
+import Validated from "#Validated";
+import type Printable from "@rcompat/type/Printable";
+export default abstract class Type<Type, Name extends string> extends Validated<Type> implements Printable {
+    optional(): OptionalType<this>;
+    default<const S extends Type>(value: S | (() => S)): DefaultType<this, S>;
+    get Name(): Name;
+}
+//# sourceMappingURL=Type.d.ts.map

package/lib/private/Type.js

@@ -0,0 +1,15 @@
+import DefaultType from "#DefaultType";
+import OptionalType from "#OptionalType";
+import Validated from "#Validated";
+export default class Type extends Validated {
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    get Name() {
+        return undefined;
+    }
+}
+//# sourceMappingURL=Type.js.map

package/lib/private/URLType.d.ts

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

package/lib/private/URLType.js

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

package/lib/private/UintType.d.ts

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

package/lib/private/UintType.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 UintType extends PrimitiveType {
+    constructor() {
+        super("uint");
+    }
+    validate(x, key) {
+        if (!is_int(x) || x < 0) {
+            throw new Error(error(expected("uint", x), key));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=UintType.js.map

package/lib/private/UndefinedType.d.ts

@@ -0,0 +1,7 @@
+import PrimitiveType from "#PrimitiveType";
+type Name = "UndefinedType";
+export default class UndefinedType extends PrimitiveType<undefined, Name> {
+    constructor();
+}
+export {};
+//# sourceMappingURL=UndefinedType.d.ts.map

package/lib/private/UndefinedType.js

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

package/lib/private/UnionType.d.ts

@@ -0,0 +1,18 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import type InferSchema from "#InferSchema";
+import OptionalType from "#OptionalType";
+import type Schema from "#Schema";
+import type TupleToUnion from "@rcompat/type/TupleToUnion";
+type InferUnion<T extends Schema[]> = TupleToUnion<{
+    [K in keyof T]: T[K] extends Schema ? InferSchema<T[K]> : "union-never";
+}>;
+export default class UnionType<T extends Schema[]> extends GenericType<T, InferUnion<T>, "UnionType"> {
+    #private;
+    constructor(types: T);
+    optional(): OptionalType<this>;
+    get name(): string;
+    validate(x: unknown, key?: string): Infer<this>;
+}
+export {};
+//# sourceMappingURL=UnionType.d.ts.map

package/lib/private/UnionType.js

@@ -0,0 +1,63 @@
+import expected from "#expected";
+import GenericType from "#GenericType";
+import schema from "#index";
+import is_validated_type from "#is_validated_type";
+import OptionalType from "#OptionalType";
+import assert from "@rcompat/invariant/assert";
+const error = (message, key) => {
+    return key === undefined
+        ? message
+        : `${key}: ${message}`;
+};
+const print = (type) => {
+    const validated = is_validated_type(type);
+    if (validated) {
+        return type.name;
+    }
+    const type_of = typeof type;
+    if (type_of === "string") {
+        return `"${type}"`;
+    }
+    if (type_of === "bigint") {
+        return `${type}n`;
+    }
+    if (type_of === "object") {
+        return `{ ${Object.entries(type)
+            .map(([name, subtype]) => `${name}: ${print(subtype)}`)
+            .join(", ")} }`;
+    }
+    return type;
+};
+const to_union_string = (types) => `\`${types.map(t => is_validated_type(t) ? t.name : print(t)).join(" | ")}\``;
+export default class UnionType extends GenericType {
+    #types;
+    constructor(types) {
+        assert(types.length > 1, "union type must have at least two members");
+        super();
+        this.#types = types;
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    get name() {
+        return "union";
+    }
+    validate(x, key) {
+        // union validates when any of its members validates
+        const validated = this.#types.some(type => {
+            const validator = is_validated_type(type) ? type : schema(type);
+            try {
+                validator.validate(x, key);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!validated) {
+            throw new Error(error(expected(to_union_string(this.#types), x), key));
+        }
+        return x;
+    }
+}
+//# sourceMappingURL=UnionType.js.map

package/lib/private/Validated.d.ts

@@ -0,0 +1,8 @@
+import ValidatedKey from "#ValidatedKey";
+export default abstract class Validated<StaticType> {
+    get [ValidatedKey](): "ValidatedKey";
+    get infer(): StaticType;
+    abstract get name(): string;
+    abstract validate(x: unknown, key?: string): StaticType;
+}
+//# sourceMappingURL=Validated.d.ts.map

package/lib/private/Validated.js

@@ -0,0 +1,10 @@
+import ValidatedKey from "#ValidatedKey";
+export default class Validated {
+    get [ValidatedKey]() {
+        return "ValidatedKey";
+    }
+    get infer() {
+        return undefined;
+    }
+}
+//# sourceMappingURL=Validated.js.map

package/lib/private/ValidatedKey.d.ts

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

package/lib/private/ValidatedKey.js

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

package/lib/private/Validator.d.ts

@@ -0,0 +1,3 @@
+type Validator<T = unknown> = (x: T) => void;
+export type { Validator as default };
+//# sourceMappingURL=Validator.d.ts.map

package/lib/private/Validator.js

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

package/lib/private/array.d.ts

@@ -0,0 +1,5 @@
+import ArrayType from "#ArrayType";
+import type Validated from "#Validated";
+declare const _default: <const T extends Validated<unknown>>(t: T) => ArrayType<T>;
+export default _default;
+//# sourceMappingURL=array.d.ts.map

package/lib/private/array.js

@@ -0,0 +1,3 @@
+import ArrayType from "#ArrayType";
+export default (t) => new ArrayType(t);
+//# sourceMappingURL=array.js.map

package/lib/private/bigint.d.ts

@@ -0,0 +1,4 @@
+import BigIntType from "#BigIntType";
+declare const _default: BigIntType;
+export default _default;
+//# sourceMappingURL=bigint.d.ts.map

package/lib/private/bigint.js

@@ -0,0 +1,3 @@
+import BigIntType from "#BigIntType";
+export default new BigIntType();
+//# sourceMappingURL=bigint.js.map

package/lib/private/blob.d.ts

@@ -0,0 +1,4 @@
+import BlobType from "#BlobType";
+declare const _default: BlobType;
+export default _default;
+//# sourceMappingURL=blob.d.ts.map

package/lib/private/blob.js

@@ -0,0 +1,3 @@
+import BlobType from "#BlobType";
+export default new BlobType();
+//# sourceMappingURL=blob.js.map

package/lib/private/boolean.d.ts

@@ -0,0 +1,4 @@
+import BooleanType from "#BooleanType";
+declare const _default: BooleanType;
+export default _default;
+//# sourceMappingURL=boolean.d.ts.map

package/lib/private/boolean.js

@@ -0,0 +1,3 @@
+import BooleanType from "#BooleanType";
+export default new BooleanType();
+//# sourceMappingURL=boolean.js.map

package/lib/private/constructor.d.ts

@@ -0,0 +1,5 @@
+import ConstructorType from "#ConstructorType";
+import type AbstractConstructor from "@rcompat/type/AbstractConstructor";
+declare const _default: <const C extends AbstractConstructor>(constructor: C) => ConstructorType<C>;
+export default _default;
+//# sourceMappingURL=constructor.d.ts.map

package/lib/private/constructor.js

@@ -0,0 +1,3 @@
+import ConstructorType from "#ConstructorType";
+export default (constructor) => new ConstructorType(constructor);
+//# sourceMappingURL=constructor.js.map

package/lib/private/date.d.ts

@@ -0,0 +1,4 @@
+import DateType from "#DateType";
+declare const _default: DateType;
+export default _default;
+//# sourceMappingURL=date.d.ts.map

package/lib/private/date.js

@@ -0,0 +1,3 @@
+import DateType from "#DateType";
+export default new DateType();
+//# sourceMappingURL=date.js.map

package/lib/private/error.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (message: string, key?: string) => string;
+export default _default;
+//# sourceMappingURL=error.d.ts.map

package/lib/private/error.js

@@ -0,0 +1,4 @@
+export default (message, key) => key === undefined
+    ? message
+    : `${key}: ${message}`;
+//# sourceMappingURL=error.js.map

package/lib/private/expect.d.ts

@@ -0,0 +1,21 @@
+declare const types: {
+    a: string;
+    b: string;
+    d: string;
+    n: string;
+    s: string;
+    u: string;
+    bt: string;
+    f: string;
+    bb: string;
+    o: string;
+    nl: string;
+    sy: string;
+    ur: string;
+    i: string;
+    ui: string;
+    co: string;
+};
+declare const _default: (type: keyof typeof types, got: unknown, at?: string) => string;
+export default _default;
+//# sourceMappingURL=expect.d.ts.map

package/lib/private/expect.js

@@ -0,0 +1,21 @@
+const types = {
+    a: "array",
+    b: "boolean",
+    d: "date",
+    n: "number",
+    s: "string",
+    u: "undefined",
+    bt: "bigint",
+    f: "file",
+    bb: "blob",
+    o: "object",
+    nl: "null",
+    sy: "symbol",
+    ur: "url",
+    i: "int",
+    ui: "uint",
+    co: "constructor",
+};
+const prefix = (at) => at ? `${at}: ` : "";
+export default (type, got, at = "") => `${prefix(at)}expected ${types[type]}, got \`${got}\` (${typeof got})`;
+//# sourceMappingURL=expect.js.map

package/lib/private/expected.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (type: string, x: unknown) => string;
+export default _default;
+//# sourceMappingURL=expected.d.ts.map

package/lib/private/expected.js

@@ -0,0 +1,2 @@
+export default (type, x) => `expected ${type}, got \`${x?.toString() ?? x}\` (${(typeof x)})`;
+//# sourceMappingURL=expected.js.map

package/lib/private/file.d.ts

@@ -0,0 +1,4 @@
+import FileType from "#FileType";
+declare const _default: FileType;
+export default _default;
+//# sourceMappingURL=file.d.ts.map

package/lib/private/file.js

@@ -0,0 +1,3 @@
+import FileType from "#FileType";
+export default new FileType();
+//# sourceMappingURL=file.js.map

package/lib/private/index.d.ts

@@ -0,0 +1,5 @@
+import type NormalizeSchema from "#NormalizeSchema";
+import type Schema from "#Schema";
+import SchemaType from "#SchemaType";
+export default function schema<const S extends Schema>(s: S): SchemaType<NormalizeSchema<S>>;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -0,0 +1,43 @@
+import array from "#array";
+import constructor from "#constructor";
+import is_validated_type from "#is_validated_type";
+import literal from "#literal";
+import null_type from "#null";
+import SchemaType from "#SchemaType";
+import tuple from "#tuple";
+import undefined_type from "#undefined";
+const is_constructor = (value) => {
+    try {
+        if (typeof value !== "function")
+            return false;
+        new value();
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export default function schema(s) {
+    if (s === null) {
+        return new SchemaType(null_type);
+    }
+    if (s === undefined) {
+        return new SchemaType(undefined_type);
+    }
+    if (typeof s === "string") {
+        return new SchemaType(literal(s));
+    }
+    if (is_constructor(s)) {
+        return new SchemaType(constructor(s));
+    }
+    if (Array.isArray(s)) {
+        if (s.length === 1 && is_validated_type(s[0])) {
+            return new SchemaType(array(s[0]));
+        }
+        else {
+            return new SchemaType(tuple(...s));
+        }
+    }
+    return new SchemaType(s);
+}
+//# sourceMappingURL=index.js.map

package/lib/private/int.d.ts

@@ -0,0 +1,4 @@
+import IntType from "#IntType";
+declare const _default: IntType;
+export default _default;
+//# sourceMappingURL=int.d.ts.map

package/lib/private/int.js

@@ -0,0 +1,3 @@
+import IntType from "#IntType";
+export default new IntType();
+//# sourceMappingURL=int.js.map

package/lib/private/is-int.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (n: unknown) => n is number | bigint;
+export default _default;
+//# sourceMappingURL=is-int.d.ts.map

package/lib/private/is-int.js

@@ -0,0 +1,5 @@
+export default (n) => {
+    const type = typeof n;
+    return type === "number" && Number.isInteger(n) || type === "bigint";
+};
+//# sourceMappingURL=is-int.js.map

package/lib/private/is_validated_type.d.ts

@@ -0,0 +1,4 @@
+import type Validated from "#Validated";
+declare const _default: (x: unknown) => x is Validated<unknown>;
+export default _default;
+//# sourceMappingURL=is_validated_type.d.ts.map

package/lib/private/is_validated_type.js

@@ -0,0 +1,5 @@
+import ValidatedKey from "#ValidatedKey";
+export default (x) => {
+    return !!x && typeof x === "object" && ValidatedKey in x;
+};
+//# sourceMappingURL=is_validated_type.js.map

package/lib/private/literal.d.ts

@@ -0,0 +1,5 @@
+import LiteralType from "#LiteralType";
+type Literal = string;
+declare const _default: <T extends Literal>(t: T) => LiteralType<T>;
+export default _default;
+//# sourceMappingURL=literal.d.ts.map

package/lib/private/literal.js

@@ -0,0 +1,3 @@
+import LiteralType from "#LiteralType";
+export default (t) => new LiteralType(t);
+//# sourceMappingURL=literal.js.map