pema 0.1.0 → 0.2.1

package/lib/private/u8.js

@@ -0,0 +1,6 @@
+import UintType from "#UintType";
+import range from "#validator/range";
+const from = 0;
+const to = 2 ** 8 - 1;
+export default new UintType("u8", [range(from, to)]);
+//# sourceMappingURL=u8.js.map

package/lib/private/uint.d.ts

@@ -1,4 +1,2 @@
-import UintType from "#UintType";
-declare const _default: UintType;
-export default _default;
+export { default } from "#u32";
 //# sourceMappingURL=uint.d.ts.map

package/lib/private/uint.js

@@ -1,3 +1,2 @@
-import UintType from "#UintType";
-export default new UintType();
+export { default } from "#u32";
 //# sourceMappingURL=uint.js.map

package/lib/private/union.d.ts

@@ -1,9 +1,10 @@
-import UnionType from "#UnionType";
-import type Schema from "#Schema";
 import type NormalizeSchema from "#NormalizeSchema";
-type NormalizeSchemas<T extends Schema[]> = {
+import type Schema from "#Schema";
+import UnionType from "#UnionType";
+type NormalizeArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
-declare const _default: <const T extends Schema[]>(...types: T) => UnionType<NormalizeSchemas<T>>;
-export default _default;
+export default function union(): UnionType<[]>;
+export default function union<const T extends Schema[]>(...types: T): UnionType<NormalizeArray<T>>;
+export {};
 //# sourceMappingURL=union.d.ts.map

package/lib/private/union.js

@@ -1,3 +1,6 @@
 import UnionType from "#UnionType";
-export default (...types) => new UnionType(types);
+import normalize from "#normalize";
+export default function union(...types) {
+    return new UnionType(types.map(normalize));
+}
 //# sourceMappingURL=union.js.map

package/lib/private/unknown.d.ts

@@ -0,0 +1,7 @@
+import UnknownType from "#UnknownType";
+/**
+* Value is an unknown type.
+*/
+declare const _default: UnknownType;
+export default _default;
+//# sourceMappingURL=unknown.d.ts.map

package/lib/private/unknown.js

@@ -0,0 +1,6 @@
+import UnknownType from "#UnknownType";
+/**
+* Value is an unknown type.
+*/
+export default new UnknownType();
+//# sourceMappingURL=unknown.js.map

package/lib/private/validator/email.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../Validator.js").default<string>;
+export default _default;
+//# sourceMappingURL=email.d.ts.map

package/lib/private/validator/email.js

@@ -0,0 +1,4 @@
+import regex from "#validator/regex";
+const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+export default regex(email, x => `"${x}" is not a valid email`);
+//# sourceMappingURL=email.js.map

package/lib/private/validator/ends-with.d.ts

@@ -0,0 +1,4 @@
+import type Validator from "#Validator";
+declare const _default: (suffix: string) => Validator<string>;
+export default _default;
+//# sourceMappingURL=ends-with.d.ts.map

package/lib/private/validator/ends-with.js

@@ -0,0 +1,11 @@
+import ParseError from "#ParseError";
+export default (suffix) => (x) => {
+    if (!x.endsWith(suffix)) {
+        throw new ParseError([{
+                input: x,
+                message: `"${x}" does not end with "${suffix}"`,
+                path: "",
+            }]);
+    }
+};
+//# sourceMappingURL=ends-with.js.map

package/lib/private/validator/f32.d.ts

@@ -0,0 +1,2 @@
+export default function f32(x: number): void;
+//# sourceMappingURL=f32.d.ts.map

package/lib/private/validator/f32.js

@@ -0,0 +1,11 @@
+import ParseError from "#ParseError";
+export default function f32(x) {
+    if (x !== new Float32Array([x])[0]) {
+        throw new ParseError([{
+                input: x,
+                message: `${x} is not a 32-bit float`,
+                path: "",
+            }]);
+    }
+}
+//# sourceMappingURL=f32.js.map

package/lib/private/validator/integer.d.ts

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

package/lib/private/validator/integer.js

@@ -0,0 +1,12 @@
+import ParseError from "#ParseError";
+import integer from "@rcompat/is/integer";
+export default (x) => {
+    if (!integer(x)) {
+        throw new ParseError([{
+                input: x,
+                message: `${x} is not an integer`,
+                path: "",
+            }]);
+    }
+};
+//# sourceMappingURL=integer.js.map

package/lib/private/validator/isotime.d.ts

@@ -0,0 +1,2 @@
+export default function isotime(x: string): void;
+//# sourceMappingURL=isotime.d.ts.map

package/lib/private/validator/isotime.js

@@ -0,0 +1,30 @@
+import ParseError from "#ParseError";
+import regex from "#validator/regex";
+const ISOTIME = /^T?(?<hour>\d{2}):?(?<minute>\d{2}):?(?<second>\d{2})$/u;
+const RANGE = {
+    hour: { max: 23, min: 0 },
+    minute: { max: 59, min: 0 },
+    second: { max: 60, min: 0 },
+};
+export default function isotime(x) {
+    // check format
+    regex(ISOTIME, y => `"${y}" is not a valid ISO time`)(x);
+    // check range
+    const match = ISOTIME.exec(x);
+    const g = match.groups;
+    const h = Number(g.hour);
+    const m = Number(g.minute);
+    const s = Number(g.second);
+    const inRange = h >= RANGE.hour.min && h <= RANGE.hour.max &&
+        m >= RANGE.minute.min && m <= RANGE.minute.max &&
+        s >= RANGE.second.min && s <= RANGE.second.max;
+    if (!inRange) {
+        throw new ParseError([{
+                input: x,
+                message: `"${x}" is not a valid ISO time`,
+                path: "",
+            }]);
+    }
+}
+;
+//# sourceMappingURL=isotime.js.map

package/lib/private/validator/length.d.ts

@@ -0,0 +1,5 @@
+import type Validator from "#Validator";
+type Input = string | unknown[];
+export default function length(from: number, to: number): Validator<Input>;
+export {};
+//# sourceMappingURL=length.d.ts.map

package/lib/private/validator/length.js

@@ -0,0 +1,29 @@
+import fail from "#error/fail";
+import schemafail from "#error/schemafail";
+import ParseError from "#ParseError";
+import isFinite from "@rcompat/is/finite";
+export default function length(from, to) {
+    if (!isFinite(from) || !isFinite(to)) {
+        throw schemafail("length: {0} and {1} must be finite numbers", from, to);
+    }
+    if (from < 0 || to < 0) {
+        throw schemafail("length: {0} and {1} must be positive", from, to);
+    }
+    if (from > to) {
+        throw schemafail("length: {0} must be lower than {1}", from, to);
+    }
+    return (x) => {
+        if (typeof x !== "string" && !Array.isArray(x)) {
+            throw fail(x, "invalid type");
+        }
+        if (x.length < from || x.length > to) {
+            throw new ParseError([{
+                    input: x,
+                    message: "length out of range",
+                    path: "",
+                }]);
+        }
+    };
+}
+;
+//# sourceMappingURL=length.js.map

package/lib/private/validator/max.d.ts

@@ -0,0 +1,6 @@
+import type Validator from "#Validator";
+type Limit = bigint | number;
+type Input = bigint | number | string | unknown[];
+export default function max(limit: Limit): Validator<Input>;
+export {};
+//# sourceMappingURL=max.d.ts.map

package/lib/private/validator/max.js

@@ -0,0 +1,37 @@
+import fail from "#error/fail";
+import schemafail from "#error/schemafail";
+import isFinite from "@rcompat/is/finite";
+export default function max(limit) {
+    // validate limit once
+    if (typeof limit === "number") {
+        if (!isFinite(limit)) {
+            throw schemafail("max: limit {0} must be a finite number", limit);
+        }
+        return (x) => {
+            if (typeof x === "number") {
+                if (x > limit)
+                    throw fail(x, `${x} is greater than max (${limit})`);
+            }
+            else if (typeof x === "string" || Array.isArray(x)) {
+                if (x.length > limit) {
+                    const unit = typeof x === "string" ? "characters" : "items";
+                    throw fail(x, `max ${limit} ${unit}`);
+                }
+            }
+            else {
+                throw fail(x, "invalid type");
+            }
+        };
+    }
+    // bigint
+    return (x) => {
+        if (typeof x === "bigint") {
+            if (x > limit)
+                throw fail(x, `${x} is greater than max (${limit})`);
+        }
+        else {
+            throw fail(x, "invalid type");
+        }
+    };
+}
+//# sourceMappingURL=max.js.map

package/lib/private/validator/min.d.ts

@@ -0,0 +1,6 @@
+import type Validator from "#Validator";
+type Limit = bigint | number;
+type Input = bigint | number | string | unknown[];
+export default function min(limit: Limit): Validator<Input>;
+export {};
+//# sourceMappingURL=min.d.ts.map

package/lib/private/validator/min.js

@@ -0,0 +1,37 @@
+import fail from "#error/fail";
+import schemafail from "#error/schemafail";
+import isFinite from "@rcompat/is/finite";
+export default function min(limit) {
+    // validate limit once
+    if (typeof limit === "number") {
+        if (!isFinite(limit)) {
+            throw schemafail("max: limit {0} must be a finite number", limit);
+        }
+        return (x) => {
+            if (typeof x === "number") {
+                if (x < limit)
+                    throw fail(x, `${x} is lower than min (${limit})`);
+            }
+            else if (typeof x === "string" || Array.isArray(x)) {
+                if (x.length < limit) {
+                    const unit = typeof x === "string" ? "characters" : "items";
+                    throw fail(x, `min ${limit} ${unit}`);
+                }
+            }
+            else {
+                throw fail(x, "invalid type");
+            }
+        };
+    }
+    // bigint
+    return (x) => {
+        if (typeof x === "bigint") {
+            if (x < limit)
+                throw fail(x, `${x} is lower than min (${limit})`);
+        }
+        else {
+            throw fail(x, "invalid type");
+        }
+    };
+}
+//# sourceMappingURL=min.js.map

package/lib/private/validator/port.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (port: number) => void;
+export default _default;
+//# sourceMappingURL=port.d.ts.map

package/lib/private/validator/port.js

@@ -0,0 +1,15 @@
+import ParseError from "#ParseError";
+// 1000
+const min = 2 ** 10;
+// 65535
+const max = 2 ** 16 - 1;
+export default (port) => {
+    if (port < min || port > max) {
+        throw new ParseError([{
+                input: port,
+                message: `${port} out of port range (${min} - ${max})`,
+                path: "",
+            }]);
+    }
+};
+//# sourceMappingURL=port.js.map

package/lib/private/validator/range.d.ts

@@ -0,0 +1,3 @@
+import type Validator from "#Validator";
+export default function range<From extends bigint | number, To extends From>(from: From, to: To): Validator<From>;
+//# sourceMappingURL=range.d.ts.map

package/lib/private/validator/range.js

@@ -0,0 +1,22 @@
+import ParseError from "#ParseError";
+import isFinite from "@rcompat/is/finite";
+const fail = (input, msg) => new ParseError([{ input, message: msg, path: "" }]);
+export default function range(from, to) {
+    if (!isFinite(from) || !isFinite(to)) {
+        throw new TypeError("range(): from and to must be finite numbers");
+    }
+    return (x) => {
+        if (typeof x !== "number" && typeof x !== "bigint") {
+            throw fail(x, "invalid type");
+        }
+        if (x < from || x > to) {
+            throw new ParseError([{
+                    input: x,
+                    message: `${x} is out of range`,
+                    path: "",
+                }]);
+        }
+    };
+}
+;
+//# sourceMappingURL=range.js.map

package/lib/private/validator/regex.d.ts

@@ -0,0 +1,5 @@
+import type Validator from "#Validator";
+type ErrorFunction = (x: string) => string;
+export default function validateRegex(regex: RegExp, error?: ErrorFunction): Validator<string>;
+export {};
+//# sourceMappingURL=regex.d.ts.map

package/lib/private/validator/regex.js

@@ -0,0 +1,15 @@
+import ParseError from "#ParseError";
+export default function validateRegex(regex, error) {
+    return (x) => {
+        if (!regex.test(x)) {
+            const message = (error ?? ((y) => `"${y}" is not a valid ${String(regex)}`))(x);
+            throw new ParseError([{
+                    input: x,
+                    message,
+                    path: "", // root; the calling type should rebase if needed
+                }]);
+        }
+    };
+}
+;
+//# sourceMappingURL=regex.js.map

package/lib/private/validator/starts-with.d.ts

@@ -0,0 +1,4 @@
+import type Validator from "#Validator";
+declare const _default: (prefix: string) => Validator<string>;
+export default _default;
+//# sourceMappingURL=starts-with.d.ts.map

package/lib/private/validator/starts-with.js

@@ -0,0 +1,11 @@
+import ParseError from "#ParseError";
+export default (prefix) => (x) => {
+    if (!x.startsWith(prefix)) {
+        throw new ParseError([{
+                input: x,
+                message: `"${x}" does not start with "${prefix}"`,
+                path: "",
+            }]);
+    }
+};
+//# sourceMappingURL=starts-with.js.map

package/lib/private/validator/unique-by.d.ts

@@ -0,0 +1,2 @@
+export default function uniqueBy<T, K extends PropertyKey>(selector: (item: T) => K): (array: Array<T>) => void;
+//# sourceMappingURL=unique-by.d.ts.map

package/lib/private/validator/unique-by.js

@@ -0,0 +1,23 @@
+import ParseError from "#ParseError";
+import join from "#path/join";
+function message(k, i, first) {
+    return `duplicate key "${String(k)}" at index ${i} (first ${first})`;
+}
+export default function uniqueBy(selector) {
+    return (array) => {
+        const seen = new Map();
+        for (let i = 0; i < array.length; i++) {
+            const k = selector(array[i]);
+            if (seen.has(k)) {
+                const first = seen.get(k);
+                throw new ParseError([{
+                        input: array,
+                        message: message(k, i, first),
+                        path: join("", i),
+                    }]);
+            }
+            seen.set(k, i);
+        }
+    };
+}
+//# sourceMappingURL=unique-by.js.map

package/lib/private/validator/unique-with.d.ts

@@ -0,0 +1,2 @@
+export default function uniqueWith<T>(equals: (a: T, b: T) => boolean): (array: Array<T>) => void;
+//# sourceMappingURL=unique-with.d.ts.map

package/lib/private/validator/unique-with.js

@@ -0,0 +1,18 @@
+import ParseError from "#ParseError";
+import join from "#path/join";
+export default function uniqueWith(equals) {
+    return (array) => {
+        for (let i = 0; i < array.length; i++) {
+            for (let j = 0; j < i; j++) {
+                if (equals(array[i], array[j])) {
+                    throw new ParseError([{
+                            input: array,
+                            message: `items at ${j} and ${i} considered equal`,
+                            path: join("", i),
+                        }]);
+                }
+            }
+        }
+    };
+}
+//# sourceMappingURL=unique-with.js.map

package/lib/private/validator/unique.d.ts

@@ -0,0 +1,2 @@
+export default function unique<T>(array: Array<T>): void;
+//# sourceMappingURL=unique.d.ts.map

package/lib/private/validator/unique.js

@@ -0,0 +1,19 @@
+import ParseError from "#ParseError";
+import join from "#path/join";
+export default function unique(array) {
+    const seen = new Map();
+    for (let i = 0; i < array.length; i++) {
+        const v = array[i];
+        if (seen.has(v)) {
+            const first = seen.get(v);
+            // key = current duplicate index
+            throw new ParseError([{
+                    input: array,
+                    message: `duplicate value at index ${i} (first seen at ${first})`,
+                    path: join("", i),
+                }]);
+        }
+        seen.set(v, i);
+    }
+}
+//# sourceMappingURL=unique.js.map

package/lib/private/validator/uuid.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../Validator.js").default<string>;
+export default _default;
+//# sourceMappingURL=uuid.d.ts.map

package/lib/private/validator/uuid.js

@@ -0,0 +1,4 @@
+import regex from "#validator/regex";
+const uuid = /^[^\W_]{8}-[^\W_]{4}-[^\W_]{4}-[^\W_]{4}-[^\W_]{12}$/u;
+export default regex(uuid, x => `"${x}" is not a valid UUID`);
+//# sourceMappingURL=uuid.js.map

package/lib/private/validator/values.d.ts

@@ -0,0 +1,4 @@
+import type Validator from "#Validator";
+import type Dict from "@rcompat/type/Dict";
+export default function values<T>(input: Dict<T>): Validator<T>;
+//# sourceMappingURL=values.d.ts.map

package/lib/private/validator/values.js

@@ -0,0 +1,14 @@
+import ParseError from "#ParseError";
+export default function values(input) {
+    const allowed = Object.values(input).map(v => String(v)).join(", ");
+    return (x) => {
+        if (!Object.values(input).includes(x)) {
+            throw new ParseError([{
+                    input: x,
+                    message: `"${x}" not in given list of values (${allowed})`,
+                    path: "",
+                }]);
+        }
+    };
+}
+//# sourceMappingURL=values.js.map

package/lib/public/DataType.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#DataType";
+//# sourceMappingURL=DataType.d.ts.map

package/lib/public/DataType.js

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

package/lib/public/Id.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#Id";
+//# sourceMappingURL=Id.d.ts.map

package/lib/public/Id.js

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

package/lib/public/InferStore.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#InferStore";
+//# sourceMappingURL=InferStore.d.ts.map

package/lib/public/InferStore.js

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

package/lib/public/InferStoreOut.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#InferStoreOut";
+//# sourceMappingURL=InferStoreOut.d.ts.map

package/lib/public/InferStoreOut.js

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

package/lib/public/Issue.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#Issue";
+//# sourceMappingURL=Issue.d.ts.map

package/lib/public/Issue.js

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

package/lib/public/JSONPayload.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#json/JSONPayload";
+//# sourceMappingURL=JSONPayload.d.ts.map

package/lib/public/JSONPayload.js

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

package/lib/public/ParseError.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#ParseError";
+//# sourceMappingURL=ParseError.d.ts.map

package/lib/public/ParseError.js

@@ -0,0 +1,2 @@
+export { default } from "#ParseError";
+//# sourceMappingURL=ParseError.js.map

package/lib/public/Serialized.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#Serialized";
+//# sourceMappingURL=Serialized.d.ts.map

package/lib/public/Serialized.js

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

package/lib/public/StoreId.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#StoreId";
+//# sourceMappingURL=StoreId.d.ts.map

package/lib/public/StoreId.js

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

package/lib/public/StoreSchema.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#StoreSchema";
+//# sourceMappingURL=StoreSchema.d.ts.map

package/lib/public/StoreSchema.js

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

package/lib/public/StoreType.d.ts

@@ -0,0 +1,3 @@
+export { default as Serialized } from "#Serialized";
+export { default } from "#StoreType";
+//# sourceMappingURL=StoreType.d.ts.map

package/lib/public/StoreType.js

@@ -0,0 +1,2 @@
+export { default } from "#StoreType";
+//# sourceMappingURL=StoreType.js.map

package/lib/public/array.d.ts

@@ -0,0 +1,3 @@
+export { default } from "#array";
+export { default as ArrayType } from "#ArrayType";
+//# sourceMappingURL=array.d.ts.map

package/lib/public/array.js

@@ -0,0 +1,3 @@
+export { default } from "#array";
+export { default as ArrayType } from "#ArrayType";
+//# sourceMappingURL=array.js.map

package/lib/public/bigint.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#bigint";
+//# sourceMappingURL=bigint.d.ts.map

package/lib/public/bigint.js

@@ -0,0 +1,2 @@
+export { default } from "#bigint";
+//# sourceMappingURL=bigint.js.map

package/lib/public/biguint.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#biguint";
+//# sourceMappingURL=biguint.d.ts.map

package/lib/public/biguint.js

@@ -0,0 +1,2 @@
+export { default } from "#biguint";
+//# sourceMappingURL=biguint.js.map

package/lib/public/boolean.d.ts

@@ -1,2 +1,3 @@
 export { default } from "#boolean";
+export { default as BooleanType } from "#BooleanType";
 //# sourceMappingURL=boolean.d.ts.map

package/lib/public/boolean.js

@@ -1,2 +1,3 @@
 export { default } from "#boolean";
+export { default as BooleanType } from "#BooleanType";
 //# sourceMappingURL=boolean.js.map