pema 0.12.0 → 0.13.0

package/lib/private/BigUintType.d.ts

@@ -3,8 +3,11 @@ import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 import type Storable from "#Storable";
-export default class BigUintType<T extends BigUintDataType = "u64", L extends boolean | undefined = undefined> extends NumericType<T, bigint, "BigUintType", L> implements Storable<T> {
+export default class BigUintType<T extends BigUintDataType = "u64", L extends boolean | undefined = undefined, G extends boolean = false> extends NumericType<T, bigint, "BigUintType", L, G> implements Storable<T> {
     [CoerceKey]: typeof coerce;
+    sequence(): BigUintType<T, L, true>;
+    default<S extends bigint>(value: (() => S) | S): import("./DefaultType.js").default<this, S>;
+    optional(): import("./OptionalType.js").default<this>;
     get name(): string;
 }
 //# sourceMappingURL=BigUintType.d.ts.map

package/lib/private/BigUintType.js

@@ -3,6 +3,21 @@ import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
 export default class BigUintType extends NumericType {
     [CoerceKey] = coerce;
+    sequence() {
+        return this.with({ sequence: true });
+    }
+    default(value) {
+        if (this.generated === "sequence") {
+            throw new TypeError("a sequence cannot also have a default value");
+        }
+        return super.default(value);
+    }
+    optional() {
+        if (this.generated === "sequence") {
+            throw new TypeError("a sequence cannot be optional in stored output");
+        }
+        return super.optional();
+    }
     get name() {
         return "bigint";
     }

package/lib/private/JSONType.d.ts

@@ -8,12 +8,13 @@ import Storable from "#Storable";
 import type { JSONValue } from "@rcompat/type";
 export type ParsedJSON = Parsed<JSONValue>;
 type JSONInput = ParsedJSON | undefined;
-type JSONInfer<S extends JSONInput> = S extends ParsedJSON ? Infer<S> : JSONValue;
-export default class JSONType<S extends JSONInput = undefined> extends Storable<"json", JSONInfer<S>> {
+type JSONInfer<S extends JSONInput, D extends boolean> = D extends true ? Record<string, JSONValue> : S extends ParsedJSON ? Infer<S> : JSONValue;
+export default class JSONType<S extends JSONInput = undefined, D extends boolean = false> extends Storable<"json", JSONInfer<S, D>> {
     #private;
-    constructor(inner?: S);
+    constructor(inner?: S, dictionary?: D);
     get name(): "json";
     get datatype(): "json";
+    dict(this: JSONType<undefined, false>): JSONType<undefined, true>;
     optional(): OptionalType<this>;
     default(value: (() => Infer<this>) | Infer<this>): DefaultType<this, Infer<this>>;
     parse(u: unknown, options?: ParseOptions): Infer<this>;
@@ -21,6 +22,7 @@ export default class JSONType<S extends JSONInput = undefined> extends Storable<
         type: "json";
         datatype: "json";
         of?: Serialized;
+        dictionary?: true;
     };
 }
 export {};

package/lib/private/JSONType.js

@@ -29,9 +29,11 @@ function json_with_undefined_object_values(x, ancestors = new Set()) {
 }
 export default class JSONType extends Storable {
     #inner;
-    constructor(inner) {
+    #dictionary;
+    constructor(inner, dictionary = false) {
         super();
         this.#inner = inner;
+        this.#dictionary = dictionary;
     }
     get name() {
         return "json";
@@ -39,6 +41,9 @@ export default class JSONType extends Storable {
     get datatype() {
         return "json";
     }
+    dict() {
+        return new JSONType(undefined, true);
+    }
     optional() {
         return new OptionalType(this);
     }
@@ -47,6 +52,9 @@ export default class JSONType extends Storable {
     }
     parse(u, options = {}) {
         const x = resolve(u);
+        if (this.#dictionary && !is.dict(x)) {
+            throw E.invalid_type(x, "dictionary", options);
+        }
         // delegate to inner schema for typed validation
         if (is.defined(this.#inner))
             return this.#inner.parse(x, options);
@@ -60,6 +68,7 @@ export default class JSONType extends Storable {
             type: "json",
             datatype: "json",
             ...is.defined(this.#inner) && { of: this.#inner.toJSON() },
+            ...this.#dictionary && { dictionary: true },
         };
     }
 }

package/lib/private/NumericType.d.ts

@@ -8,21 +8,24 @@ import type Validator from "#Validator";
 import type { Dict } from "@rcompat/type";
 type Next<T> = {
     options?: ParseOptions;
+    sequence?: boolean;
     validators?: Validator<T>[];
 };
-export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string, M extends Mode = undefined> extends PrimitiveType<T, Name> implements Storable<Key> {
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string, M extends Mode = undefined, G extends boolean = false> extends PrimitiveType<T, Name> implements Storable<Key> {
     #private;
     [Loose]: M;
-    constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions);
+    constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions, sequence?: G);
     with(next: Next<T>): this;
     values(anyof: Dict<T>): this;
     range(from: T, to: T): this;
     min(from: T): this;
     max(to: T): this;
     get datatype(): Key;
+    get generated(): G extends true ? "sequence" : undefined;
     toJSON(): {
         type: "number" | "bigint";
         datatype: Key;
+        sequence?: true | undefined;
     };
 }
 export {};

package/lib/private/NumericType.js

@@ -6,15 +6,17 @@ import range from "#validator/range";
 import values from "#validator/values";
 export default class NumericType extends PrimitiveType {
     #datatype;
+    #sequence;
     [Loose];
-    constructor(datatype, mode = undefined, validators = [], options = {}) {
+    constructor(datatype, mode = undefined, validators = [], options = {}, sequence = false) {
         super(validators, options);
         this.#datatype = datatype;
+        this.#sequence = sequence;
         this[Loose] = mode;
     }
     with(next) {
         const Constructor = this.constructor;
-        return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
+        return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} }, (next.sequence ?? this.#sequence));
     }
     values(anyof) {
         return this.with({ validators: [values(anyof)] });
@@ -31,10 +33,14 @@ export default class NumericType extends PrimitiveType {
     get datatype() {
         return this.#datatype;
     }
+    get generated() {
+        return (this.#sequence ? "sequence" : undefined);
+    }
     toJSON() {
         return {
             type: this.name,
             datatype: this.#datatype,
+            ...this.#sequence ? { sequence: true } : {},
         };
     }
 }

package/lib/private/RecordType.d.ts

@@ -22,6 +22,7 @@ export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<
         } | {
             type: "number" | "bigint";
             datatype: "f64";
+            sequence?: true | undefined;
         } | {
             type: "symbol";
         };

package/lib/private/Sequence.d.ts

@@ -0,0 +1,5 @@
+type Sequence = {
+    readonly generated: "sequence";
+};
+export type { Sequence as default };
+//# sourceMappingURL=Sequence.d.ts.map

package/lib/private/Sequence.js

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

package/lib/private/Serialized.d.ts

@@ -31,9 +31,11 @@ type PrimitiveSerialized = ({
 };
 type NumberSerialized = {
     type: "number";
+    sequence?: true;
 } & DT;
 type BigIntSerialized = {
     type: "bigint";
+    sequence?: true;
 } & DT;
 type StructuralSerialized = {
     type: "newable";
@@ -73,6 +75,7 @@ type StructuralSerialized = {
     type: "json";
     datatype: "json";
     of?: Serialized;
+    dictionary?: true;
 } | {
     type: "omit";
     properties: Dict<Serialized>;

package/lib/private/StoreType.d.ts

@@ -5,7 +5,7 @@ import PartialType from "#PartialType";
 import type StoreSchema from "#StoreSchema";
 export default class StoreType<S extends StoreSchema> extends ObjectType<S> {
     #private;
-    constructor(properties: S, pk?: string | null);
+    constructor(properties: S, pk?: string | null, sequences?: readonly string[]);
     get name(): string;
     parse(u: unknown, options?: ParseOptions): Infer<this>;
     partial(): PartialType<any, undefined>;

package/lib/private/StoreType.js

@@ -6,9 +6,11 @@ import resolve from "#resolve";
 import is from "@rcompat/is";
 export default class StoreType extends ObjectType {
     #pk;
-    constructor(properties, pk = null) {
+    #sequences;
+    constructor(properties, pk = null, sequences = []) {
         super(properties);
         this.#pk = pk;
+        this.#sequences = new Set(sequences);
     }
     get name() {
         return "store";
@@ -21,7 +23,8 @@ export default class StoreType extends ObjectType {
         const input = x ?? {};
         const out = {};
         for (const k in this.properties) {
-            if (k === this.#pk && !(k in input))
+            const generated = k === this.#pk || this.#sequences.has(k);
+            if (generated && !(k in input))
                 continue;
             const parsed = this.properties[k].parse(input[k], next(k, $options));
             if (is.defined(parsed))

package/lib/private/UintType.d.ts

@@ -4,8 +4,11 @@ import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
 import type Storable from "#Storable";
 import type UintDataType from "#UintDataType";
-export default class UintType<T extends UintDataType, L extends boolean | undefined = undefined> extends NumericType<T, number, "UintType", L> implements Storable<T> {
+export default class UintType<T extends UintDataType, L extends boolean | undefined = undefined, G extends boolean = false> extends NumericType<T, number, "UintType", L, G> implements Storable<T> {
     [CoerceKey]: typeof coerce;
+    sequence(): UintType<T, L, true>;
+    default<S extends number>(value: (() => S) | S): import("./DefaultType.js").default<this, S>;
+    optional(): import("./OptionalType.js").default<this>;
     get name(): string;
     /**
     * Value is a non-privileged port number (1000 - 65535).

package/lib/private/UintType.js

@@ -5,6 +5,21 @@ import integer from "#validator/integer";
 import port from "#validator/port";
 export default class UintType extends NumericType {
     [CoerceKey] = coerce;
+    sequence() {
+        return this.with({ sequence: true });
+    }
+    default(value) {
+        if (this.generated === "sequence") {
+            throw new TypeError("a sequence cannot also have a default value");
+        }
+        return super.default(value);
+    }
+    optional() {
+        if (this.generated === "sequence") {
+            throw new TypeError("a sequence cannot be optional in stored output");
+        }
+        return super.optional();
+    }
     get name() {
         return "number";
     }

package/lib/private/index.d.ts

@@ -27,6 +27,7 @@ export type { default as PartialType } from "#PartialType";
 export type { default as PureType } from "#PureType";
 export type { default as RecordType } from "#RecordType";
 export type { default as Schema } from "#Schema";
+export type { default as Sequence } from "#Sequence";
 export type { default as Serialized } from "#Serialized";
 export type { default as Storable } from "#Storable";
 export type { default as StoreId } from "#StoreId";
@@ -55,7 +56,7 @@ declare namespace schema {
     export { async_schema as async };
     export var _b: import("./BigIntType.js").default<"i64", undefined>;
     export { _b as bigint };
-    export var _c: import("./BigUintType.js").default<"u64", undefined>;
+    export var _c: import("./BigUintType.js").default<"u64", undefined, false>;
     export { _c as biguint };
     export var _d: import("#BlobType").default;
     export { _d as blob };
@@ -121,17 +122,17 @@ declare namespace schema {
     export { _6 as symbol };
     export var _7: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }>;
     export { _7 as tuple };
-    export var _8: import("./BigUintType.js").default<"u128", undefined>;
+    export var _8: import("./BigUintType.js").default<"u128", undefined, false>;
     export { _8 as u128 };
-    export var _9: import("#UintType").default<"u16", undefined>;
+    export var _9: import("#UintType").default<"u16", undefined, false>;
     export { _9 as u16 };
-    export var _10: import("#UintType").default<"u32", undefined>;
+    export var _10: import("#UintType").default<"u32", undefined, false>;
     export { _10 as u32 };
-    export var _11: import("./BigUintType.js").default<"u64", undefined>;
+    export var _11: import("./BigUintType.js").default<"u64", undefined, false>;
     export { _11 as u64 };
-    export var _12: import("#UintType").default<"u8", undefined>;
+    export var _12: import("#UintType").default<"u8", undefined, false>;
     export { _12 as u8 };
-    export var _13: import("#UintType").default<"u32", undefined>;
+    export var _13: import("#UintType").default<"u32", undefined, false>;
     export { _13 as uint };
     export var _14: import("#UndefinedType").default;
     export { _14 as undefined };
@@ -154,7 +155,7 @@ declare namespace schema {
 declare const loose: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
     array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, true>;
     bigint: import("./BigIntType.js").default<"i64", true>;
-    biguint: import("./BigUintType.js").default<"u64", true>;
+    biguint: import("./BigUintType.js").default<"u64", true, false>;
     blob: import("#BlobType").default;
     boolean: import("#BooleanType").default<true>;
     constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
@@ -190,12 +191,12 @@ declare const loose: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
     string: import("#StringType").default;
     symbol: import("./SymbolType.js").default;
     tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
-    u128: import("./BigUintType.js").default<"u128", true>;
-    u16: import("#UintType").default<"u16", true>;
-    u32: import("#UintType").default<"u32", true>;
-    u64: import("./BigUintType.js").default<"u64", true>;
-    u8: import("#UintType").default<"u8", true>;
-    uint: import("#UintType").default<"u32", true>;
+    u128: import("./BigUintType.js").default<"u128", true, false>;
+    u16: import("#UintType").default<"u16", true, false>;
+    u32: import("#UintType").default<"u32", true, false>;
+    u64: import("./BigUintType.js").default<"u64", true, false>;
+    u8: import("#UintType").default<"u8", true, false>;
+    uint: import("#UintType").default<"u32", true, false>;
     undefined: import("#UndefinedType").default;
     union: {
         (): import("#UnionType").default<[], true>;
@@ -208,7 +209,7 @@ declare const loose: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
 declare const strict: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
     array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, false>;
     bigint: import("./BigIntType.js").default<"i64", false>;
-    biguint: import("./BigUintType.js").default<"u64", false>;
+    biguint: import("./BigUintType.js").default<"u64", false, false>;
     blob: import("#BlobType").default;
     boolean: import("#BooleanType").default<false>;
     constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
@@ -244,12 +245,12 @@ declare const strict: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
     string: import("#StringType").default;
     symbol: import("./SymbolType.js").default;
     tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
-    u128: import("./BigUintType.js").default<"u128", false>;
-    u16: import("#UintType").default<"u16", false>;
-    u32: import("#UintType").default<"u32", false>;
-    u64: import("./BigUintType.js").default<"u64", false>;
-    u8: import("#UintType").default<"u8", false>;
-    uint: import("#UintType").default<"u32", false>;
+    u128: import("./BigUintType.js").default<"u128", false, false>;
+    u16: import("#UintType").default<"u16", false, false>;
+    u32: import("#UintType").default<"u32", false, false>;
+    u64: import("./BigUintType.js").default<"u64", false, false>;
+    u8: import("#UintType").default<"u8", false, false>;
+    uint: import("#UintType").default<"u32", false, false>;
     undefined: import("#UndefinedType").default;
     union: {
         (): import("#UnionType").default<[], false>;

package/lib/private/u128.d.ts

@@ -1,8 +1,8 @@
 import BigUintType from "#BigUintType";
 declare const u128: {
-    vanilla: BigUintType<"u128", undefined>;
-    loose: BigUintType<"u128", true>;
-    strict: BigUintType<"u128", false>;
+    vanilla: BigUintType<"u128", undefined, false>;
+    loose: BigUintType<"u128", true, false>;
+    strict: BigUintType<"u128", false, false>;
 };
 export default u128;
 //# sourceMappingURL=u128.d.ts.map

package/lib/private/u16.d.ts

@@ -1,8 +1,8 @@
 import UintType from "#UintType";
 declare const u16: {
-    vanilla: UintType<"u16", undefined>;
-    loose: UintType<"u16", true>;
-    strict: UintType<"u16", false>;
+    vanilla: UintType<"u16", undefined, false>;
+    loose: UintType<"u16", true, false>;
+    strict: UintType<"u16", false, false>;
 };
 export default u16;
 //# sourceMappingURL=u16.d.ts.map

package/lib/private/u32.d.ts

@@ -1,8 +1,8 @@
 import UintType from "#UintType";
 declare const u32: {
-    vanilla: UintType<"u32", undefined>;
-    loose: UintType<"u32", true>;
-    strict: UintType<"u32", false>;
+    vanilla: UintType<"u32", undefined, false>;
+    loose: UintType<"u32", true, false>;
+    strict: UintType<"u32", false, false>;
 };
 export default u32;
 //# sourceMappingURL=u32.d.ts.map

package/lib/private/u64.d.ts

@@ -1,8 +1,8 @@
 import BigUintType from "#BigUintType";
 declare const u64: {
-    vanilla: BigUintType<"u64", undefined>;
-    loose: BigUintType<"u64", true>;
-    strict: BigUintType<"u64", false>;
+    vanilla: BigUintType<"u64", undefined, false>;
+    loose: BigUintType<"u64", true, false>;
+    strict: BigUintType<"u64", false, false>;
 };
 export default u64;
 //# sourceMappingURL=u64.d.ts.map

package/lib/private/u8.d.ts

@@ -1,8 +1,8 @@
 import UintType from "#UintType";
 declare const u8: {
-    vanilla: UintType<"u8", undefined>;
-    loose: UintType<"u8", true>;
-    strict: UintType<"u8", false>;
+    vanilla: UintType<"u8", undefined, false>;
+    loose: UintType<"u8", true, false>;
+    strict: UintType<"u8", false, false>;
 };
 export default u8;
 //# sourceMappingURL=u8.d.ts.map

package/package.json

@@ -2,7 +2,7 @@
   "bugs": "https://github.com/primate-run/primate/issues",
   "dependencies": {
     "@rcompat/assert": "^0.16.0",
-    "@rcompat/cli": "^0.28.0",
+    "@rcompat/cli": "^0.29.0",
     "@rcompat/error": "^0.11.0",
     "@rcompat/is": "^0.14.0"
   },
@@ -48,5 +48,5 @@
     "test": "proby"
   },
   "type": "module",
-  "version": "0.12.0"
+  "version": "0.13.0"
 }