pema 0.2.0 → 0.3.0

package/lib/private/ArrayType.d.ts

@@ -1,19 +1,22 @@
+import DefaultType from "#DefaultType";
 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 DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
 import type Validator from "#Validator";
 import type Primitive from "@rcompat/type/Primitive";
 type Next<T> = {
     validators?: Validator<T>[];
 };
-export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait {
+export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait, DefaultTrait<Infer<T>[]> {
     #private;
     constructor(item: T, validators?: Validator<Array<Infer<T>>>[]);
     get name(): "array";
     optional(): OptionalType<this>;
+    default(value: (() => Infer<T>[]) | Infer<T>[]): DefaultType<this, Infer<T>[]>;
     derive(_next: Next<Array<Infer<T>>>): this;
     /**
      * Member values are unique — only for primitive subtypes.

package/lib/private/ArrayType.js

@@ -1,3 +1,4 @@
+import DefaultType from "#DefaultType";
 import error from "#error";
 import schemafail from "#error/schemafail";
 import GenericType from "#GenericType";
@@ -30,6 +31,9 @@ export default class ArrayType extends GenericType {
     optional() {
         return new OptionalType(this);
     }
+    default(value) {
+        return new DefaultType(this, value);
+    }
     derive(_next) {
         const Constructor = this.constructor;
         return new Constructor(this.#item, [...this.#validators, ..._next.validators ?? []]);

package/lib/private/index.d.ts

@@ -3,5 +3,36 @@ 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 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,65 @@
+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 primary from "#primary";
+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.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/package.json

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