pema 0.8.2 → 0.9.0

package/lib/private/ArrayType.d.ts

@@ -20,7 +20,7 @@ export default class ArrayType<T extends Parsed<unknown>, M extends Mode = undef
     get name(): "array";
     optional(): OptionalType<this>;
     default(value: (() => Infer<T>[]) | Infer<T>[]): DefaultType<this, Infer<T>[]>;
-    derive(_next: Next<Array<Infer<T>>>): this;
+    with(_next: Next<Array<Infer<T>>>): this;
     /**
      * Member values are unique — only for primitive subtypes.
      *

package/lib/private/ArrayType.js

@@ -40,7 +40,7 @@ export default class ArrayType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    derive(_next) {
+    with(_next) {
         const Constructor = this.constructor;
         return new Constructor(this.#item, this[Loose], [...this.#validators, ..._next.validators ?? []]);
     }
@@ -54,27 +54,27 @@ export default class ArrayType extends GenericType {
         if (!isPrimitive(this.#item)) {
             throw S.unique_subtype_not_primitive(this.#item.name);
         }
-        return this.derive({ validators: [unique] });
+        return this.with({ validators: [unique] });
     }
     uniqueBy(select) {
-        return this.derive({ validators: [uniqueBy(select)] });
+        return this.with({ validators: [uniqueBy(select)] });
     }
     min(limit) {
         if (limit < 0)
             throw S.min_negative(limit);
-        return this.derive({ validators: [min(limit)] });
+        return this.with({ validators: [min(limit)] });
     }
     max(limit) {
         if (limit < 0)
             throw S.max_negative(limit);
-        return this.derive({ validators: [max(limit)] });
+        return this.with({ validators: [max(limit)] });
     }
     length(from, to) {
-        return this.derive({ validators: [length(from, to)] });
+        return this.with({ validators: [length(from, to)] });
     }
     parse(u, options = {}) {
         const x = resolve(u);
-        const $options = this[Loose] !== undefined
+        const $options = is.defined(this[Loose])
             ? { ...options, [Loose]: this[Loose] }
             : options;
         const path = $options[ParsedKey] ?? "";

package/lib/private/AsyncType.d.ts

@@ -0,0 +1,18 @@
+import type Mode from "#Mode";
+import type ObjectType from "#ObjectType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type { Dict, MaybePromise } from "@rcompat/type";
+type Derive<Input, Output> = (value: Input) => MaybePromise<Output>;
+export default class AsyncType<P extends Dict<Parsed<unknown>> = Dict<Parsed<unknown>>, M extends Mode = undefined, I = ObjectType<P, M>["infer"], Output = I> {
+    #private;
+    constructor(schema: ObjectType<P, M, I>, derive?: Derive<I, Output>);
+    get infer(): Output;
+    get input(): import("./InferInputSchema.js").default<P>;
+    get schema(): ObjectType<P, M, I>;
+    get properties(): P;
+    derive<Next>(derive: Derive<Output, Next>): AsyncType<P, M, I, Awaited<Next>>;
+    parse(u: unknown, options?: ParseOptions): Promise<Output>;
+}
+export {};
+//# sourceMappingURL=AsyncType.d.ts.map

package/lib/private/AsyncType.js

@@ -0,0 +1,28 @@
+export default class AsyncType {
+    #schema;
+    #derive;
+    constructor(schema, derive = value => value) {
+        this.#schema = schema;
+        this.#derive = derive;
+    }
+    get infer() {
+        return undefined;
+    }
+    get input() {
+        return this.#schema.input;
+    }
+    get schema() {
+        return this.#schema;
+    }
+    get properties() {
+        return this.#schema.properties;
+    }
+    derive(derive) {
+        const next = async (value) => await derive(await this.#derive(value));
+        return new AsyncType(this.#schema, next);
+    }
+    async parse(u, options) {
+        return this.#derive(this.#schema.parse(u, options));
+    }
+}
+//# sourceMappingURL=AsyncType.js.map

package/lib/private/EnumType.d.ts

@@ -1,21 +1,24 @@
 import DefaultType from "#DefaultType";
-import GenericType from "#GenericType";
-import type Infer from "#Infer";
 import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
-import type OptionalTrait from "#trait/Optional";
-type Literal = string;
-export default class EnumType<T extends readonly Literal[]> extends GenericType<T, T[number], "EnumType"> implements OptionalTrait {
+import Storable from "#Storable";
+import type UintType from "#UintType";
+import type { Dict } from "@rcompat/type";
+export default class EnumType<V extends Dict<number>, L extends boolean | undefined = undefined> extends Storable<"u8", V[keyof V]> {
     #private;
-    constructor(values: T);
+    constructor(values: V, inner: UintType<"u8", L>);
     get name(): string;
+    get datatype(): "u8";
+    get values(): V;
+    nameOf(value: V[keyof V]): keyof V;
     optional(): OptionalType<this>;
-    default<D extends T[number]>(value: (() => D) | D): DefaultType<EnumType<T>, D>;
-    parse(u: unknown, options?: ParseOptions): Infer<this>;
+    default<D extends V[keyof V]>(value: (() => D) | D): DefaultType<EnumType<V, L>, D>;
+    parse(u: unknown, options?: ParseOptions): V[keyof V];
     toJSON(): {
         type: "enum";
-        values: T[number][];
+        datatype: "u8";
+        values: V;
     };
 }
-export {};
+export type Enum<V extends Dict<number>, L extends boolean | undefined = undefined> = EnumType<V, L> & V;
 //# sourceMappingURL=EnumType.d.ts.map

package/lib/private/EnumType.js

@@ -1,17 +1,35 @@
 import DefaultType from "#DefaultType";
-import E from "#errors";
-import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-import resolve from "#resolve";
-import is from "@rcompat/is";
-export default class EnumType extends GenericType {
+import S from "#schema-errors";
+import Storable from "#Storable";
+const KEY = /^[A-Z][A-Z0-9_]*$/;
+export default class EnumType extends Storable {
     #values;
-    constructor(values) {
+    #reverse;
+    #inner;
+    constructor(values, inner) {
         super();
+        for (const key of Object.keys(values)) {
+            if (!KEY.test(key))
+                throw S.enum_invalid_key(key);
+        }
         this.#values = values;
+        this.#reverse = new Map(Object.entries(values).map(([k, v]) => [v, k]));
+        this.#inner = inner.values(values);
+        Object.assign(this, values);
+        Object.freeze(this);
     }
     get name() {
-        return this.#values.map(v => `"${v}"`).join(" | ");
+        return Object.keys(this.#values).map(k => `"${k}"`).join(" | ");
+    }
+    get datatype() {
+        return "u8";
+    }
+    get values() {
+        return this.#values;
+    }
+    nameOf(value) {
+        return this.#reverse.get(value);
     }
     optional() {
         return new OptionalType(this);
@@ -20,14 +38,14 @@ export default class EnumType extends GenericType {
         return new DefaultType(this, value);
     }
     parse(u, options = {}) {
-        const x = resolve(u);
-        if (!is.string(x) || !this.#values.includes(x)) {
-            throw E.invalid_type(x, this.name, options);
-        }
-        return x;
+        return this.#inner.parse(u, options);
     }
     toJSON() {
-        return { type: "enum", values: [...this.#values] };
+        return {
+            type: "enum",
+            datatype: "u8",
+            values: { ...this.#values },
+        };
     }
 }
 //# sourceMappingURL=EnumType.js.map

package/lib/private/InferInputSchema.d.ts

@@ -5,7 +5,7 @@ import type OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type { ImpliedOptional, UndefinedToOptional } from "@rcompat/type";
-type InferInputSchema<S> = S extends DefaultType<infer T, unknown> ? T["infer"] | undefined : S extends OptionalType<infer T> ? T["infer"] | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
+type InferInputSchema<S> = S extends DefaultType<infer T, unknown> ? InferInputSchema<T> | undefined : S extends OptionalType<infer T> ? InferInputSchema<T> | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
     [K in keyof P]: InferInputSchema<P[K]>;
 }>> : S extends Parsed<unknown> ? S["infer"] : S extends {
     [key: string]: Schema;

package/lib/private/JSONType.js

@@ -24,10 +24,9 @@ export default class JSONType extends Storable {
     }
     parse(u, options = {}) {
         const x = resolve(u);
-        if (this.#inner !== undefined) {
-            // delegate to inner schema for typed validation
+        // delegate to inner schema for typed validation
+        if (is.defined(this.#inner))
             return this.#inner.parse(x, options);
-        }
         if (!is.json(x))
             throw E.invalid_type(x, "json", options);
         return JSON.parse(JSON.stringify(x));
@@ -36,7 +35,7 @@ export default class JSONType extends Storable {
         return {
             type: "json",
             datatype: "json",
-            ...(this.#inner !== undefined && { of: this.#inner.toJSON() }),
+            ...is.defined(this.#inner) && { of: this.#inner.toJSON() },
         };
     }
 }

package/lib/private/LiteralType.d.ts

@@ -2,9 +2,9 @@ import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import Loose from "#Loose";
+import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
-import type Mode from "#Mode";
 type Literal = string | boolean | number;
 export default class LiteralType<T extends Literal, M extends Mode = undefined> extends GenericType<T, T, "LiteralType"> {
     #private;

package/lib/private/NumericType.d.ts

@@ -14,7 +14,7 @@ export default abstract class NumericType<Key extends DataKey, T extends bigint
     #private;
     [Loose]: M;
     constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions);
-    derive(next: Next<T>): this;
+    with(next: Next<T>): this;
     values(anyof: Dict<T>): this;
     range(from: T, to: T): this;
     min(from: T): this;

package/lib/private/NumericType.js

@@ -12,21 +12,21 @@ export default class NumericType extends PrimitiveType {
         this.#datatype = datatype;
         this[Loose] = mode;
     }
-    derive(next) {
+    with(next) {
         const Constructor = this.constructor;
         return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
     }
     values(anyof) {
-        return this.derive({ validators: [values(anyof)] });
+        return this.with({ validators: [values(anyof)] });
     }
     range(from, to) {
-        return this.derive({ validators: [range(from, to)] });
+        return this.with({ validators: [range(from, to)] });
     }
     min(from) {
-        return this.derive({ validators: [min(from)] });
+        return this.with({ validators: [min(from)] });
     }
     max(to) {
-        return this.derive({ validators: [max(to)] });
+        return this.with({ validators: [max(to)] });
     }
     get datatype() {
         return this.#datatype;

package/lib/private/ObjectType.js

@@ -52,7 +52,7 @@ export default class ObjectType extends GenericType {
     }
     parse(u, options = {}) {
         const x = resolve(u);
-        const $options = this[Loose] !== undefined
+        const $options = is.defined(this[Loose])
             ? { ...this.#options, ...options, [Loose]: this[Loose] }
             : { ...this.#options, ...options };
         if (is.defined(x) && !is.dict(x))
@@ -61,7 +61,7 @@ export default class ObjectType extends GenericType {
         const out = {};
         for (const k in this.#properties) {
             const parsed = this.#properties[k].parse(input[k], next(k, $options));
-            if (parsed !== undefined)
+            if (is.defined(parsed))
                 out[k] = parsed;
         }
         return out;

package/lib/private/OmitType.js

@@ -28,12 +28,11 @@ export default class OmitType extends GenericType {
         const props = this.#properties;
         for (const k in props) {
             const field = props[k];
-            const r = field.parse(x[k], {
+            const parsed = field.parse(x[k], {
                 ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
             });
-            if (r !== undefined) {
-                out[k] = r;
-            }
+            if (is.defined(parsed))
+                out[k] = parsed;
         }
         return out;
     }

package/lib/private/Parsed.d.ts

@@ -11,6 +11,7 @@ export default abstract class Parsed<StaticType> implements Serializable {
     [Loose]: boolean | undefined;
     [CoerceKey](x: unknown): unknown;
     abstract get name(): string;
+    derive<Output>(derive: (value: StaticType) => Output): Parsed<Output>;
     /**
     * Parse the given value.
     *

package/lib/private/Parsed.js

@@ -15,5 +15,26 @@ export default class Parsed {
     [CoerceKey](x) {
         return x;
     }
+    derive(derive) {
+        return new DerivedType(this, derive);
+    }
+}
+class DerivedType extends Parsed {
+    #schema;
+    #derive;
+    constructor(schema, derive) {
+        super();
+        this.#schema = schema;
+        this.#derive = derive;
+    }
+    get name() {
+        return this.#schema.name;
+    }
+    parse(u, options) {
+        return this.#derive(this.#schema.parse(u, options));
+    }
+    toJSON() {
+        return this.#schema.toJSON();
+    }
 }
 //# sourceMappingURL=Parsed.js.map

package/lib/private/PartialType.js

@@ -34,11 +34,11 @@ export default class PartialType extends VirtualType {
         const issues = [];
         for (const key of Object.keys(this.#spec)) {
             // skip missing/undefined keys (partial semantics)
-            if (!(key in input) || input[key] === undefined)
+            if (!(key in input) || is.undefined(input[key]))
                 continue;
             try {
                 const parsed = this.#spec[key].parse(input[key], next(key, options));
-                if (parsed !== undefined)
+                if (is.defined(parsed))
                     out[key] = parsed;
             }
             catch (e) {

package/lib/private/PrimitiveType.d.ts

@@ -11,7 +11,7 @@ export default abstract class PrimitiveType<StaticType, Name extends string> ext
     constructor(validators?: Validator<StaticType>[], options?: ParseOptions);
     get options(): ParseOptions<unknown>;
     get validators(): Validator<StaticType>[];
-    derive(next: Next<StaticType>): this;
+    with(next: Next<StaticType>): this;
     parse(u: unknown, options?: ParseOptions<StaticType>): Infer<this>;
 }
 export {};

package/lib/private/PrimitiveType.js

@@ -5,6 +5,7 @@ import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import resolve from "#resolve";
 import Type from "#Type";
+import is from "@rcompat/is";
 export default class PrimitiveType extends Type {
     #validators;
     #options;
@@ -19,14 +20,14 @@ export default class PrimitiveType extends Type {
     get validators() {
         return this.#validators;
     }
-    derive(next) {
+    with(next) {
         const Constructor = this.constructor;
         return new Constructor([...this.#validators, ...next.validators ?? []], { ...this.#options, ...next.options ?? {} });
     }
     parse(u, options = {}) {
         const x = resolve(u);
         // hotpath: avoid object spread when possible
-        const has_instance_options = this.#options[ParsedKey] !== undefined;
+        const has_instance_options = is.defined(this.#options[ParsedKey]);
         const $options = has_instance_options
             ? { ...this.#options, ...options }
             : options;

package/lib/private/Serialized.d.ts

@@ -78,7 +78,8 @@ type StructuralSerialized = {
     properties: Dict<Serialized>;
 } | {
     type: "enum";
-    values: string[];
+    datatype: "u8";
+    values: Dict<number>;
 } | {
     type: "pure";
 } | {

package/lib/private/StoreType.js

@@ -24,7 +24,7 @@ export default class StoreType extends ObjectType {
             if (k === this.#pk && !(k in input))
                 continue;
             const parsed = this.properties[k].parse(input[k], next(k, $options));
-            if (parsed !== undefined)
+            if (is.defined(parsed))
                 out[k] = parsed;
         }
         return out;

package/lib/private/StringType.js

@@ -17,32 +17,32 @@ export default class StringType extends PrimitiveType {
         return "string";
     }
     isotime() {
-        return this.derive({ validators: [isotime] });
+        return this.with({ validators: [isotime] });
     }
     regex(pattern) {
-        return this.derive({ validators: [regex(pattern)] });
+        return this.with({ validators: [regex(pattern)] });
     }
     email() {
-        return this.derive({ validators: [email] });
+        return this.with({ validators: [email] });
     }
     startsWith(prefix) {
-        return this.derive({ validators: [starts_with(prefix)] });
+        return this.with({ validators: [starts_with(prefix)] });
     }
     endsWith(suffix) {
-        return this.derive({ validators: [ends_with(suffix)] });
+        return this.with({ validators: [ends_with(suffix)] });
     }
     min(limit) {
         if (limit < 0)
             throw E.min_negative(limit);
-        return this.derive({ validators: [min(limit)] });
+        return this.with({ validators: [min(limit)] });
     }
     max(limit) {
         if (limit < 0)
             throw E.max_negative(limit);
-        return this.derive({ validators: [max(limit)] });
+        return this.with({ validators: [max(limit)] });
     }
     length(from, to) {
-        return this.derive({ validators: [length(from, to)] });
+        return this.with({ validators: [length(from, to)] });
     }
     toJSON() {
         return Storable.serialize(this);

package/lib/private/TupleType.js

@@ -23,7 +23,7 @@ export default class TupleType extends GenericType {
         const x = resolve(u);
         if (!is.array(x))
             throw E.invalid_type(x, "array", options);
-        const $options = this[Loose] !== undefined
+        const $options = is.defined(this[Loose])
             ? { ...options, [Loose]: this[Loose] }
             : options;
         const items = this.#items;

package/lib/private/UintType.js

@@ -12,7 +12,7 @@ export default class UintType extends NumericType {
     * Value is a non-privileged port number (1000 - 65535).
     */
     port() {
-        return this.derive({ validators: [port] });
+        return this.with({ validators: [port] });
     }
     parse(u, options = {}) {
         return super.parse(u, {

package/lib/private/array.d.ts

@@ -1,10 +1,16 @@
 import ArrayType from "#ArrayType";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
+/**
+* Value is an array of the given type.
+*/
+declare const vanilla: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+declare const loose: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, true>;
+declare const strict: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, false>;
 declare const array: {
-    strict: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, false>;
-    loose: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>, true>;
-    vanilla: <const S extends Schema>(of: S) => ArrayType<NormalizeSchema<S>>;
+    strict: typeof strict;
+    loose: typeof loose;
+    vanilla: typeof vanilla;
 };
 export default array;
 //# sourceMappingURL=array.d.ts.map

package/lib/private/async.d.ts

@@ -0,0 +1,8 @@
+import AsyncType from "#AsyncType";
+import type { NormalizeSchemaObject } from "#NormalizeSchema";
+import type ObjectType from "#ObjectType";
+import type Schema from "#Schema";
+import type { Dict } from "@rcompat/type";
+declare function async_schema<const S extends Dict<Schema>>(schema: S): AsyncType<NormalizeSchemaObject<S>, undefined, ObjectType<NormalizeSchemaObject<S>>["infer"]>;
+export default async_schema;
+//# sourceMappingURL=async.d.ts.map

package/lib/private/async.js

@@ -0,0 +1,7 @@
+import AsyncType from "#AsyncType";
+import normalize from "#normalize";
+function async_schema(schema) {
+    return new AsyncType(normalize(schema));
+}
+export default async_schema;
+//# sourceMappingURL=async.js.map

package/lib/private/coerce/date.js

@@ -6,16 +6,14 @@ const ISO_DATETIME_TZ = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})
 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;
+    // for numbers we always treat as ms (no digits provided)
+    const ms = is.defined(digits) ? (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;
+    return is.defined(date) ? date : n;
 }
 function fromString(raw) {
     const s = raw.trim();

package/lib/private/constructor.d.ts

@@ -1,9 +1,15 @@
 import ConstructorType from "#ConstructorType";
 import type { AbstractNewable } from "@rcompat/type";
+/**
+ * Value is a constructed instance of the given class.
+ */
+declare const vanilla: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+declare const loose: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+declare const strict: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
 declare const constructor: {
-    vanilla: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
-    loose: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
-    strict: <const C extends AbstractNewable>(c: C) => ConstructorType<C>;
+    vanilla: typeof vanilla;
+    loose: typeof loose;
+    strict: typeof strict;
 };
 export default constructor;
 //# sourceMappingURL=constructor.d.ts.map

package/lib/private/enum.d.ts

@@ -1,11 +1,12 @@
-import EnumType from "#EnumType";
-declare function vanilla<T extends readonly string[]>(values: T): EnumType<T>;
-declare function loose<T extends readonly string[]>(values: T): EnumType<T>;
-declare function strict<T extends readonly string[]>(values: T): EnumType<T>;
+import { type Enum } from "#EnumType";
+import type { Dict } from "@rcompat/type";
+declare function vanilla<const V extends Dict<number>>(values: V): Enum<V, undefined>;
+declare function loose<const V extends Dict<number>>(values: V): Enum<V, true>;
+declare function strict<const V extends Dict<number>>(values: V): Enum<V, false>;
 declare const _default: {
+    vanilla: typeof vanilla;
     loose: typeof loose;
     strict: typeof strict;
-    vanilla: typeof vanilla;
 };
 export default _default;
 //# sourceMappingURL=enum.d.ts.map

package/lib/private/enum.js

@@ -1,12 +1,13 @@
 import EnumType from "#EnumType";
+import u8 from "#u8";
 function vanilla(values) {
-    return new EnumType(values);
+    return new EnumType(values, u8.vanilla);
 }
 function loose(values) {
-    return new EnumType(values);
+    return new EnumType(values, u8.loose);
 }
 function strict(values) {
-    return new EnumType(values);
+    return new EnumType(values, u8.strict);
 }
-export default { loose, strict, vanilla };
+export default { vanilla, loose, strict };
 //# sourceMappingURL=enum.js.map