pema 0.1.0 → 0.2.1

package/lib/private/StoreId.d.ts

@@ -0,0 +1,6 @@
+import type Infer from "#Infer";
+import type Parsed from "#Parsed";
+import type StoreSchema from "#StoreSchema";
+type StoreId<T extends StoreSchema> = T["id"] extends Parsed<unknown> ? NonNullable<Infer<T["id"]>> : never;
+export type { StoreId as default };
+//# sourceMappingURL=StoreId.d.ts.map

package/lib/private/StoreId.js

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

package/lib/private/StoreSchema.d.ts

@@ -0,0 +1,8 @@
+import type Storeable from "#Storeable";
+type StoreSchema = {
+    [k: string]: Storeable;
+} & {
+    id: Storeable;
+};
+export type { StoreSchema as default };
+//# sourceMappingURL=StoreSchema.d.ts.map

package/lib/private/StoreSchema.js

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

package/lib/private/StoreType.d.ts

@@ -0,0 +1,21 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import type InferStore from "#InferStore";
+import type ParseOptions from "#ParseOptions";
+import PartialType from "#PartialType";
+import type Serialized from "#Serialized";
+import type StoreSchema from "#StoreSchema";
+import type Dict from "@rcompat/type/Dict";
+export default class StoreType<T extends StoreSchema> extends GenericType<T, InferStore<T>, "StoreType"> {
+    #private;
+    constructor(spec: T);
+    get name(): string;
+    get schema(): T;
+    partial(): PartialType<T>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "object";
+        properties: Dict<Serialized>;
+    };
+}
+//# sourceMappingURL=StoreType.d.ts.map

package/lib/private/StoreType.js

@@ -0,0 +1,45 @@
+import GenericType from "#GenericType";
+import ParsedKey from "#ParsedKey";
+import PartialType from "#PartialType";
+import join from "#path/join";
+export default class StoreType extends GenericType {
+    #properties;
+    constructor(spec) {
+        super();
+        this.#properties = spec;
+    }
+    get name() {
+        return "store";
+    }
+    get schema() {
+        return this.#properties;
+    }
+    partial() {
+        return new PartialType(this.#properties);
+    }
+    parse(x, options = {}) {
+        const spec = this.#properties;
+        if (typeof x !== "object" || x === null) {
+            throw new Error("Expected object");
+        }
+        const result = {};
+        for (const k in spec) {
+            const r = spec[k].parse(x[k], {
+                ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
+            });
+            // exclude undefined (optionals)
+            if (r !== undefined) {
+                result[k] = r;
+            }
+        }
+        return x;
+    }
+    toJSON() {
+        const properties = {};
+        for (const [k, v] of Object.entries(this.#properties)) {
+            properties[k] = v.toJSON();
+        }
+        return { type: "object", properties };
+    }
+}
+//# sourceMappingURL=StoreType.js.map

package/lib/private/Storeable.d.ts

@@ -0,0 +1,15 @@
+import type K from "#DataKey";
+import Parsed from "#Parsed";
+import type Serialized from "#Serialized";
+export default abstract class Storeable<T extends K = K> extends Parsed<unknown> {
+    abstract get datatype(): T;
+    abstract toJSON(): Serialized;
+    static serialize<N extends string, T extends K>(s: {
+        name: N;
+        datatype: T;
+    }): {
+        type: N;
+        datatype: T;
+    };
+}
+//# sourceMappingURL=Storeable.d.ts.map

package/lib/private/Storeable.js

@@ -0,0 +1,7 @@
+import Parsed from "#Parsed";
+export default class Storeable extends Parsed {
+    static serialize(s) {
+        return { type: s.name, datatype: s.datatype };
+    }
+}
+//# sourceMappingURL=Storeable.js.map

package/lib/private/StringType.d.ts

@@ -1,8 +1,20 @@
 import PrimitiveType from "#PrimitiveType";
-import type Validator from "#Validator";
-export default class StringType extends PrimitiveType<string, "StringType"> {
-    constructor(validators?: Validator<string>[]);
-    startsWith(prefix: string): StringType;
-    endsWith(suffix: string): StringType;
+import Storeable from "#Storeable";
+export default class StringType extends PrimitiveType<string, "StringType"> implements Storeable<"string"> {
+    get name(): "string";
+    get datatype(): "string";
+    isotime(): this;
+    regex(pattern: RegExp): this;
+    email(): this;
+    uuid(): this;
+    startsWith(prefix: string): this;
+    endsWith(suffix: string): this;
+    min(limit: number): this;
+    max(limit: number): this;
+    length(from: number, to: number): this;
+    toJSON(): {
+        type: "string";
+        datatype: "string";
+    };
 }
 //# sourceMappingURL=StringType.d.ts.map

package/lib/private/StringType.js

@@ -1,23 +1,57 @@
+import schemafail from "#error/schemafail";
 import PrimitiveType from "#PrimitiveType";
-const starts_with_validator = (prefix) => (x) => {
-    if (!x.startsWith(prefix)) {
-        throw new Error(`"${x}" does not start with "${prefix}"`);
+import Storeable from "#Storeable";
+import email from "#validator/email";
+import ends_with from "#validator/ends-with";
+import isotime from "#validator/isotime";
+import length from "#validator/length";
+import max from "#validator/max";
+import min from "#validator/min";
+import regex from "#validator/regex";
+import starts_with from "#validator/starts-with";
+import uuid from "#validator/uuid";
+export default class StringType extends PrimitiveType {
+    get name() {
+        return "string";
     }
-};
-const ends_with_validator = (suffix) => (x) => {
-    if (!x.endsWith(suffix)) {
-        throw new Error(`"${x}" does not end with "${suffix}"`);
+    get datatype() {
+        return "string";
     }
-};
-export default class StringType extends PrimitiveType {
-    constructor(validators) {
-        super("string", validators);
+    isotime() {
+        return this.derive({ validators: [isotime] });
+    }
+    regex(pattern) {
+        return this.derive({ validators: [regex(pattern)] });
+    }
+    email() {
+        return this.derive({ validators: [email] });
+    }
+    uuid() {
+        return this.derive({ validators: [uuid] });
     }
     startsWith(prefix) {
-        return new StringType([...this.validators, starts_with_validator(prefix)]);
+        return this.derive({ validators: [starts_with(prefix)] });
     }
     endsWith(suffix) {
-        return new StringType([...this.validators, ends_with_validator(suffix)]);
+        return this.derive({ validators: [ends_with(suffix)] });
+    }
+    min(limit) {
+        if (limit < 0) {
+            throw schemafail("min: {0} must be positive", limit);
+        }
+        return this.derive({ validators: [min(limit)] });
+    }
+    max(limit) {
+        if (limit < 0) {
+            throw schemafail("max: {0} must be positive", limit);
+        }
+        return this.derive({ validators: [max(limit)] });
+    }
+    length(from, to) {
+        return this.derive({ validators: [length(from, to)] });
+    }
+    toJSON() {
+        return Storeable.serialize(this);
     }
 }
 //# sourceMappingURL=StringType.js.map

package/lib/private/SymbolType.d.ts

@@ -1,5 +1,8 @@
 import PrimitiveType from "#PrimitiveType";
 export default class SymbolType extends PrimitiveType<symbol, "SymbolType"> {
-    constructor();
+    get name(): "symbol";
+    toJSON(): {
+        type: "symbol";
+    };
 }
 //# sourceMappingURL=SymbolType.d.ts.map

package/lib/private/SymbolType.js

@@ -1,7 +1,10 @@
 import PrimitiveType from "#PrimitiveType";
 export default class SymbolType extends PrimitiveType {
-    constructor() {
-        super("symbol");
+    get name() {
+        return "symbol";
+    }
+    toJSON() {
+        return { type: this.name };
     }
 }
 //# sourceMappingURL=SymbolType.js.map

package/lib/private/TupleType.d.ts

@@ -2,16 +2,23 @@ import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type InferSchema from "#InferSchema";
 import OptionalType from "#OptionalType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
 import type Schema from "#Schema";
+import type OptionalTrait from "#trait/Optional";
 type InferTuple<T extends Schema[]> = {
     [K in keyof T]: T[K] extends Schema ? InferSchema<T[K]> : "tuple-never";
 };
-export default class TupleType<T extends Schema[]> extends GenericType<T, InferTuple<T>, "TupleType"> {
+export default class TupleType<T extends Parsed<unknown>[]> extends GenericType<T, InferTuple<T>, "TupleType"> implements OptionalTrait {
     #private;
-    constructor(members: T);
+    constructor(items: T);
+    get name(): "tuple";
     optional(): OptionalType<this>;
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "tuple";
+        of: import("./Serialized.js").default[];
+    };
 }
 export {};
 //# sourceMappingURL=TupleType.d.ts.map

package/lib/private/TupleType.js

@@ -1,40 +1,34 @@
 import error from "#error";
-import expected from "#expected";
 import GenericType from "#GenericType";
-import schema from "#index";
-import is_validated_type from "#is_validated_type";
 import OptionalType from "#OptionalType";
-const member_error = (i, key) => {
-    return key === undefined
-        ? `[${i}]`
-        : `${key}[${i}]`;
-};
+import ParseError from "#ParseError";
+import next from "#path/next";
 export default class TupleType extends GenericType {
-    #members;
-    constructor(members) {
+    #items;
+    constructor(items) {
         super();
-        this.#members = members;
-    }
-    optional() {
-        return new OptionalType(this);
+        this.#items = items;
     }
     get name() {
         return "tuple";
     }
-    validate(x, key) {
+    optional() {
+        return new OptionalType(this);
+    }
+    parse(x, options = {}) {
         if (!(!!x && Array.isArray(x))) {
-            throw new Error(error(expected("array", x), key));
+            throw new ParseError(error("array", x, options));
         }
-        this.#members.forEach((v, i) => {
-            const validator = is_validated_type(v) ? v : schema(v);
-            validator.validate(x[i], `${member_error(i, key)}`);
+        this.#items.forEach((v, i) => {
+            v.parse(x[i], next(i, options));
         });
         x.forEach((v, i) => {
-            const member = this.#members[i];
-            const validator = is_validated_type(member) ? member : schema(member);
-            validator.validate(v, `${member_error(i, key)}`);
+            if (i >= this.#items.length) {
+                throw new ParseError(error("undefined", v, next(i, options)));
+            }
         });
         return x;
     }
+    toJSON() { return { type: this.name, of: this.#items.map(i => i.toJSON()) }; }
 }
 //# sourceMappingURL=TupleType.js.map

package/lib/private/Type.d.ts

@@ -1,10 +1,12 @@
 import DefaultType from "#DefaultType";
 import OptionalType from "#OptionalType";
-import Validated from "#Validated";
+import Parsed from "#Parsed";
+import type DefaultTrait from "#trait/Default";
+import type OptionalTrait from "#trait/Optional";
 import type Printable from "@rcompat/type/Printable";
-export default abstract class Type<Type, Name extends string> extends Validated<Type> implements Printable {
+export default abstract class Type<T, Name extends string> extends Parsed<T> implements Printable, DefaultTrait<T>, OptionalTrait {
     optional(): OptionalType<this>;
-    default<const S extends Type>(value: S | (() => S)): DefaultType<this, S>;
+    default<S extends T>(value: (() => S) | S): DefaultType<this, S>;
     get Name(): Name;
 }
 //# sourceMappingURL=Type.d.ts.map

package/lib/private/Type.js

@@ -1,7 +1,7 @@
 import DefaultType from "#DefaultType";
 import OptionalType from "#OptionalType";
-import Validated from "#Validated";
-export default class Type extends Validated {
+import Parsed from "#Parsed";
+export default class Type extends Parsed {
     optional() {
         return new OptionalType(this);
     }

package/lib/private/URLType.d.ts

@@ -1,5 +1,19 @@
 import BuiltinType from "#BuiltinType";
-export default class URLType extends BuiltinType<URL, "URLType"> {
-    constructor();
+import Storeable from "#Storeable";
+export default class URLType extends BuiltinType<URL, "URLType"> implements Storeable<"url"> {
+    get Type(): {
+        new (url: string | URL, base?: string | URL): URL;
+        prototype: URL;
+        canParse(url: string | URL, base?: string | URL): boolean;
+        createObjectURL(obj: Blob | MediaSource): string;
+        parse(url: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(url: string): void;
+    };
+    get name(): "url";
+    get datatype(): "url";
+    toJSON(): {
+        type: "url";
+        datatype: "url";
+    };
 }
 //# sourceMappingURL=URLType.d.ts.map

package/lib/private/URLType.js

@@ -1,7 +1,17 @@
 import BuiltinType from "#BuiltinType";
+import Storeable from "#Storeable";
 export default class URLType extends BuiltinType {
-    constructor() {
-        super("url", URL);
+    get Type() {
+        return URL;
+    }
+    get name() {
+        return "url";
+    }
+    get datatype() {
+        return "url";
+    }
+    toJSON() {
+        return Storeable.serialize(this);
     }
 }
 //# sourceMappingURL=URLType.js.map

package/lib/private/UintDataType.d.ts

@@ -0,0 +1,3 @@
+type UintDataType = "u16" | "u32" | "u8";
+export type { UintDataType as default };
+//# sourceMappingURL=UintDataType.d.ts.map

package/lib/private/UintDataType.js

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

package/lib/private/UintType.d.ts

@@ -1,9 +1,16 @@
-import type Infer from "#Infer";
-import PrimitiveType from "#PrimitiveType";
-type Name = "UintType";
-export default class UintType extends PrimitiveType<number | bigint, Name> {
-    constructor();
-    validate(x: unknown, key?: string): Infer<this>;
+import coerce from "#coerce/int";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+import type ParseOptions from "#ParseOptions";
+import type Storeable from "#Storeable";
+import type UintDataType from "#UintDataType";
+export default class UintType<T extends UintDataType> extends NumericType<T, number, "UintType"> implements Storeable<T> {
+    [CoerceKey]: typeof coerce;
+    get name(): string;
+    /**
+    * Value is a non-privileged port number (1000 - 65535).
+    */
+    port(): this;
+    parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
 }
-export {};
 //# sourceMappingURL=UintType.d.ts.map

package/lib/private/UintType.js

@@ -1,16 +1,24 @@
-import PrimitiveType from "#PrimitiveType";
-import error from "#error";
-import expected from "#expected";
-import is_int from "#is-int";
-export default class UintType extends PrimitiveType {
-    constructor() {
-        super("uint");
+import coerce from "#coerce/int";
+import CoerceKey from "#CoerceKey";
+import NumericType from "#NumericType";
+import integer from "#validator/integer";
+import port from "#validator/port";
+export default class UintType extends NumericType {
+    [CoerceKey] = coerce;
+    get name() {
+        return "number";
     }
-    validate(x, key) {
-        if (!is_int(x) || x < 0) {
-            throw new Error(error(expected("uint", x), key));
-        }
-        return x;
+    /**
+    * Value is a non-privileged port number (1000 - 65535).
+    */
+    port() {
+        return this.derive({ validators: [port] });
+    }
+    parse(x, options = {}) {
+        return super.parse(x, {
+            ...options,
+            validators: [integer],
+        });
     }
 }
 //# sourceMappingURL=UintType.js.map

package/lib/private/UndefinedType.d.ts

@@ -1,7 +1,10 @@
 import PrimitiveType from "#PrimitiveType";
 type Name = "UndefinedType";
 export default class UndefinedType extends PrimitiveType<undefined, Name> {
-    constructor();
+    get name(): "undefined";
+    toJSON(): {
+        type: "undefined";
+    };
 }
 export {};
 //# sourceMappingURL=UndefinedType.d.ts.map

package/lib/private/UndefinedType.js

@@ -1,7 +1,12 @@
 import PrimitiveType from "#PrimitiveType";
 export default class UndefinedType extends PrimitiveType {
-    constructor() {
-        super("undefined");
+    get name() {
+        return "undefined";
+    }
+    toJSON() {
+        return {
+            type: this.name,
+        };
     }
 }
 //# sourceMappingURL=UndefinedType.js.map

package/lib/private/UnionType.d.ts

@@ -1,18 +1,29 @@
+import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type InferSchema from "#InferSchema";
 import OptionalType from "#OptionalType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
 import type Schema from "#Schema";
+import type DefaultTrait from "#trait/Default";
+import type OptionalTrait from "#trait/Optional";
 import type TupleToUnion from "@rcompat/type/TupleToUnion";
 type InferUnion<T extends Schema[]> = TupleToUnion<{
     [K in keyof T]: T[K] extends Schema ? InferSchema<T[K]> : "union-never";
 }>;
-export default class UnionType<T extends Schema[]> extends GenericType<T, InferUnion<T>, "UnionType"> {
+export default class UnionType<T extends Parsed<unknown>[]> extends GenericType<T, InferUnion<T>, "UnionType"> implements OptionalTrait, DefaultTrait<InferUnion<T>> {
     #private;
-    constructor(types: T);
+    constructor(of: T);
+    get name(): "union";
+    get schema(): T;
     optional(): OptionalType<this>;
-    get name(): string;
-    validate(x: unknown, key?: string): Infer<this>;
+    default(value: (() => InferUnion<T>) | InferUnion<T>): DefaultType<this, InferUnion<T>>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "union";
+        of: import("./Serialized.js").default[];
+    };
 }
 export {};
 //# sourceMappingURL=UnionType.d.ts.map

package/lib/private/UnionType.js

@@ -1,17 +1,14 @@
-import expected from "#expected";
+import DefaultType from "#DefaultType";
+import error from "#error";
 import GenericType from "#GenericType";
 import schema from "#index";
-import is_validated_type from "#is_validated_type";
+import isParsedType from "#is-parsed-type";
 import OptionalType from "#OptionalType";
-import assert from "@rcompat/invariant/assert";
-const error = (message, key) => {
-    return key === undefined
-        ? message
-        : `${key}: ${message}`;
-};
+import ParseError from "#ParseError";
+import assert from "@rcompat/assert";
 const print = (type) => {
-    const validated = is_validated_type(type);
-    if (validated) {
+    const parsed = isParsedType(type);
+    if (parsed) {
         return type.name;
     }
     const type_of = typeof type;
@@ -28,36 +25,45 @@ const print = (type) => {
     }
     return type;
 };
-const to_union_string = (types) => `\`${types.map(t => is_validated_type(t) ? t.name : print(t)).join(" | ")}\``;
+const union_error = (types) => `\`${types.map(t => isParsedType(t) ? t.name : print(t)).join(" | ")}\``;
 export default class UnionType extends GenericType {
-    #types;
-    constructor(types) {
-        assert(types.length > 1, "union type must have at least two members");
+    #of;
+    constructor(of) {
+        assert(of.length > 1, "union type must have at least two members");
         super();
-        this.#types = types;
+        this.#of = of;
+    }
+    get name() {
+        return "union";
+    }
+    get schema() {
+        return this.#of;
     }
     optional() {
         return new OptionalType(this);
     }
-    get name() {
-        return "union";
+    default(value) {
+        return new DefaultType(this, value);
     }
-    validate(x, key) {
-        // union validates when any of its members validates
-        const validated = this.#types.some(type => {
-            const validator = is_validated_type(type) ? type : schema(type);
+    parse(x, options = {}) {
+        // union parses when any of its members parses
+        const parsed = this.#of.map(type => {
+            const validator = isParsedType(type) ? type : schema(type);
             try {
-                validator.validate(x, key);
+                validator.parse(x, options);
                 return true;
             }
-            catch {
-                return false;
+            catch (e) {
+                return e;
             }
         });
-        if (!validated) {
-            throw new Error(error(expected(to_union_string(this.#types), x), key));
+        if (!parsed.some(r => r === true)) {
+            throw new ParseError(error(union_error(this.#of), x, options));
         }
         return x;
     }
+    toJSON() {
+        return { type: this.name, of: this.#of.map(t => t.toJSON()) };
+    }
 }
 //# sourceMappingURL=UnionType.js.map

package/lib/private/UnknownType.d.ts

@@ -0,0 +1,5 @@
+import PureType from "#PureType";
+export default class UnknownType extends PureType<unknown, "unknown"> {
+    get name(): string;
+}
+//# sourceMappingURL=UnknownType.d.ts.map

package/lib/private/UnknownType.js

@@ -0,0 +1,7 @@
+import PureType from "#PureType";
+export default class UnknownType extends PureType {
+    get name() {
+        return "unknown";
+    }
+}
+//# sourceMappingURL=UnknownType.js.map

package/lib/private/Validator.d.ts

@@ -1,3 +1,3 @@
-type Validator<T = unknown> = (x: T) => void;
+type Validator<T> = (x: T) => void;
 export type { Validator as default };
 //# sourceMappingURL=Validator.d.ts.map

package/lib/private/VirtualType.d.ts

@@ -0,0 +1,6 @@
+import GenericType from "#GenericType";
+export default abstract class VirtualType<Type, Inferred, Name extends string> extends GenericType<Type, Inferred, Name> {
+    abstract get schema(): Type;
+    get datatype(): keyof import("./DataType.js").default;
+}
+//# sourceMappingURL=VirtualType.d.ts.map