pema 0.2.1 → 0.4.0

package/lib/private/OmitType.d.ts

@@ -0,0 +1,20 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import type ObjectType from "#ObjectType";
+import type Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type Serialized from "#Serialized";
+import type Dict from "@rcompat/type/Dict";
+export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P> extends GenericType<Omit<P, K>, Omit<{
+    [Key in keyof P]: Infer<P[Key]>;
+}, K>, "OmitType"> {
+    #private;
+    constructor(type: ObjectType<P>, keys: K[]);
+    get name(): "omit";
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "omit";
+        properties: Dict<Serialized>;
+    };
+}
+//# sourceMappingURL=OmitType.d.ts.map

package/lib/private/OmitType.js

@@ -0,0 +1,43 @@
+import GenericType from "#GenericType";
+import ParsedKey from "#ParsedKey";
+import join from "#path/join";
+export default class OmitType extends GenericType {
+    #properties;
+    constructor(type, keys) {
+        super();
+        const props = { ...type.properties };
+        for (const key of keys) {
+            delete props[key];
+        }
+        this.#properties = props;
+    }
+    get name() {
+        return "omit";
+    }
+    parse(x, options = {}) {
+        if (typeof x !== "object" || x === null) {
+            throw new Error("Expected object");
+        }
+        const result = {};
+        const props = this.#properties;
+        for (const k in props) {
+            const field = props[k];
+            const r = field.parse(x[k], {
+                ...options, [ParsedKey]: join(options[ParsedKey] ?? "", String(k)),
+            });
+            if (r !== undefined) {
+                result[k] = r;
+            }
+        }
+        return result;
+    }
+    toJSON() {
+        const properties = {};
+        const props = this.#properties;
+        for (const [k, v] of Object.entries(props)) {
+            properties[k] = v.toJSON();
+        }
+        return { type: "omit", properties };
+    }
+}
+//# sourceMappingURL=OmitType.js.map

package/lib/private/Serialized.d.ts

@@ -62,6 +62,9 @@ type StructuralSerialized = {
 } | {
     type: "schema";
     of: Serialized;
+} | {
+    type: "omit";
+    properties: Dict<Serialized>;
 } | {
     type: "pure";
 } | {

package/lib/private/StoreType.d.ts

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

package/lib/private/StoreType.js

@@ -1,45 +1,14 @@
-import GenericType from "#GenericType";
-import ParsedKey from "#ParsedKey";
+import ObjectType from "#ObjectType";
 import PartialType from "#PartialType";
-import join from "#path/join";
-export default class StoreType extends GenericType {
-    #properties;
+export default class StoreType extends ObjectType {
     constructor(spec) {
-        super();
-        this.#properties = spec;
+        super(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 };
+        return new PartialType(this.properties);
     }
 }
 //# sourceMappingURL=StoreType.js.map

package/lib/private/index.d.ts

@@ -3,5 +3,38 @@ import type Schema from "#Schema";
 /**
 * Create a schema.
 */
-export default function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
+declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
+declare namespace schema {
+    var array: typeof import("#array").default;
+    var bigint: import("./BigIntType.js").default<"i64">;
+    var biguint: import("./BigUintType.js").default<"u64">;
+    var blob: import("./BlobType.js").default;
+    var boolean: import("./BooleanType.js").default;
+    var constructor: <const C extends import("@rcompat/type/AbstractNewable").default>(constructor: C) => import("./ConstructorType.js").default<C>;
+    var date: import("./DateType.js").default;
+    var f32: import("./NumberType.js").default<"f32">;
+    var f64: import("./NumberType.js").default<"f64">;
+    var file: import("./FileType.js").default;
+    var i128: import("./BigIntType.js").default<"i128">;
+    var i16: import("./IntType.js").default<"i16">;
+    var i32: import("./IntType.js").default<"i32">;
+    var i64: import("./BigIntType.js").default<"i64">;
+    var i8: import("./IntType.js").default<"i8">;
+    var int: import("./IntType.js").default<"i32">;
+    var number: import("./NumberType.js").default<"f64">;
+    var omit: typeof import("#omit").default;
+    var record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("./Parsed.js").default<unknown>>(k: Key, v: Value) => import("./RecordType.js").default<Key, Value>;
+    var primary: import("./PrimaryType.js").default;
+    var string: import("./StringType.js").default;
+    var symbol: import("./SymbolType.js").default;
+    var u128: import("./BigUintType.js").default<"u128">;
+    var u16: import("./UintType.js").default<"u16">;
+    var u32: import("./UintType.js").default<"u32">;
+    var u64: import("./BigUintType.js").default<"u64">;
+    var u8: import("./UintType.js").default<"u8">;
+    var uint: import("./UintType.js").default<"u32">;
+    var union: typeof import("#union").default;
+    var unknown: import("./UnknownType.js").default;
+}
+export default schema;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -1,8 +1,69 @@
+import array from "#array";
+import bigint from "#bigint";
+import biguint from "#biguint";
+import blob from "#blob";
+import boolean from "#boolean";
+import constructor from "#constructor";
+import date from "#date";
+import f32 from "#f32";
+import f64 from "#f64";
+import file from "#file";
+import i128 from "#i128";
+import i16 from "#i16";
+import i32 from "#i32";
+import i64 from "#i64";
+import i8 from "#i8";
+import int from "#int";
 import normalize from "#normalize";
+import number from "#number";
+import omit from "#omit";
+import primary from "#primary";
+import record from "#record";
+import string from "#string";
+import symbol from "#symbol";
+import u128 from "#u128";
+import u16 from "#u16";
+import u32 from "#u32";
+import u64 from "#u64";
+import u8 from "#u8";
+import uint from "#uint";
+import union from "#union";
+import unknown from "#unknown";
 /**
 * Create a schema.
 */
-export default function schema(s) {
+function schema(s) {
     return normalize(s);
 }
+schema.array = array;
+schema.bigint = bigint;
+schema.biguint = biguint;
+schema.blob = blob;
+schema.boolean = boolean;
+schema.constructor = constructor;
+schema.date = date;
+schema.f32 = f32;
+schema.f64 = f64;
+schema.file = file;
+schema.i128 = i128;
+schema.i16 = i16;
+schema.i32 = i32;
+schema.i64 = i64;
+schema.i8 = i8;
+schema.int = int;
+schema.number = number;
+schema.omit = omit;
+schema.record = record;
+schema.primary = primary;
+schema.string = string;
+schema.symbol = symbol;
+schema.u128 = u128;
+schema.u16 = u16;
+schema.u32 = u32;
+schema.u64 = u64;
+schema.u8 = u8;
+schema.uint = uint;
+schema.union = union;
+schema.unknown = unknown;
+export default schema;
 //# sourceMappingURL=index.js.map

package/lib/private/omit.d.ts

@@ -0,0 +1,6 @@
+import type ObjectType from "#ObjectType";
+import OmitType from "#OmitType";
+import type Parsed from "#Parsed";
+import type Dict from "@rcompat/type/Dict";
+export default function omit<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
+//# sourceMappingURL=omit.d.ts.map

package/lib/private/omit.js

@@ -0,0 +1,5 @@
+import OmitType from "#OmitType";
+export default function omit(type, ...keys) {
+    return new OmitType(type, keys);
+}
+//# sourceMappingURL=omit.js.map

package/lib/public/OmitType.d.ts

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

package/lib/public/OmitType.js

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

package/lib/public/index.d.ts

@@ -1,3 +1,4 @@
+export { default as ConstructorType } from "#ConstructorType";
 export { default as DefaultType } from "#DefaultType";
 export { default } from "#index";
 export { default as LiteralType } from "#LiteralType";
@@ -5,4 +6,6 @@ export { default as ObjectType } from "#ObjectType";
 export { default as OptionalType } from "#OptionalType";
 export { default as PureType } from "#PureType";
 export { default as TupleType } from "#TupleType";
+export { default as UndefinedType } from "#UndefinedType";
+export { default as ArrayType } from "#ArrayType";
 //# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -1,3 +1,4 @@
+export { default as ConstructorType } from "#ConstructorType";
 export { default as DefaultType } from "#DefaultType";
 export { default } from "#index";
 export { default as LiteralType } from "#LiteralType";
@@ -5,4 +6,6 @@ export { default as ObjectType } from "#ObjectType";
 export { default as OptionalType } from "#OptionalType";
 export { default as PureType } from "#PureType";
 export { default as TupleType } from "#TupleType";
+export { default as UndefinedType } from "#UndefinedType";
+export { default as ArrayType } from "#ArrayType";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pema",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Primate schema validation",
   "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",