@dzeio/schema 0.0.2 → 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;
@@ -121,6 +133,10 @@ type ModelInfer$1<M extends Model> = {
 	[key in keyof M]: SchemaInfer<M[key]>
 }
 
+declare class SchemaAny extends SchemaItem {
+    isOfType(input: unknown): input is any;
+}
+
 declare class SchemaDate extends SchemaItem<Date> {
     isOfType(input: unknown): input is Date;
 }
@@ -175,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}
@@ -278,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']>;
@@ -285,6 +291,7 @@ declare function parseForm<T extends SchemaObject>(model: T, form: HTMLFormEleme
 declare function parceable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
 declare const Types: {
+    readonly Any: typeof SchemaAny;
     readonly Array: typeof SchemaArray;
     readonly Boolean: typeof SchemaBoolean;
     readonly Date: typeof SchemaDate;
@@ -300,6 +307,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     private static registeredModules;
     static register(module: SchemaItemStatic): void;
     static getModule(name: string): SchemaItemStatic | undefined;
+    static any(): SchemaAny;
     static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
     static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
     static date(...inputs: ConstructorParameters<typeof SchemaDate>): SchemaDate;
@@ -340,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, 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;
@@ -121,6 +133,10 @@ type ModelInfer$1<M extends Model> = {
 	[key in keyof M]: SchemaInfer<M[key]>
 }
 
+declare class SchemaAny extends SchemaItem {
+    isOfType(input: unknown): input is any;
+}
+
 declare class SchemaDate extends SchemaItem<Date> {
     isOfType(input: unknown): input is Date;
 }
@@ -175,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}
@@ -278,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']>;
@@ -285,6 +291,7 @@ declare function parseForm<T extends SchemaObject>(model: T, form: HTMLFormEleme
 declare function parceable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
 declare const Types: {
+    readonly Any: typeof SchemaAny;
     readonly Array: typeof SchemaArray;
     readonly Boolean: typeof SchemaBoolean;
     readonly Date: typeof SchemaDate;
@@ -300,6 +307,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     private static registeredModules;
     static register(module: SchemaItemStatic): void;
     static getModule(name: string): SchemaItemStatic | undefined;
+    static any(): SchemaAny;
     static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
     static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
     static date(...inputs: ConstructorParameters<typeof SchemaDate>): SchemaDate;
@@ -340,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, 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

@@ -28,6 +28,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 // src/Schema.ts
 var Schema_exports = {};
 __export(Schema_exports, {
+  SchemaAny: () => SchemaAny,
   SchemaArray: () => SchemaArray,
   SchemaBoolean: () => SchemaBoolean,
   SchemaDate: () => SchemaDate,
@@ -42,6 +43,7 @@ __export(Schema_exports, {
   SchemaUnion: () => SchemaUnion,
   Types: () => Types,
   default: () => Schema,
+  isNull: () => isNull,
   parceable: () => parceable,
   parseForm: () => parseForm,
   parseFormData: () => parseFormData,
@@ -55,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"] = {
@@ -108,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;
@@ -191,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 {
@@ -281,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 {
@@ -349,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) {
@@ -393,6 +413,14 @@ function parseForm(model, form, opts) {
   return parseFormData(model, new FormData(form), opts);
 }
 
+// src/items/any.ts
+var SchemaAny = class extends SchemaItem {
+  // @ts-expect-error input while not used is necessary for the `override to work`
+  isOfType(input) {
+    return true;
+  }
+};
+
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
   isOfType(input) {
@@ -667,6 +695,7 @@ function parceable() {
   };
 }
 var Types = {
+  Any: SchemaAny,
   Array: SchemaArray,
   Boolean: SchemaBoolean,
   Date: SchemaDate,
@@ -685,6 +714,9 @@ var _Schema = class _Schema extends SchemaObject {
   static getModule(name) {
     return this.registeredModules.find((it) => it.name === name);
   }
+  static any() {
+    return new SchemaAny();
+  }
   static array(...inputs) {
     return new SchemaArray(...inputs);
   }
@@ -792,6 +824,7 @@ var Schema = _Schema;
 var s = Schema;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  SchemaAny,
   SchemaArray,
   SchemaBoolean,
   SchemaDate,
@@ -805,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) {
@@ -352,6 +370,14 @@ function parseForm(model, form, opts) {
   return parseFormData(model, new FormData(form), opts);
 }
 
+// src/items/any.ts
+var SchemaAny = class extends SchemaItem {
+  // @ts-expect-error input while not used is necessary for the `override to work`
+  isOfType(input) {
+    return true;
+  }
+};
+
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
   isOfType(input) {
@@ -626,6 +652,7 @@ function parceable() {
   };
 }
 var Types = {
+  Any: SchemaAny,
   Array: SchemaArray,
   Boolean: SchemaBoolean,
   Date: SchemaDate,
@@ -644,6 +671,9 @@ var _Schema = class _Schema extends SchemaObject {
   static getModule(name) {
     return this.registeredModules.find((it) => it.name === name);
   }
+  static any() {
+    return new SchemaAny();
+  }
   static array(...inputs) {
     return new SchemaArray(...inputs);
   }
@@ -750,6 +780,7 @@ _Schema.registeredModules = [
 var Schema = _Schema;
 var s = Schema;
 export {
+  SchemaAny,
   SchemaArray,
   SchemaBoolean,
   SchemaDate,
@@ -764,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.2",
+	"version": "0.0.4",
 	"dependencies": {
 		"@dzeio/object-util": "^1.8.3"
 	},