pema 0.1.0 → 0.2.1

package/lib/private/ParseError.js

@@ -0,0 +1,51 @@
+function humanize(path) {
+    return path === ""
+        ? ""
+        : path
+            .slice(1)
+            .split("/")
+            .map(seg => seg.replace(/~1/g, "/").replace(/~0/g, "~"))
+            .map(seg => `.${seg}`)
+            .join("");
+}
+function stringify(issue) {
+    // For root (scalar) errors, keep just the message;
+    // otherwise prefix with humanized path
+    return issue.path === ""
+        ? issue.message
+        : `${humanize(issue.path)}: ${issue.message}`;
+}
+export default class ParseError extends Error {
+    #issues;
+    constructor(issues) {
+        super(stringify(issues[0]));
+        this.name = "ParseError";
+        this.#issues = issues;
+    }
+    get issues() {
+        return this.#issues;
+    }
+    toJSON() {
+        const issues = this.#issues ?? [];
+        if (issues.length === 0) {
+            return { message: "Parsing failed", messages: ["Parsing failed"] };
+        }
+        const isForm = issues.some(i => i.path !== "");
+        if (!isForm) {
+            const messages = issues.map(i => i.message);
+            return { message: messages[0], messages };
+        }
+        const dict = {};
+        for (const i of issues) {
+            const key = i.path;
+            if (!dict[key])
+                dict[key] = { message: i.message, messages: [] };
+            dict[key].messages.push(i.message);
+            // Keep the first as the short message
+            if (dict[key].messages.length === 1)
+                dict[key].message = i.message;
+        }
+        return dict;
+    }
+}
+//# sourceMappingURL=ParseError.js.map

package/lib/private/ParseIssue.d.ts

@@ -0,0 +1,5 @@
+import type Issue from "#Issue";
+export default interface ParseIssue extends Issue {
+    input: unknown;
+}
+//# sourceMappingURL=ParseIssue.d.ts.map

package/lib/private/ParseIssue.js

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

package/lib/private/ParseOptions.d.ts

@@ -0,0 +1,10 @@
+import type ParsedKey from "#ParsedKey";
+import type Validator from "#Validator";
+import type JSONPointer from "@rcompat/type/JSONPointer";
+export default interface ParseOptions<T = unknown> {
+    coerce?: boolean;
+    [ParsedKey]?: JSONPointer;
+    partial?: boolean;
+    validators?: Validator<T>[];
+}
+//# sourceMappingURL=ParseOptions.d.ts.map

package/lib/private/ParseOptions.js

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

package/lib/private/Parsed.d.ts

@@ -0,0 +1,24 @@
+import CoerceKey from "#CoerceKey";
+import ParsedKey from "#ParsedKey";
+import type ParseOptions from "#ParseOptions";
+import type Serialized from "#Serialized";
+import type Serializable from "@rcompat/type/Serializable";
+export default abstract class Parsed<StaticType> implements Serializable {
+    get [ParsedKey](): "ParsedKey";
+    get infer(): StaticType;
+    get nullable(): boolean;
+    [CoerceKey](x: unknown): unknown;
+    abstract get name(): string;
+    /**
+    * Parse the given value.
+    *
+    * @param x Value to parse.
+    *
+    * @throws `ParseError` if the value could not be parsed.
+    *
+    * @returns The parsed value, if successfully parsed.
+    */
+    abstract parse(x: unknown, options?: ParseOptions): StaticType;
+    abstract toJSON(): Serialized;
+}
+//# sourceMappingURL=Parsed.d.ts.map

package/lib/private/Parsed.js

@@ -0,0 +1,17 @@
+import CoerceKey from "#CoerceKey";
+import ParsedKey from "#ParsedKey";
+export default class Parsed {
+    get [ParsedKey]() {
+        return "ParsedKey";
+    }
+    get infer() {
+        return undefined;
+    }
+    get nullable() {
+        return false;
+    }
+    [CoerceKey](x) {
+        return x;
+    }
+}
+//# sourceMappingURL=Parsed.js.map

package/lib/private/ParsedKey.d.ts

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

package/lib/private/ParsedKey.js

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

package/lib/private/PartialType.d.ts

@@ -0,0 +1,25 @@
+import DefaultType from "#DefaultType";
+import type Infer from "#Infer";
+import type ParseOptions from "#ParseOptions";
+import type Partialable from "#Partialable";
+import type DefaultTrait from "#trait/Default";
+import VirtualType from "#VirtualType";
+type InferPartial<D extends Partialable> = {
+    -readonly [K in keyof D]?: NonNullable<Infer<D[K]>>;
+};
+export default class PartialType<D extends Partialable> extends VirtualType<D, InferPartial<D>, "PartialType"> implements DefaultTrait<InferPartial<D>> {
+    #private;
+    constructor(spec: D);
+    get name(): "partial";
+    get schema(): D;
+    default(value: (() => InferPartial<D>) | InferPartial<D>): DefaultType<this, InferPartial<D>>;
+    parse(x: unknown, options?: ParseOptions): InferPartial<D>;
+    toJSON(): {
+        type: "partial";
+        of: {
+            type: "string";
+        };
+    };
+}
+export {};
+//# sourceMappingURL=PartialType.d.ts.map

package/lib/private/PartialType.js

@@ -0,0 +1,69 @@
+import DefaultType from "#DefaultType";
+import error from "#error";
+import ParsedKey from "#ParsedKey";
+import ParseError from "#ParseError";
+import join from "#path/join";
+import next from "#path/next";
+import VirtualType from "#VirtualType";
+import isDict from "@rcompat/is/dict";
+export default class PartialType extends VirtualType {
+    #spec;
+    constructor(spec) {
+        super();
+        this.#spec = spec;
+    }
+    get name() {
+        return "partial";
+    }
+    get schema() {
+        return this.#spec;
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
+        if (!isDict(x)) {
+            throw new ParseError(error("object", x, options));
+        }
+        const input = x;
+        const out = {};
+        const issues = [];
+        for (const key of Object.keys(this.#spec)) {
+            // skip missing/undefined keys (partial semantics)
+            if (!(key in input) || input[key] === undefined)
+                continue;
+            try {
+                const parsed = this.#spec[key].parse(input[key], next(key, options));
+                if (parsed !== undefined)
+                    out[key] = parsed;
+            }
+            catch (e) {
+                if (e instanceof ParseError) {
+                    // child already rebased to /<key> via nextOptions -> just collect
+                    if (e.issues && e.issues.length) {
+                        issues.push(...e.issues);
+                    }
+                }
+                else {
+                    // wrap non-ParseError into a properly-pathed issue at /<key>
+                    const message = e && typeof e.message === "string"
+                        ? e.message
+                        : String(e);
+                    issues.push({
+                        input: input[key],
+                        message: message,
+                        path: join(options[ParsedKey] ?? "", key),
+                    });
+                }
+            }
+        }
+        if (issues.length > 0) {
+            throw new ParseError(issues);
+        }
+        return out;
+    }
+    toJSON() {
+        return { type: this.name, of: { type: "string" } };
+    }
+}
+//# sourceMappingURL=PartialType.js.map

package/lib/private/Partialable.d.ts

@@ -0,0 +1,5 @@
+import type Parsed from "#Parsed";
+import type Dict from "@rcompat/type/Dict";
+type Partialable = Dict<Parsed<unknown>>;
+export type { Partialable as default };
+//# sourceMappingURL=Partialable.d.ts.map

package/lib/private/Partialable.js

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

package/lib/private/PrimaryType.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,26 @@
+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/PrimitiveType.d.ts

@@ -1,11 +1,19 @@
 import type Infer from "#Infer";
+import type ParseOptions from "#ParseOptions";
 import Type from "#Type";
 import type Validator from "#Validator";
-export default class PrimitiveType<StaticType, Name extends string> extends Type<StaticType, Name> {
+type Next<T> = {
+    options?: ParseOptions;
+    validators?: Validator<T>[];
+};
+export default abstract class PrimitiveType<StaticType, Name extends string> extends Type<StaticType, Name> {
     #private;
-    constructor(name: string, validators?: Validator<StaticType>[]);
+    constructor(validators?: Validator<StaticType>[], options?: ParseOptions);
+    get options(): ParseOptions<unknown>;
     get validators(): Validator<StaticType>[];
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    derive(next: Next<StaticType>): this;
+    get coerce(): this;
+    parse(x: unknown, options?: ParseOptions<StaticType>): Infer<this>;
 }
+export {};
 //# sourceMappingURL=PrimitiveType.d.ts.map

package/lib/private/PrimitiveType.js

@@ -1,31 +1,64 @@
-import expected from "#expected";
+import CoerceKey from "#CoerceKey";
+import error from "#error";
+import ParsedKey from "#ParsedKey";
+import ParseError from "#ParseError";
 import Type from "#Type";
-const error_message = (name, x, key) => {
-    const base = expected(name, x);
-    return key === undefined
-        ? base
-        : `${key}: ${base}`;
-};
 export default class PrimitiveType extends Type {
-    #name;
     #validators;
-    constructor(name, validators = []) {
+    #options;
+    constructor(validators = [], options = {}) {
         super();
-        this.#name = name;
         this.#validators = validators;
+        this.#options = options;
+    }
+    get options() {
+        return this.#options;
     }
     get validators() {
         return this.#validators;
     }
-    get name() {
-        return this.#name;
+    derive(next) {
+        const Constructor = this.constructor;
+        return new Constructor([...this.#validators, ...next.validators ?? []], { ...this.#options, ...next.options ?? {} });
+    }
+    get coerce() {
+        return this.derive({ options: { coerce: true } });
     }
-    validate(x, key) {
-        if (typeof x !== this.name) {
-            throw new Error(error_message(this.name, x, key));
+    parse(x, options = {}) {
+        const $options = { ...this.#options, ...options };
+        const validators = [...$options.validators ?? [], ...this.#validators];
+        const $x = $options.coerce === true ? this[CoerceKey](x) : x;
+        if (typeof $x !== this.name) {
+            throw new ParseError(error(this.name, $x, $options));
+        }
+        const base = $options[ParsedKey] ?? "";
+        for (const v of validators) {
+            try {
+                v($x);
+            }
+            catch (e) {
+                if (e instanceof ParseError) {
+                    // rebase each issue path under `base`
+                    const rebased = (e.issues ?? []).map(i => ({
+                        ...i,
+                        path: i.path === ""
+                            ? base
+                            : (base === "" ? i.path : (base + i.path)),
+                    }));
+                    throw new ParseError(rebased);
+                }
+                // non a ParseError - wrap with proper path
+                const message = e && typeof e.message === "string"
+                    ? e.message
+                    : String(e);
+                throw new ParseError([{
+                        input: x,
+                        message,
+                        path: base,
+                    }]);
+            }
         }
-        this.#validators.forEach(validator => validator(x));
-        return x;
+        return $x;
     }
 }
 //# sourceMappingURL=PrimitiveType.js.map

package/lib/private/PureType.d.ts

@@ -0,0 +1,15 @@
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+import type OptionalTrait from "#trait/Optional";
+import type Printable from "@rcompat/type/Printable";
+export default class PureType<Type, Name extends string = "PureType"> extends Parsed<Type> implements Printable, OptionalTrait {
+    get name(): string;
+    get Name(): Name;
+    optional(): OptionalType<this>;
+    parse(x: unknown): Infer<this>;
+    toJSON(): {
+        type: "pure";
+    };
+}
+//# sourceMappingURL=PureType.d.ts.map

package/lib/private/PureType.js

@@ -0,0 +1,21 @@
+import OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+export default class PureType extends Parsed {
+    get name() {
+        return "pure";
+    }
+    get Name() {
+        return undefined;
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    parse(x) {
+        // no parsing of static types
+        return x;
+    }
+    toJSON() {
+        return { type: "pure" };
+    }
+}
+//# sourceMappingURL=PureType.js.map

package/lib/private/RecordType.d.ts

@@ -1,13 +1,28 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import OptionalType from "#OptionalType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
 import type RecordTypeKey from "#RecordTypeKey";
-import type Validated from "#Validated";
-export default class RecordType<Key extends RecordTypeKey, Value extends Validated<unknown>> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> {
+import type OptionalTrait from "#trait/Optional";
+export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<unknown>> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> implements OptionalTrait {
     #private;
     constructor(k: Key, v: Value);
     optional(): OptionalType<this>;
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    get name(): "record";
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "record";
+        key: {
+            type: "string";
+            datatype: "string";
+        } | {
+            type: "symbol";
+        } | {
+            type: "number" | "bigint";
+            datatype: "f64";
+        };
+        value: import("./Serialized.js").default;
+    };
 }
 //# sourceMappingURL=RecordType.d.ts.map

package/lib/private/RecordType.js

@@ -1,10 +1,15 @@
+import error from "#error";
+import expected from "#expected";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-import expected from "#expected";
-const error = (k, key) => {
-    return key === undefined
-        ? `.${k}`
-        : `${key}.${k}`;
+import ParsedKey from "#ParsedKey";
+import ParseError from "#ParseError";
+import join from "#path/join";
+const nextOptions = (k, options) => {
+    const base = options?.[ParsedKey] ?? "";
+    return options === undefined
+        ? { [ParsedKey]: join("", k) }
+        : { ...options, [ParsedKey]: join(base, k) };
 };
 const is_numeric = (string) => /^-?\d+(\.\d+)?$/.test(string);
 export default class RecordType extends GenericType {
@@ -21,38 +26,62 @@ export default class RecordType extends GenericType {
     get name() {
         return "record";
     }
-    validate(x, key) {
+    parse(x, options = {}) {
         if (typeof x !== "object" || x === null) {
-            throw new Error("Expected object");
+            throw new ParseError(error("object", x, options));
         }
         const key_name = this.#key.name;
         const keys = Object.keys(x);
         const symbols = Object.getOwnPropertySymbols(x);
+        const base = options[ParsedKey] ?? "";
         if (key_name === "string" || key_name === "number") {
             // no key may be a symbol
             if (symbols.length > 0) {
-                throw new Error(expected(`${key_name} key`, symbols[0]));
+                throw new ParseError([{
+                        input: x,
+                        message: expected(`${key_name} key`, symbols[0]),
+                        path: base,
+                    }]);
             }
             keys.forEach(k => {
                 if (key_name === "string" && is_numeric(k)) {
-                    throw new Error(expected("string key", +k));
+                    throw new ParseError([{
+                            input: x,
+                            message: expected("string key", +k),
+                            path: join(base, k),
+                        }]);
                 }
                 if (key_name === "number" && !is_numeric(k)) {
-                    throw new Error(expected("number key", k));
+                    throw new ParseError([{
+                            input: x,
+                            message: expected("number key", k),
+                            path: join(base, k),
+                        }]);
                 }
-                this.#value.validate(x[k], error(k.toString(), key));
+                this.#value.parse(x[k], nextOptions(k, options));
             });
         }
         if (key_name === "symbol") {
-            // no key may not be a symbol
+            // disallow any non-symbol keys
             if (keys.length > 0) {
-                throw new Error(expected("symbol key", keys[0]));
+                throw new ParseError([{
+                        input: x,
+                        message: expected("symbol key", keys[0]),
+                        path: join(base, keys[0]),
+                    }]);
             }
             symbols.forEach(k => {
-                this.#value.validate(x[k], error(k.toString(), key));
+                this.#value.parse(x[k], options);
             });
         }
         return x;
     }
+    toJSON() {
+        return {
+            type: this.name,
+            key: this.#key.toJSON(),
+            value: this.#value.toJSON(),
+        };
+    }
 }
 //# sourceMappingURL=RecordType.js.map

package/lib/private/RecordTypeKey.d.ts

@@ -1,6 +1,6 @@
 import type NumberType from "#NumberType";
 import type StringType from "#StringType";
 import type SymbolType from "#SymbolType";
-type KeyType = StringType | NumberType | SymbolType;
+type KeyType = NumberType | StringType | SymbolType;
 export type { KeyType as default };
 //# sourceMappingURL=RecordTypeKey.d.ts.map

package/lib/private/Schema.d.ts

@@ -1,6 +1,6 @@
-import type Validated from "#Validated";
-import type AbstractConstructor from "@rcompat/type/AbstractConstructor";
-type Schema = Validated<unknown> | Schema[] | null | undefined | string | AbstractConstructor | {
+import type Parsed from "#Parsed";
+import type AbstractNewable from "@rcompat/type/AbstractNewable";
+type Schema = Parsed<unknown> | AbstractNewable | null | undefined | string | number | boolean | Schema[] | {
     [k: string]: Schema;
 };
 export type { Schema as default };

package/lib/private/SchemaError.d.ts

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

package/lib/private/SchemaError.js

@@ -0,0 +1,8 @@
+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/Serialized.d.ts

@@ -0,0 +1,72 @@
+import type Dict from "@rcompat/type/Dict";
+import type JSONValue from "@rcompat/type/JSONValue";
+type DT<D extends string = string> = {
+    datatype?: D;
+};
+type PrimitiveSerialized = {
+    type: "string";
+} & DT | {
+    type: "boolean";
+} & DT | {
+    type: "symbol";
+} & DT | {
+    type: "null";
+} & DT | {
+    type: "undefined";
+} & DT | {
+    type: "date";
+} & DT | {
+    type: "blob";
+} & DT | {
+    type: "file";
+} & DT | {
+    type: "url";
+} & DT;
+type NumberSerialized = {
+    type: "number";
+} & DT;
+type BigIntSerialized = {
+    type: "bigint";
+} & DT;
+type StructuralSerialized = {
+    type: "newable";
+    of: string;
+} | {
+    type: "literal";
+    value: JSONValue;
+} | {
+    type: "array";
+    of: Serialized;
+} | {
+    type: "tuple";
+    of: Serialized[];
+} | {
+    type: "record";
+    key: Serialized;
+    value: Serialized;
+} | {
+    type: "object";
+    properties: Dict<Serialized>;
+} | {
+    type: "union";
+    of: Serialized[];
+} | {
+    type: "optional";
+    of: Serialized;
+} | {
+    type: "default";
+    of: Serialized;
+} | {
+    type: "partial";
+    of: Serialized;
+} | {
+    type: "schema";
+    of: Serialized;
+} | {
+    type: "pure";
+} | {
+    type: "primary";
+};
+type Serialized = PrimitiveSerialized | NumberSerialized | BigIntSerialized | StructuralSerialized;
+export type { Serialized as default };
+//# sourceMappingURL=Serialized.d.ts.map

package/lib/private/Serialized.js

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