pema 0.1.0 → 0.2.1

package/lib/private/VirtualType.js

@@ -0,0 +1,11 @@
+import GenericType from "#GenericType";
+const storeable = (x) => !!x && typeof x === "object" && "datatype" in x;
+export default class VirtualType extends GenericType {
+    get datatype() {
+        if (storeable(this.schema)) {
+            return this.schema.datatype;
+        }
+        throw new Error("cannot be used in a store");
+    }
+}
+//# sourceMappingURL=VirtualType.js.map

package/lib/private/array.d.ts

@@ -1,5 +1,8 @@
 import ArrayType from "#ArrayType";
-import type Validated from "#Validated";
-declare const _default: <const T extends Validated<unknown>>(t: T) => ArrayType<T>;
-export default _default;
+import type NormalizeSchema from "#NormalizeSchema";
+import type Schema from "#Schema";
+/**
+* Value is an array of the given type.
+*/
+export default function array<const S extends Schema>(of: S): ArrayType<NormalizeSchema<S>>;
 //# sourceMappingURL=array.d.ts.map

package/lib/private/array.js

@@ -1,3 +1,9 @@
 import ArrayType from "#ArrayType";
-export default (t) => new ArrayType(t);
+import normalize from "#normalize";
+/**
+* Value is an array of the given type.
+*/
+export default function array(of) {
+    return new ArrayType(normalize(of));
+}
 //# sourceMappingURL=array.js.map

package/lib/private/bigint.d.ts

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

package/lib/private/bigint.js

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

package/lib/private/biguint.d.ts

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

package/lib/private/biguint.js

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

package/lib/private/boolean.d.ts

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

package/lib/private/boolean.js

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

package/lib/private/coerce/bigint.d.ts

@@ -0,0 +1,2 @@
+export default function coerceBigInt(x: unknown): unknown;
+//# sourceMappingURL=bigint.d.ts.map

package/lib/private/coerce/bigint.js

@@ -0,0 +1,13 @@
+import integer from "@rcompat/is/integer";
+import numeric from "@rcompat/is/numeric";
+export default function coerceBigInt(x) {
+    // normalize from string to number; other types unaffected
+    const n = numeric(x) ? Number(x) : x;
+    // normalize from number to bigint; other types unaffected
+    if (integer(n)) {
+        return BigInt(n);
+    }
+    // bigint or invalid
+    return x;
+}
+//# sourceMappingURL=bigint.js.map

package/lib/private/coerce/date.d.ts

@@ -0,0 +1,2 @@
+export default function coerceDate(x: unknown): unknown;
+//# sourceMappingURL=date.d.ts.map

package/lib/private/coerce/date.js

@@ -0,0 +1,56 @@
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+// time with optional :ss and .ms, but TZ is REQUIRED (Z or ±HH:MM)
+const ISO_DATETIME_TZ = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(?:Z|[+-]\d{2}:\d{2})$/;
+// signed integer
+const INT = /^[+-]?\d+$/;
+function epoch(n, digits) {
+    // for strings we use digit-count to choose s vs ms.
+    // for numbers we ALWAYS treat as ms (no digits provided)
+    const ms = digits !== undefined
+        ? (digits >= 13 ? n : n * 1000)
+        : n;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function fromNumber(n) {
+    const date = epoch(n);
+    return date !== undefined ? date : n;
+}
+function fromString(raw) {
+    const s = raw.trim();
+    if (s === "")
+        return raw;
+    // integer string -> epoch seconds or ms (based on digit count)
+    if (INT.test(s)) {
+        const digits = s[0] === "+" || s[0] === "-" ? s.length - 1 : s.length;
+        const n = Number(s);
+        const date = epoch(n, digits);
+        return date ?? raw;
+    }
+    // ISO date-only -> interpret as UTC midnight
+    if (ISO_DATE.test(s)) {
+        const date = new Date(`${s}T00:00:00.000Z`);
+        return Number.isNaN(date.getTime()) ? raw : date;
+    }
+    // ISO datetime *with* timezone
+    if (ISO_DATETIME_TZ.test(s)) {
+        const date = new Date(s);
+        return Number.isNaN(date.getTime()) ? raw : date;
+    }
+    return raw;
+}
+export default function coerceDate(x) {
+    // already a Date
+    if (x instanceof Date)
+        return x;
+    // numbers are treated as epochs
+    if (typeof x === "number" && Number.isFinite(x)) {
+        return fromNumber(x);
+    }
+    // strings
+    if (typeof x === "string") {
+        return fromString(x);
+    }
+    return x;
+}
+//# sourceMappingURL=date.js.map

package/lib/private/coerce/int.d.ts

@@ -0,0 +1,2 @@
+export default function coerceInt(x: unknown): unknown;
+//# sourceMappingURL=int.d.ts.map

package/lib/private/coerce/int.js

@@ -0,0 +1,8 @@
+import numeric from "@rcompat/is/numeric";
+export default function coerceInt(x) {
+    if (numeric(x)) {
+        return Number(x);
+    }
+    return x;
+}
+//# sourceMappingURL=int.js.map

package/lib/private/constructor.d.ts

@@ -1,5 +1,8 @@
 import ConstructorType from "#ConstructorType";
-import type AbstractConstructor from "@rcompat/type/AbstractConstructor";
-declare const _default: <const C extends AbstractConstructor>(constructor: C) => ConstructorType<C>;
+import type AbstractNewable from "@rcompat/type/AbstractNewable";
+/**
+ * Value is a constructed instance of the given class.
+ */
+declare const _default: <const C extends AbstractNewable>(constructor: C) => ConstructorType<C>;
 export default _default;
 //# sourceMappingURL=constructor.d.ts.map

package/lib/private/constructor.js

@@ -1,3 +1,6 @@
 import ConstructorType from "#ConstructorType";
+/**
+ * Value is a constructed instance of the given class.
+ */
 export default (constructor) => new ConstructorType(constructor);
 //# sourceMappingURL=constructor.js.map

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

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

package/lib/private/error/fail.js

@@ -0,0 +1,5 @@
+import ParseError from "#ParseError";
+export default function fail(input, msg) {
+    return new ParseError([{ input, message: msg, path: "" }]);
+}
+//# sourceMappingURL=fail.js.map

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

@@ -0,0 +1,3 @@
+import SchemaError from "#SchemaError";
+export default function schemafail(message: string, ...args: unknown[]): SchemaError;
+//# sourceMappingURL=schemafail.d.ts.map

package/lib/private/error/schemafail.js

@@ -0,0 +1,5 @@
+import SchemaError from "#SchemaError";
+export default function schemafail(message, ...args) {
+    return new SchemaError(message, ...args);
+}
+//# sourceMappingURL=schemafail.js.map

package/lib/private/error.d.ts

@@ -1,3 +1,4 @@
-declare const _default: (message: string, key?: string) => string;
-export default _default;
+import type ParseIssue from "#ParseIssue";
+import type ParseOptions from "#ParseOptions";
+export default function error<T>(name: string, x: unknown, options?: ParseOptions<T>): [ParseIssue];
 //# sourceMappingURL=error.d.ts.map

package/lib/private/error.js

@@ -1,4 +1,11 @@
-export default (message, key) => key === undefined
-    ? message
-    : `${key}: ${message}`;
+import expected from "#expected";
+import ParsedKey from "#ParsedKey";
+export default function error(name, x, options) {
+    return [{
+            input: x,
+            message: expected(name, x),
+            path: options?.[ParsedKey] ?? "",
+        }];
+}
+;
 //# sourceMappingURL=error.js.map

package/lib/private/expect.d.ts

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

package/lib/private/expect.js

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

package/lib/private/expected.js

@@ -1,2 +1,11 @@
-export default (type, x) => `expected ${type}, got \`${x?.toString() ?? x}\` (${(typeof x)})`;
+function print_got(x) {
+    if (x === undefined) {
+        return "undefined";
+    }
+    if (x === null) {
+        return "null";
+    }
+    return `\`${x?.toString() ?? x}\` (${(typeof x)})`;
+}
+export default (type, x) => `expected ${type}, got ${print_got(x)}`;
 //# sourceMappingURL=expected.js.map

package/lib/private/f32.d.ts

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

package/lib/private/f32.js

@@ -0,0 +1,4 @@
+import NumberType from "#NumberType";
+import f32 from "#validator/f32";
+export default new NumberType("f32", [f32]);
+//# sourceMappingURL=f32.js.map

package/lib/private/f64.d.ts

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

package/lib/private/f64.js

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

package/lib/private/i128.d.ts

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

package/lib/private/i128.js

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

package/lib/private/i16.d.ts

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

package/lib/private/i16.js

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

package/lib/private/i32.d.ts

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

package/lib/private/i32.js

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

package/lib/private/i64.d.ts

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

package/lib/private/i64.js

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

package/lib/private/i8.d.ts

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

package/lib/private/i8.js

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

package/lib/private/index.d.ts

@@ -1,5 +1,7 @@
 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>>;
+/**
+* Create a schema.
+*/
+export default function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -1,43 +1,8 @@
-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;
-    }
-};
+import normalize from "#normalize";
+/**
+* Create a schema.
+*/
 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);
+    return normalize(s);
 }
 //# sourceMappingURL=index.js.map

package/lib/private/int.d.ts

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

package/lib/private/int.js

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

package/lib/private/is-parsed-type.d.ts

@@ -0,0 +1,3 @@
+import type Parsed from "#Parsed";
+export default function isParsedType(x: unknown): x is Parsed<unknown>;
+//# sourceMappingURL=is-parsed-type.d.ts.map

package/lib/private/is-parsed-type.js

@@ -0,0 +1,6 @@
+import ParsedKey from "#ParsedKey";
+export default function isParsedType(x) {
+    return !!x && typeof x === "object" && ParsedKey in x;
+}
+;
+//# sourceMappingURL=is-parsed-type.js.map

package/lib/private/json/JSONIssue.d.ts

@@ -0,0 +1,6 @@
+type JSONIssue = {
+    message: string;
+    messages: string[];
+};
+export type { JSONIssue as default };
+//# sourceMappingURL=JSONIssue.d.ts.map

package/lib/private/json/JSONIssue.js

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

package/lib/private/json/JSONPayload.d.ts

@@ -0,0 +1,5 @@
+import type JSONIssue from "#json/JSONIssue";
+import type JSONPointer from "@rcompat/type/JSONPointer";
+type JSONPayload = JSONIssue | Record<JSONPointer, JSONIssue>;
+export type { JSONPayload as default };
+//# sourceMappingURL=JSONPayload.d.ts.map

package/lib/private/json/JSONPayload.js

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

package/lib/private/literal.d.ts

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

package/lib/private/literal.js

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

package/lib/private/normalize.d.ts

@@ -0,0 +1,4 @@
+import type NormalizeSchema from "#NormalizeSchema";
+import type Schema from "#Schema";
+export default function normalize<const T extends Schema>(x: T): NormalizeSchema<T>;
+//# sourceMappingURL=normalize.d.ts.map

package/lib/private/normalize.js

@@ -0,0 +1,42 @@
+import ArrayType from "#ArrayType";
+import ConstructorType from "#ConstructorType";
+import LiteralType from "#LiteralType";
+import NullType from "#NullType";
+import ObjectType from "#ObjectType";
+import ParsedKey from "#ParsedKey";
+import TupleType from "#TupleType";
+import UndefinedType from "#UndefinedType";
+import newable from "@rcompat/is/newable";
+function isParsed(x) {
+    return !!x && typeof x === "object" && ParsedKey in x;
+}
+function isPlain(x) {
+    return !!x && typeof x === "object" &&
+        Object.getPrototypeOf(x) === Object.prototype;
+}
+export default function normalize(x) {
+    if (isParsed(x))
+        return x;
+    if (x === null)
+        return new NullType();
+    if (x === undefined)
+        return new UndefinedType();
+    if (typeof x === "string" || typeof x === "number" || typeof x === "boolean")
+        return new LiteralType(x);
+    if (newable(x)) {
+        return new ConstructorType(x);
+    }
+    if (Array.isArray(x)) {
+        return x.length === 1
+            ? new ArrayType(normalize(x[0]))
+            : new TupleType(x.map(normalize));
+    }
+    if (isPlain(x)) {
+        const props = {};
+        for (const [k, v] of Object.entries(x))
+            props[k] = normalize(v);
+        return new ObjectType(props);
+    }
+    throw new TypeError("Unsupported type-like value passed to asType");
+}
+//# sourceMappingURL=normalize.js.map

package/lib/private/number.d.ts

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

package/lib/private/number.js

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

package/lib/private/object.d.ts

@@ -0,0 +1,11 @@
+import type NormalizeSchema from "#NormalizeSchema";
+import ObjectType from "#ObjectType";
+import type Schema from "#Schema";
+import type Dict from "@rcompat/type/Dict";
+import type EO from "@rcompat/type/EO";
+type NormalizeProps<S extends Dict<Schema>> = keyof S extends never ? EO : {
+    [K in keyof S]: NormalizeSchema<S[K]>;
+};
+export default function object<P extends Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
+export {};
+//# sourceMappingURL=object.d.ts.map

package/lib/private/object.js

@@ -0,0 +1,10 @@
+import normalize from "#normalize";
+import ObjectType from "#ObjectType";
+export default function object(peries) {
+    const props = {};
+    for (const [k, v] of Object.entries(peries)) {
+        props[k] = normalize(v);
+    }
+    return new ObjectType(props);
+}
+//# sourceMappingURL=object.js.map