@dzeio/schema 0.0.3 → 0.0.4

package/dist/Schema.d.mts

@@ -1,5 +1,16 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
+declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
+    readonly child: Type;
+    constructor(child: Type);
+    unwrap(): Type;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<SchemaInfer<Type> | undefined>;
+    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
+    private isNull;
+}
+
 declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type> {
     '~standard': StandardSchemaV1.Props<Type>;
     /**
@@ -39,6 +50,7 @@ declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type>
     private readonly items?;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
+    defaultValue(value: Type, strict?: boolean): this;
     attrs(...attributes: Array<string>): this;
     attr(...attributes: Array<string>): this;
     setInvalidError(err: string): this;
@@ -179,17 +191,6 @@ declare class SchemaLiteral<Type> extends SchemaItem<Type> {
     isOfType(input: unknown): input is Type;
 }
 
-declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
-    readonly child: Type;
-    constructor(child: Type);
-    unwrap(): Type;
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<SchemaInfer<Type> | undefined>;
-    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
-    private isNull;
-}
-
 declare class SchemaNumber extends SchemaItem<number> {
     /**
      * validate that the number is less or equal than {@link value}
@@ -282,6 +283,7 @@ declare class SchemaUnion<T extends Array<SchemaItem>> extends SchemaItem<ItemTy
     isOfType(input: unknown): input is ItemType<T>;
 }
 
+declare function isNull(value: unknown): value is undefined | null;
 declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseFormData<T extends SchemaObject>(model: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseForm<T extends SchemaObject>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
@@ -346,4 +348,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, type ValidationResultOld, Schema as default, parceable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parceable, parseForm, parseFormData, parseQuery, s };

package/dist/Schema.d.ts

@@ -1,5 +1,16 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
+declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
+    readonly child: Type;
+    constructor(child: Type);
+    unwrap(): Type;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<SchemaInfer<Type> | undefined>;
+    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
+    private isNull;
+}
+
 declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type> {
     '~standard': StandardSchemaV1.Props<Type>;
     /**
@@ -39,6 +50,7 @@ declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type>
     private readonly items?;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
+    defaultValue(value: Type, strict?: boolean): this;
     attrs(...attributes: Array<string>): this;
     attr(...attributes: Array<string>): this;
     setInvalidError(err: string): this;
@@ -179,17 +191,6 @@ declare class SchemaLiteral<Type> extends SchemaItem<Type> {
     isOfType(input: unknown): input is Type;
 }
 
-declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
-    readonly child: Type;
-    constructor(child: Type);
-    unwrap(): Type;
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<SchemaInfer<Type> | undefined>;
-    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
-    private isNull;
-}
-
 declare class SchemaNumber extends SchemaItem<number> {
     /**
      * validate that the number is less or equal than {@link value}
@@ -282,6 +283,7 @@ declare class SchemaUnion<T extends Array<SchemaItem>> extends SchemaItem<ItemTy
     isOfType(input: unknown): input is ItemType<T>;
 }
 
+declare function isNull(value: unknown): value is undefined | null;
 declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseFormData<T extends SchemaObject>(model: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseForm<T extends SchemaObject>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
@@ -346,4 +348,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, type ValidationResultOld, Schema as default, parceable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parceable, parseForm, parseFormData, parseQuery, s };

package/dist/Schema.js

@@ -43,6 +43,7 @@ __export(Schema_exports, {
   SchemaUnion: () => SchemaUnion,
   Types: () => Types,
   default: () => Schema,
+  isNull: () => isNull,
   parceable: () => parceable,
   parseForm: () => parseForm,
   parseFormData: () => parseFormData,
@@ -56,7 +57,35 @@ var import_object_util3 = require("@dzeio/object-util");
 
 // src/SchemaItem.ts
 var import_object_util = require("@dzeio/object-util");
-var SchemaItem = class _SchemaItem {
+
+// src/items/nullable.ts
+var SchemaNullable = class extends SchemaItem {
+  constructor(child) {
+    super([child]);
+    this.child = child;
+  }
+  unwrap() {
+    return this.child;
+  }
+  parse(input, options) {
+    if (this.isNull(input)) {
+      return {
+        valid: true,
+        object: void 0
+      };
+    }
+    return this.child.parse(input, options);
+  }
+  isOfType(input) {
+    return Array.isArray(input);
+  }
+  isNull(value) {
+    return typeof value === "undefined" || value === null;
+  }
+};
+
+// src/SchemaItem.ts
+var _SchemaItem = class _SchemaItem {
   constructor(items) {
     // standard Schema V1 spec
     this["~standard"] = {
@@ -109,6 +138,15 @@ var SchemaItem = class _SchemaItem {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
+  defaultValue(value, strict = true) {
+    this.addPreProcess((input) => {
+      if (strict && isNull(input) || !strict && !input) {
+        return value;
+      }
+      return input;
+    });
+    return this;
+  }
   attrs(...attributes) {
     this.attributes.concat(attributes);
     return this;
@@ -192,6 +230,10 @@ var SchemaItem = class _SchemaItem {
     return this;
   }
 };
+__decorateClass([
+  parceable()
+], _SchemaItem.prototype, "defaultValue", 1);
+var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
 var SchemaArray = class extends SchemaItem {
@@ -282,32 +324,6 @@ __decorateClass([
   parceable()
 ], SchemaBoolean.prototype, "parseString", 1);
 
-// src/items/nullable.ts
-var SchemaNullable = class extends SchemaItem {
-  constructor(child) {
-    super([child]);
-    this.child = child;
-  }
-  unwrap() {
-    return this.child;
-  }
-  parse(input, options) {
-    if (this.isNull(input)) {
-      return {
-        valid: true,
-        object: void 0
-      };
-    }
-    return this.child.parse(input, options);
-  }
-  isOfType(input) {
-    return Array.isArray(input);
-  }
-  isNull(value) {
-    return typeof value === "undefined" || value === null;
-  }
-};
-
 // src/items/object.ts
 var import_object_util2 = require("@dzeio/object-util");
 var SchemaObject = class extends SchemaItem {
@@ -350,6 +366,9 @@ var SchemaObject = class extends SchemaItem {
 };
 
 // src/helpers.ts
+function isNull(value) {
+  return typeof value === "undefined" || value === null;
+}
 function parseQuery(model, query, opts) {
   const record = {};
   for (const [key, value] of query) {
@@ -819,6 +838,7 @@ var s = Schema;
   SchemaString,
   SchemaUnion,
   Types,
+  isNull,
   parceable,
   parseForm,
   parseFormData,

package/dist/Schema.mjs

@@ -14,7 +14,35 @@ import { objectGet, objectLoop as objectLoop2, objectSet } from "@dzeio/object-u
 
 // src/SchemaItem.ts
 import { objectClean } from "@dzeio/object-util";
-var SchemaItem = class _SchemaItem {
+
+// src/items/nullable.ts
+var SchemaNullable = class extends SchemaItem {
+  constructor(child) {
+    super([child]);
+    this.child = child;
+  }
+  unwrap() {
+    return this.child;
+  }
+  parse(input, options) {
+    if (this.isNull(input)) {
+      return {
+        valid: true,
+        object: void 0
+      };
+    }
+    return this.child.parse(input, options);
+  }
+  isOfType(input) {
+    return Array.isArray(input);
+  }
+  isNull(value) {
+    return typeof value === "undefined" || value === null;
+  }
+};
+
+// src/SchemaItem.ts
+var _SchemaItem = class _SchemaItem {
   constructor(items) {
     // standard Schema V1 spec
     this["~standard"] = {
@@ -67,6 +95,15 @@ var SchemaItem = class _SchemaItem {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
+  defaultValue(value, strict = true) {
+    this.addPreProcess((input) => {
+      if (strict && isNull(input) || !strict && !input) {
+        return value;
+      }
+      return input;
+    });
+    return this;
+  }
   attrs(...attributes) {
     this.attributes.concat(attributes);
     return this;
@@ -150,6 +187,10 @@ var SchemaItem = class _SchemaItem {
     return this;
   }
 };
+__decorateClass([
+  parceable()
+], _SchemaItem.prototype, "defaultValue", 1);
+var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
 var SchemaArray = class extends SchemaItem {
@@ -240,32 +281,6 @@ __decorateClass([
   parceable()
 ], SchemaBoolean.prototype, "parseString", 1);
 
-// src/items/nullable.ts
-var SchemaNullable = class extends SchemaItem {
-  constructor(child) {
-    super([child]);
-    this.child = child;
-  }
-  unwrap() {
-    return this.child;
-  }
-  parse(input, options) {
-    if (this.isNull(input)) {
-      return {
-        valid: true,
-        object: void 0
-      };
-    }
-    return this.child.parse(input, options);
-  }
-  isOfType(input) {
-    return Array.isArray(input);
-  }
-  isNull(value) {
-    return typeof value === "undefined" || value === null;
-  }
-};
-
 // src/items/object.ts
 import { isObject, objectClone, objectLoop } from "@dzeio/object-util";
 var SchemaObject = class extends SchemaItem {
@@ -308,6 +323,9 @@ var SchemaObject = class extends SchemaItem {
 };
 
 // src/helpers.ts
+function isNull(value) {
+  return typeof value === "undefined" || value === null;
+}
 function parseQuery(model, query, opts) {
   const record = {};
   for (const [key, value] of query) {
@@ -777,6 +795,7 @@ export {
   SchemaUnion,
   Types,
   Schema as default,
+  isNull,
   parceable,
   parseForm,
   parseFormData,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dzeio/schema",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"dependencies": {
 		"@dzeio/object-util": "^1.8.3"
 	},