pema 0.4.0 → 0.6.0

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

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

package/lib/private/validator/integer.js

@@ -1,12 +1,8 @@
-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: "",
-            }]);
-    }
-};
+import E from "#errors";
+import is from "@rcompat/is";
+export default function integer(x) {
+    if (!is.int(x))
+        throw E.invalid_type(x, `${x} is not an integer`);
+}
+;
 //# sourceMappingURL=integer.js.map

package/lib/private/validator/isotime.js

@@ -1,4 +1,4 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 import regex from "#validator/regex";
 const ISOTIME = /^T?(?<hour>\d{2}):?(?<minute>\d{2}):?(?<second>\d{2})$/u;
 const RANGE = {
@@ -6,25 +6,23 @@ const RANGE = {
     minute: { max: 59, min: 0 },
     second: { max: 60, min: 0 },
 };
+function validator(s) {
+    return `"${s}" is not a valid ISO time`;
+}
 export default function isotime(x) {
     // check format
-    regex(ISOTIME, y => `"${y}" is not a valid ISO time`)(x);
+    regex(ISOTIME, validator)(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 &&
+    const in_range = 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: "",
-            }]);
-    }
+    if (!in_range)
+        throw E.out_of_range(x, validator(x));
 }
 ;
 //# sourceMappingURL=isotime.js.map

package/lib/private/validator/length.js

@@ -1,27 +1,19 @@
-import fail from "#error/fail";
-import schemafail from "#error/schemafail";
-import ParseError from "#ParseError";
-import isFinite from "@rcompat/is/finite";
+import E from "#errors";
+import S from "#schema-errors";
+import is from "@rcompat/is";
 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);
-    }
+    if (!is.finite(from) || !is.finite(to))
+        throw S.length_not_finite(from, to);
+    if (from < 0 || to < 0)
+        throw S.length_not_positive(from, to);
+    if (from > to)
+        throw S.length_from_exceeds_to(from, to);
     return (x) => {
-        if (typeof x !== "string" && !Array.isArray(x)) {
-            throw fail(x, "invalid type");
+        if (!is.string(x) && !is.array(x)) {
+            throw E.invalid_type(x, "string or array");
         }
         if (x.length < from || x.length > to) {
-            throw new ParseError([{
-                    input: x,
-                    message: "length out of range",
-                    path: "",
-                }]);
+            throw E.out_of_range(x, "length out of range");
         }
     };
 }

package/lib/private/validator/max.js

@@ -1,36 +1,35 @@
-import fail from "#error/fail";
-import schemafail from "#error/schemafail";
-import isFinite from "@rcompat/is/finite";
+import E from "#errors";
+import S from "#schema-errors";
+import is from "@rcompat/is";
 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);
-        }
+    if (is.number(limit)) {
+        if (!is.finite(limit))
+            throw S.max_limit_not_finite(limit);
         return (x) => {
-            if (typeof x === "number") {
+            if (is.number(x)) {
                 if (x > limit)
-                    throw fail(x, `${x} is greater than max (${limit})`);
+                    throw E.too_large(x, `${x} is greater than ${limit}`);
             }
-            else if (typeof x === "string" || Array.isArray(x)) {
+            else if (is.string(x) || is.array(x)) {
                 if (x.length > limit) {
-                    const unit = typeof x === "string" ? "characters" : "items";
-                    throw fail(x, `max ${limit} ${unit}`);
+                    const unit = is.string(x) ? "characters" : "items";
+                    throw E.too_large(x, `max ${limit} ${unit}`);
                 }
             }
             else {
-                throw fail(x, "invalid type");
+                throw E.invalid_type(x, "number");
             }
         };
     }
     // bigint
     return (x) => {
-        if (typeof x === "bigint") {
+        if (is.bigint(x)) {
             if (x > limit)
-                throw fail(x, `${x} is greater than max (${limit})`);
+                throw E.too_large(x, `${x} is greater than ${limit}`);
         }
         else {
-            throw fail(x, "invalid type");
+            throw E.invalid_type(x, "bigint");
         }
     };
 }

package/lib/private/validator/min.js

@@ -1,36 +1,35 @@
-import fail from "#error/fail";
-import schemafail from "#error/schemafail";
-import isFinite from "@rcompat/is/finite";
+import E from "#errors";
+import S from "#schema-errors";
+import is from "@rcompat/is";
 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);
-        }
+    if (is.number(limit)) {
+        if (!is.finite(limit))
+            throw S.min_limit_not_finite(limit);
         return (x) => {
-            if (typeof x === "number") {
+            if (is.number(x)) {
                 if (x < limit)
-                    throw fail(x, `${x} is lower than min (${limit})`);
+                    throw E.too_small(x, `${x} is lower than ${limit}`);
             }
-            else if (typeof x === "string" || Array.isArray(x)) {
+            else if (is.string(x) || is.array(x)) {
                 if (x.length < limit) {
-                    const unit = typeof x === "string" ? "characters" : "items";
-                    throw fail(x, `min ${limit} ${unit}`);
+                    const unit = is.string(x) ? "characters" : "items";
+                    throw E.too_small(x, `min ${limit} ${unit}`);
                 }
             }
             else {
-                throw fail(x, "invalid type");
+                throw E.invalid_type(x, "number");
             }
         };
     }
     // bigint
     return (x) => {
-        if (typeof x === "bigint") {
+        if (is.bigint(x)) {
             if (x < limit)
-                throw fail(x, `${x} is lower than min (${limit})`);
+                throw E.too_small(x, `${x} is lower than ${limit}`);
         }
         else {
-            throw fail(x, "invalid type");
+            throw E.invalid_type(x, "bigint");
         }
     };
 }

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

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

package/lib/private/validator/port.js

@@ -1,15 +1,12 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 // 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: "",
-            }]);
+export default function port(given) {
+    if (given < min || given > max) {
+        throw E.out_of_range(given, `${given} out of port range (${min} - ${max})`);
     }
-};
+}
+;
 //# sourceMappingURL=port.js.map

package/lib/private/validator/range.js

@@ -1,21 +1,15 @@
-import ParseError from "#ParseError";
-import isFinite from "@rcompat/is/finite";
-const fail = (input, msg) => new ParseError([{ input, message: msg, path: "" }]);
+import E from "#errors";
+import is from "@rcompat/is";
 export default function range(from, to) {
-    if (!isFinite(from) || !isFinite(to)) {
+    if (!is.finite(from) || !is.finite(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: "",
-                }]);
+        if (!is.number(x) && !is.bigint(x)) {
+            throw E.invalid_type(x, "number or bigint");
         }
+        if (x < from || x > to)
+            throw E.out_of_range(x, `${x} is out of range`);
     };
 }
 ;

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

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

package/lib/private/validator/regex.js

@@ -1,13 +1,9 @@
-import ParseError from "#ParseError";
-export default function validateRegex(regex, error) {
+import E from "#errors";
+export default function regex(format, 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
-                }]);
+        if (!format.test(x)) {
+            const message = (error ?? ((y) => `"${y}" is not a valid ${String(format)}`))(x);
+            throw E.invalid_format(x, message);
         }
     };
 }

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

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

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

@@ -1,11 +1,9 @@
-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: "",
-            }]);
-    }
-};
+import E from "#errors";
+export default function starts_with(prefix) {
+    return (x) => {
+        if (!x.startsWith(prefix)) {
+            throw E.invalid_format(x, `"${x}" does not start with "${prefix}"`);
+        }
+    };
+}
 //# sourceMappingURL=starts-with.js.map

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

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

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

@@ -1,22 +1,16 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 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) {
+export default function unique_by(select) {
     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),
-                    }]);
+            const value = array[i];
+            const key = select(value);
+            if (seen.has(key)) {
+                const first = seen.get(key);
+                throw E.duplicate(array, `duplicate value at index ${i} (first seen at ${first})`, join("", i));
             }
-            seen.set(k, i);
+            seen.set(key, i);
         }
     };
 }

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

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

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

@@ -1,15 +1,11 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 import join from "#path/join";
-export default function uniqueWith(equals) {
+export default function unique(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),
-                        }]);
+                    throw E.duplicate(array, `items at ${j} and ${i} considered equal`, join("", i));
                 }
             }
         }

package/lib/private/validator/unique.js

@@ -1,4 +1,4 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 import join from "#path/join";
 export default function unique(array) {
     const seen = new Map();
@@ -7,11 +7,7 @@ export default function unique(array) {
         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),
-                }]);
+            throw E.duplicate(array, `duplicate value at index ${i} (first seen at ${first})`, join("", i));
         }
         seen.set(v, i);
     }

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

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

package/lib/private/validator/values.js

@@ -1,13 +1,10 @@
-import ParseError from "#ParseError";
+import E from "#errors";
 export default function values(input) {
-    const allowed = Object.values(input).map(v => String(v)).join(", ");
+    const input_values = Object.values(input);
+    const allowed = input_values.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: "",
-                }]);
+        if (!input_values.includes(x)) {
+            throw E.not_in_set(x, `"${x}" not in given list of values (${allowed})`);
         }
     };
 }

package/lib/public/StoreType.d.ts

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

package/lib/public/index.d.ts

@@ -1,11 +1,3 @@
-export { default as ConstructorType } from "#ConstructorType";
-export { default as DefaultType } from "#DefaultType";
+export type * from "#index";
 export { default } from "#index";
-export { default as LiteralType } from "#LiteralType";
-export { default as ObjectType } from "#ObjectType";
-export { default as OptionalType } from "#OptionalType";
-export { default as PureType } from "#PureType";
-export { default as TupleType } from "#TupleType";
-export { default as UndefinedType } from "#UndefinedType";
-export { default as ArrayType } from "#ArrayType";
 //# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -1,11 +1,2 @@
-export { default as ConstructorType } from "#ConstructorType";
-export { default as DefaultType } from "#DefaultType";
 export { default } from "#index";
-export { default as LiteralType } from "#LiteralType";
-export { default as ObjectType } from "#ObjectType";
-export { default as OptionalType } from "#OptionalType";
-export { default as PureType } from "#PureType";
-export { default as TupleType } from "#TupleType";
-export { default as UndefinedType } from "#UndefinedType";
-export { default as ArrayType } from "#ArrayType";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,40 +1,43 @@
 {
   "name": "pema",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Primate schema validation",
   "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
   "license": "MIT",
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/primate-run/primate",
     "directory": "packages/pema"
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
   "dependencies": {
-    "@rcompat/assert": "^0.3.1",
-    "@rcompat/cli": "^0.11.3",
-    "@rcompat/is": "^0.1.4",
-    "@rcompat/record": "^0.9.1"
+    "@rcompat/assert": "^0.8.1",
+    "@rcompat/cli": "^0.18.1",
+    "@rcompat/error": "^0.3.1",
+    "@rcompat/is": "^0.6.1"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.11.1"
   },
-  "type": "module",
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
-      "apekit": "./src/public/index.ts",
+      "@primate/source": "./src/public/index.ts",
       "default": "./lib/public/index.js"
     },
     "./*": {
-      "apekit": "./src/public/*.ts",
+      "@primate/source": "./src/public/*.ts",
       "default": "./lib/public/*.js"
     }
   },
@@ -43,6 +46,6 @@
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "test": "npm run build && npx proby"
+    "test": "npx proby"
   }
 }

package/lib/private/DecrementDepth.d.ts

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

package/lib/private/DecrementDepth.js

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

package/lib/private/InferSchema.d.ts

@@ -1,20 +0,0 @@
-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 UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
-type InferSchema<S, Depth extends number = 3> = [
-    Depth
-] 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<{
-    [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

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

package/lib/private/PrimaryType.d.ts

@@ -1,14 +0,0 @@
-import type Infer from "#Infer";
-import type ParseOptions from "#ParseOptions";
-import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-export default class PrimaryType extends PrimitiveType<string | undefined, "PrimaryType"> implements Storeable<"primary"> {
-    get name(): "primary";
-    get datatype(): "primary";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
-    toJSON(): {
-        type: "primary";
-        datatype: "primary";
-    };
-}
-//# sourceMappingURL=PrimaryType.d.ts.map

package/lib/private/PrimaryType.js

@@ -1,26 +0,0 @@
-import error from "#error";
-import ParseError from "#ParseError";
-import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-export default class PrimaryType extends PrimitiveType {
-    get name() {
-        return "primary";
-    }
-    get datatype() {
-        return "primary";
-    }
-    parse(x, options = {}) {
-        // the primary type is an optional ype
-        if (x === undefined) {
-            return x;
-        }
-        if (typeof x !== "string") {
-            throw new ParseError(error(this.name, x, options));
-        }
-        return x;
-    }
-    toJSON() {
-        return Storeable.serialize(this);
-    }
-}
-//# sourceMappingURL=PrimaryType.js.map

package/lib/private/SchemaError.d.ts

@@ -1,4 +0,0 @@
-export default class SchemaError extends Error {
-    constructor(message: string, ...params: unknown[]);
-}
-//# sourceMappingURL=SchemaError.d.ts.map

package/lib/private/SchemaError.js

@@ -1,8 +0,0 @@
-import mark from "@rcompat/cli/mark";
-export default class SchemaError extends Error {
-    constructor(message, ...params) {
-        super(mark(message, ...params));
-    }
-}
-;
-//# sourceMappingURL=SchemaError.js.map

package/lib/private/error/fail.d.ts

@@ -1,3 +0,0 @@
-import ParseError from "#ParseError";
-export default function fail(input: unknown, msg: string): ParseError;
-//# sourceMappingURL=fail.d.ts.map