pema 0.9.2 → 0.11.0

package/lib/private/PrimitiveType.d.ts

@@ -12,6 +12,7 @@ export default abstract class PrimitiveType<StaticType, Name extends string> ext
     get options(): ParseOptions<unknown>;
     get validators(): Validator<StaticType>[];
     with(next: Next<StaticType>): this;
+    check(predicate: (value: StaticType) => boolean, message: string): this;
     parse(u: unknown, options?: ParseOptions<StaticType>): Infer<this>;
 }
 export {};

package/lib/private/PrimitiveType.js

@@ -24,6 +24,14 @@ export default class PrimitiveType extends Type {
         const Constructor = this.constructor;
         return new Constructor([...this.#validators, ...next.validators ?? []], { ...this.#options, ...next.options ?? {} });
     }
+    check(predicate, message) {
+        return this.with({
+            validators: [value => {
+                    if (!predicate(value))
+                        throw E.invalid_format(value, message);
+                }],
+        });
+    }
     parse(u, options = {}) {
         const x = resolve(u);
         // hotpath: avoid object spread when possible

package/lib/private/StringType.d.ts

@@ -1,19 +1,36 @@
+import type Infer from "#Infer";
+import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
+import type MessageOptions from "#validator/MessageOptions";
+type Transform = (value: string) => string;
+type Next = {
+    options?: ParseOptions;
+    transforms?: Transform[];
+    validators?: ((value: string) => void)[];
+};
 export default class StringType extends PrimitiveType<string, "StringType"> implements Storable<"string"> {
+    #private;
+    constructor(validators?: ((value: string) => void)[], options?: ParseOptions, transforms?: Transform[]);
     get name(): "string";
     get datatype(): "string";
-    isotime(): this;
-    regex(pattern: RegExp): this;
-    email(): this;
-    startsWith(prefix: string): this;
-    endsWith(suffix: string): this;
-    min(limit: number): this;
-    max(limit: number): this;
-    length(from: number, to: number): this;
+    with(next: Next): this;
+    parse(u: unknown, options?: ParseOptions<string>): Infer<this>;
+    trim(): this;
+    lowercase(): this;
+    uppercase(): this;
+    isotime(options?: MessageOptions<string>): this;
+    regex(pattern: RegExp, options?: MessageOptions<string>): this;
+    email(options?: MessageOptions<string>): this;
+    startsWith(prefix: string, options?: MessageOptions<string>): this;
+    endsWith(suffix: string, options?: MessageOptions<string>): this;
+    min(limit: number, options?: MessageOptions<string>): this;
+    max(limit: number, options?: MessageOptions<string>): this;
+    length(from: number, to: number, options?: MessageOptions<string>): this;
     toJSON(): {
         type: "string";
         datatype: "string";
     };
 }
+export {};
 //# sourceMappingURL=StringType.d.ts.map

package/lib/private/StringType.js

@@ -1,5 +1,11 @@
+import CoerceKey from "#CoerceKey";
+import E from "#errors";
+import Loose from "#Loose";
+import ParsedKey from "#ParsedKey";
+import ParseError from "#ParseError";
 import PrimitiveType from "#PrimitiveType";
-import E from "#schema-errors";
+import resolve from "#resolve";
+import S from "#schema-errors";
 import Storable from "#Storable";
 import email from "#validator/email";
 import ends_with from "#validator/ends-with";
@@ -9,40 +15,99 @@ import max from "#validator/max";
 import min from "#validator/min";
 import regex from "#validator/regex";
 import starts_with from "#validator/starts-with";
+import is from "@rcompat/is";
 export default class StringType extends PrimitiveType {
+    #transforms;
+    constructor(validators = [], options = {}, transforms = []) {
+        super(validators, options);
+        this.#transforms = transforms;
+    }
     get name() {
         return "string";
     }
     get datatype() {
         return "string";
     }
-    isotime() {
-        return this.with({ validators: [isotime] });
+    with(next) {
+        return new StringType([...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} }, [...this.#transforms, ...next.transforms ?? []]);
+    }
+    parse(u, options = {}) {
+        const x = resolve(u);
+        const has_instance_options = is.defined(this.options[ParsedKey]);
+        const $options = has_instance_options
+            ? { ...this.options, ...options }
+            : options;
+        const loose = this[Loose] ?? $options[Loose] ?? false;
+        const $x = loose ? this[CoerceKey](x) : x;
+        if (typeof $x !== this.name)
+            throw E.invalid_type($x, this.name, $options);
+        let value = $x;
+        for (const transform of this.#transforms) {
+            value = transform(value);
+        }
+        const option_validators = $options.validators;
+        const validators = is.array(option_validators)
+            ? option_validators.concat(this.validators)
+            : this.validators;
+        const base = $options[ParsedKey] ?? "";
+        for (let i = 0; i < validators.length; i++) {
+            try {
+                validators[i](value);
+            }
+            catch (e) {
+                if (ParseError.is(e)) {
+                    const rebased = e.issues.map(issue => ({
+                        ...issue,
+                        path: issue.path === ""
+                            ? base
+                            : (base === "" ? issue.path : (base + issue.path)),
+                    }));
+                    throw new ParseError(rebased);
+                }
+                const message = is.error(e) && is.string(e.message)
+                    ? e.message
+                    : String(e);
+                throw E.invalid_type(x, message, base);
+            }
+        }
+        return value;
+    }
+    trim() {
+        return this.with({ transforms: [value => value.trim()] });
+    }
+    lowercase() {
+        return this.with({ transforms: [value => value.toLowerCase()] });
+    }
+    uppercase() {
+        return this.with({ transforms: [value => value.toUpperCase()] });
+    }
+    isotime(options) {
+        return this.with({ validators: [isotime(options)] });
     }
-    regex(pattern) {
-        return this.with({ validators: [regex(pattern)] });
+    regex(pattern, options) {
+        return this.with({ validators: [regex(pattern, options)] });
     }
-    email() {
-        return this.with({ validators: [email] });
+    email(options) {
+        return this.with({ validators: [email(options)] });
     }
-    startsWith(prefix) {
-        return this.with({ validators: [starts_with(prefix)] });
+    startsWith(prefix, options) {
+        return this.with({ validators: [starts_with(prefix, options)] });
     }
-    endsWith(suffix) {
-        return this.with({ validators: [ends_with(suffix)] });
+    endsWith(suffix, options) {
+        return this.with({ validators: [ends_with(suffix, options)] });
     }
-    min(limit) {
+    min(limit, options) {
         if (limit < 0)
-            throw E.min_negative(limit);
-        return this.with({ validators: [min(limit)] });
+            throw S.min_negative(limit);
+        return this.with({ validators: [min(limit, options)] });
     }
-    max(limit) {
+    max(limit, options) {
         if (limit < 0)
-            throw E.max_negative(limit);
-        return this.with({ validators: [max(limit)] });
+            throw S.max_negative(limit);
+        return this.with({ validators: [max(limit, options)] });
     }
-    length(from, to) {
-        return this.with({ validators: [length(from, to)] });
+    length(from, to, options) {
+        return this.with({ validators: [length(from, to, options)] });
     }
     toJSON() {
         return Storable.serialize(this);

package/lib/private/normalize.js

@@ -16,12 +16,14 @@ export default function normalize(x) {
         return new UndefinedType();
     if (is.string(x) || is.number(x) || is.boolean(x))
         return new LiteralType(x);
-    if (is.newable(x))
+    if (is.newable(x)) {
         return new ConstructorType(x);
+    }
     if (Array.isArray(x)) {
-        return x.length === 1
-            ? new ArrayType(normalize(x[0]))
-            : new TupleType(x.map(normalize));
+        const schemas = x;
+        return schemas.length === 1
+            ? new ArrayType(normalize(schemas[0]))
+            : new TupleType(schemas.map(normalize));
     }
     if (is.dict(x)) {
         const props = {};
@@ -29,6 +31,6 @@ export default function normalize(x) {
             props[k] = normalize(v);
         return new ObjectType(props);
     }
-    throw new TypeError("Unsupported type-like value passed to asType");
+    throw new TypeError("Unsupported type-like value passed to normalize");
 }
 //# sourceMappingURL=normalize.js.map

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

@@ -0,0 +1,6 @@
+type Message<T> = string | ((value: T) => string);
+type MessageOptions<T> = Message<T> | {
+    message?: Message<T>;
+};
+export type { MessageOptions as default };
+//# sourceMappingURL=MessageOptions.d.ts.map

package/lib/private/validator/MessageOptions.js

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

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

@@ -1,3 +1,3 @@
-declare const _default: import("../Validator.js").default<string>;
-export default _default;
+import type MessageOptions from "#validator/MessageOptions";
+export default function email(options?: MessageOptions<string>): import("../Validator.js").default<string>;
 //# sourceMappingURL=email.d.ts.map

package/lib/private/validator/email.js

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

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

@@ -1,3 +1,4 @@
 import type Validator from "#Validator";
-export default function ends_with(suffix: string): Validator<string>;
+import type MessageOptions from "#validator/MessageOptions";
+export default function ends_with(suffix: string, options?: MessageOptions<string>): Validator<string>;
 //# sourceMappingURL=ends-with.d.ts.map

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

@@ -1,9 +1,10 @@
 import E from "#errors";
-export default function ends_with(suffix) {
+import message from "#validator/message";
+export default function ends_with(suffix, options) {
+    const format = message(options, x => `"${x}" does not end with "${suffix}"`);
     return (x) => {
-        if (!x.endsWith(suffix)) {
-            throw E.invalid_format(x, `"${x}" does not end with "${suffix}"`);
-        }
+        if (!x.endsWith(suffix))
+            throw E.invalid_format(x, format(x));
     };
 }
 //# sourceMappingURL=ends-with.js.map

package/lib/private/validator/f32.js

@@ -1,6 +1,7 @@
 import E from "#errors";
+import is from "@rcompat/is";
 export default function f32(x) {
-    if (x !== new Float32Array([x])[0])
+    if (!is.f32(x))
         throw E.out_of_range(x, `${x} is not a 32-bit float`);
 }
 //# sourceMappingURL=f32.js.map

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

@@ -1,2 +1,3 @@
-export default function isotime(x: string): void;
+import type MessageOptions from "#validator/MessageOptions";
+export default function isotime(options?: MessageOptions<string>): (x: string) => void;
 //# sourceMappingURL=isotime.d.ts.map

package/lib/private/validator/isotime.js

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

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

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

package/lib/private/validator/length.js

@@ -1,20 +1,21 @@
 import E from "#errors";
 import S from "#schema-errors";
+import message from "#validator/message";
 import is from "@rcompat/is";
-export default function length(from, to) {
+export default function length(from, to, options) {
     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);
+    const format = message(options, () => "length out of range");
     return (x) => {
         if (!is.string(x) && !is.array(x)) {
             throw E.invalid_type(x, "string or array");
         }
-        if (x.length < from || x.length > to) {
-            throw E.out_of_range(x, "length out of range");
-        }
+        if (x.length < from || x.length > to)
+            throw E.out_of_range(x, format(x));
     };
 }
 ;

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

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

package/lib/private/validator/max.js

@@ -1,7 +1,14 @@
 import E from "#errors";
 import S from "#schema-errors";
+import message from "#validator/message";
 import is from "@rcompat/is";
-export default function max(limit) {
+export default function max(limit, options) {
+    const format = message(options, x => {
+        if (is.number(x) || is.bigint(x))
+            return `${x} is greater than ${limit}`;
+        const unit = is.string(x) ? "characters" : "items";
+        return `max ${limit} ${unit}`;
+    });
     // validate limit once
     if (is.number(limit)) {
         if (!is.finite(limit))
@@ -9,13 +16,11 @@ export default function max(limit) {
         return (x) => {
             if (is.number(x)) {
                 if (x > limit)
-                    throw E.too_large(x, `${x} is greater than ${limit}`);
+                    throw E.too_large(x, format(x));
             }
             else if (is.string(x) || is.array(x)) {
-                if (x.length > limit) {
-                    const unit = is.string(x) ? "characters" : "items";
-                    throw E.too_large(x, `max ${limit} ${unit}`);
-                }
+                if (x.length > limit)
+                    throw E.too_large(x, format(x));
             }
             else {
                 throw E.invalid_type(x, "number");
@@ -26,7 +31,7 @@ export default function max(limit) {
     return (x) => {
         if (is.bigint(x)) {
             if (x > limit)
-                throw E.too_large(x, `${x} is greater than ${limit}`);
+                throw E.too_large(x, format(x));
         }
         else {
             throw E.invalid_type(x, "bigint");

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

@@ -0,0 +1,3 @@
+import type MessageOptions from "#validator/MessageOptions";
+export default function message<T>(options: MessageOptions<T> | undefined, fallback: (value: T) => string): (value: T) => any;
+//# sourceMappingURL=message.d.ts.map

package/lib/private/validator/message.js

@@ -0,0 +1,8 @@
+import is from "@rcompat/is";
+export default function message(options, fallback) {
+    const option = is.dict(options) ? options.message : options;
+    return (value) => typeof option === "function"
+        ? option(value)
+        : option ?? fallback(value);
+}
+//# sourceMappingURL=message.js.map

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

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

package/lib/private/validator/min.js

@@ -1,7 +1,13 @@
 import E from "#errors";
 import S from "#schema-errors";
+import message from "#validator/message";
 import is from "@rcompat/is";
-export default function min(limit) {
+export default function min(limit, options) {
+    const format = message(options, x => {
+        if (is.number(x) || is.bigint(x))
+            return `${x} is lower than ${limit}`;
+        return `min ${limit} ${is.string(x) ? "characters" : "items"}`;
+    });
     // validate limit once
     if (is.number(limit)) {
         if (!is.finite(limit))
@@ -9,12 +15,11 @@ export default function min(limit) {
         return (x) => {
             if (is.number(x)) {
                 if (x < limit)
-                    throw E.too_small(x, `${x} is lower than ${limit}`);
+                    throw E.too_small(x, format(x));
             }
             else if (is.string(x) || is.array(x)) {
                 if (x.length < limit) {
-                    const unit = is.string(x) ? "characters" : "items";
-                    throw E.too_small(x, `min ${limit} ${unit}`);
+                    throw E.too_small(x, format(x));
                 }
             }
             else {
@@ -26,7 +31,7 @@ export default function min(limit) {
     return (x) => {
         if (is.bigint(x)) {
             if (x < limit)
-                throw E.too_small(x, `${x} is lower than ${limit}`);
+                throw E.too_small(x, format(x));
         }
         else {
             throw E.invalid_type(x, "bigint");

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

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

package/lib/private/validator/regex.js

@@ -1,10 +1,10 @@
 import E from "#errors";
-export default function regex(format, error) {
+import message from "#validator/message";
+export default function regex(re, options) {
+    const format = message(options, y => `"${y}" is not a valid ${String(re)}`);
     return (x) => {
-        if (!format.test(x)) {
-            const message = (error ?? ((y) => `"${y}" is not a valid ${String(format)}`))(x);
-            throw E.invalid_format(x, message);
-        }
+        if (!re.test(x))
+            throw E.invalid_format(x, format(x));
     };
 }
 ;

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

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

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

@@ -1,9 +1,10 @@
 import E from "#errors";
-export default function starts_with(prefix) {
+import message from "#validator/message";
+export default function starts_with(prefix, options) {
+    const format = message(options, x => `"${x}" does not start with "${prefix}"`);
     return (x) => {
-        if (!x.startsWith(prefix)) {
-            throw E.invalid_format(x, `"${x}" does not start with "${prefix}"`);
-        }
+        if (!x.startsWith(prefix))
+            throw E.invalid_format(x, format(x));
     };
 }
 //# sourceMappingURL=starts-with.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pema",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Primate schema validation",
   "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -18,9 +18,9 @@
   ],
   "dependencies": {
     "@rcompat/assert": "^0.14.0",
-    "@rcompat/cli": "^0.25.0",
+    "@rcompat/cli": "^0.25.1",
     "@rcompat/error": "^0.9.0",
-    "@rcompat/is": "^0.12.0",
+    "@rcompat/is": "^0.12.2",
     "@rcompat/symbol": "^0.3.0"
   },
   "devDependencies": {
@@ -43,7 +43,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "pnpm run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",