@dzeio/schema 0.7.0 → 0.9.0

package/dist/Schema.d.mts

@@ -3,6 +3,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
     readonly _output: Output;
     readonly _input: Input;
+    static id: string;
     '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
@@ -163,11 +164,13 @@ type ModelInfer$1<M extends Model> = {
 type Literal = string | number | bigint | boolean | null | undefined
 
 declare class SchemaAny extends SchemaItem {
+    static id: string;
     isOfType(_input: unknown): _input is any;
 }
 
 type DateFormat = 'default' | 'iso8601' | 'yy-mm-dd' | 'jj/mm/yy';
 declare class SchemaDate extends SchemaItem<Date> {
+    static id: string;
     parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
@@ -175,6 +178,7 @@ declare class SchemaDate extends SchemaItem<Date> {
 declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
     private readonly keys;
     private readonly values;
+    static id: string;
     constructor(keys: Keys, values: Values);
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
@@ -185,6 +189,7 @@ declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Va
 
 declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
     readonly values: Child;
+    static id: string;
     constructor(values: Child);
     /**
      * transform the array so it only contains one of each elements
@@ -206,6 +211,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
+    static id: string;
     /**
      * @param [trueValue='true'] the truhty value (default to `'true'`)
      * @param [falseValue='false'] the falthy value (default to `'false'`)
@@ -220,12 +226,14 @@ interface EnumLike {
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     private readonly templateEnum;
+    static id: string;
     private readonly type;
     constructor(templateEnum: E);
     isOfType(input: unknown): input is E[keyof E];
 }
 
 declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    static id: string;
     private readonly values;
     constructor(...values: Types);
     isOfType(input: unknown): input is Types[number];
@@ -233,6 +241,7 @@ declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Typ
 
 declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
     private readonly child;
+    static id: string;
     constructor(child: Child);
     falsyAsNull(): this;
     emptyAsNull(): this;
@@ -251,6 +260,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
+    static id: string;
     /**
      * validate that the number is less or equal than {@link value}
      * @param value the maxumum value (inclusive)
@@ -289,7 +299,7 @@ type ModelInfer<M extends Record<string, SchemaItem>> = {
 };
 declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
     readonly model: T;
-    id: string;
+    static id: string;
     constructor(model: T);
     isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
@@ -300,6 +310,7 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
 }
 
 declare class SchemaString extends SchemaItem<string> {
+    static id: string;
     /**
      * force the input text to be a minimum of `value` size
      * @param value the minimum length of the text
@@ -340,6 +351,7 @@ declare class SchemaString extends SchemaItem<string> {
 }
 
 declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -354,6 +366,7 @@ type Prettify<T> = T extends unknown ? {
 } : never;
 type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -367,6 +380,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly child;
     private readonly defaultVal;
     private readonly strict;
+    static id: string;
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
     isOfType(input: unknown): input is Output;
@@ -378,6 +392,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
 }
 
 declare class SchemaFile extends SchemaItem<File> {
+    static id: string;
     constructor();
     extension(ext: string, error?: string): this;
     maxSize(size: number, error?: string): this;
@@ -387,6 +402,7 @@ declare class SchemaFile extends SchemaItem<File> {
 type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result['length']]>]>;
 type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result['length']]>]>;
 declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToOutputs<Children>, Inputs = TupleToInputs<Children>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly children;
     constructor(...children: Children);
     isOfType(input: unknown): input is Outputs;
@@ -398,18 +414,23 @@ declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToO
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
+    static id: string;
     isOfType(input: unknown): input is undefined;
 }
 declare class SchemaNull extends SchemaItem<null> {
+    static id: string;
     isOfType(input: unknown): input is null;
 }
 declare class SchemaVoid extends SchemaItem<void> {
+    static id: string;
     isOfType(input: unknown): input is void;
 }
 declare class SchemaNullish extends SchemaItem<null | undefined> {
+    static id: string;
     isOfType(input: unknown): input is null | undefined;
 }
 declare class SchemaNever extends SchemaItem<never> {
+    static id: string;
     isOfType(_input: unknown): _input is never;
 }
 
@@ -425,7 +446,9 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
  */
 declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
-type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
+type SchemaItemStatic = (new (...args: Array<any>) => SchemaItem) & {
+    id: string;
+};
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
     private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;

package/dist/Schema.d.ts

@@ -3,6 +3,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
     readonly _output: Output;
     readonly _input: Input;
+    static id: string;
     '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
@@ -163,11 +164,13 @@ type ModelInfer$1<M extends Model> = {
 type Literal = string | number | bigint | boolean | null | undefined
 
 declare class SchemaAny extends SchemaItem {
+    static id: string;
     isOfType(_input: unknown): _input is any;
 }
 
 type DateFormat = 'default' | 'iso8601' | 'yy-mm-dd' | 'jj/mm/yy';
 declare class SchemaDate extends SchemaItem<Date> {
+    static id: string;
     parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
@@ -175,6 +178,7 @@ declare class SchemaDate extends SchemaItem<Date> {
 declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
     private readonly keys;
     private readonly values;
+    static id: string;
     constructor(keys: Keys, values: Values);
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
@@ -185,6 +189,7 @@ declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Va
 
 declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
     readonly values: Child;
+    static id: string;
     constructor(values: Child);
     /**
      * transform the array so it only contains one of each elements
@@ -206,6 +211,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
+    static id: string;
     /**
      * @param [trueValue='true'] the truhty value (default to `'true'`)
      * @param [falseValue='false'] the falthy value (default to `'false'`)
@@ -220,12 +226,14 @@ interface EnumLike {
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     private readonly templateEnum;
+    static id: string;
     private readonly type;
     constructor(templateEnum: E);
     isOfType(input: unknown): input is E[keyof E];
 }
 
 declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    static id: string;
     private readonly values;
     constructor(...values: Types);
     isOfType(input: unknown): input is Types[number];
@@ -233,6 +241,7 @@ declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Typ
 
 declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
     private readonly child;
+    static id: string;
     constructor(child: Child);
     falsyAsNull(): this;
     emptyAsNull(): this;
@@ -251,6 +260,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
+    static id: string;
     /**
      * validate that the number is less or equal than {@link value}
      * @param value the maxumum value (inclusive)
@@ -289,7 +299,7 @@ type ModelInfer<M extends Record<string, SchemaItem>> = {
 };
 declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
     readonly model: T;
-    id: string;
+    static id: string;
     constructor(model: T);
     isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
@@ -300,6 +310,7 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
 }
 
 declare class SchemaString extends SchemaItem<string> {
+    static id: string;
     /**
      * force the input text to be a minimum of `value` size
      * @param value the minimum length of the text
@@ -340,6 +351,7 @@ declare class SchemaString extends SchemaItem<string> {
 }
 
 declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -354,6 +366,7 @@ type Prettify<T> = T extends unknown ? {
 } : never;
 type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -367,6 +380,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly child;
     private readonly defaultVal;
     private readonly strict;
+    static id: string;
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
     isOfType(input: unknown): input is Output;
@@ -378,6 +392,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
 }
 
 declare class SchemaFile extends SchemaItem<File> {
+    static id: string;
     constructor();
     extension(ext: string, error?: string): this;
     maxSize(size: number, error?: string): this;
@@ -387,6 +402,7 @@ declare class SchemaFile extends SchemaItem<File> {
 type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result['length']]>]>;
 type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result['length']]>]>;
 declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToOutputs<Children>, Inputs = TupleToInputs<Children>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly children;
     constructor(...children: Children);
     isOfType(input: unknown): input is Outputs;
@@ -398,18 +414,23 @@ declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToO
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
+    static id: string;
     isOfType(input: unknown): input is undefined;
 }
 declare class SchemaNull extends SchemaItem<null> {
+    static id: string;
     isOfType(input: unknown): input is null;
 }
 declare class SchemaVoid extends SchemaItem<void> {
+    static id: string;
     isOfType(input: unknown): input is void;
 }
 declare class SchemaNullish extends SchemaItem<null | undefined> {
+    static id: string;
     isOfType(input: unknown): input is null | undefined;
 }
 declare class SchemaNever extends SchemaItem<never> {
+    static id: string;
     isOfType(_input: unknown): _input is never;
 }
 
@@ -425,7 +446,9 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
  */
 declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
-type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
+type SchemaItemStatic = (new (...args: Array<any>) => SchemaItem) & {
+    id: string;
+};
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
     private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;

package/dist/Schema.js

@@ -211,7 +211,7 @@ var _SchemaItem = class _SchemaItem {
   toJSON() {
     var _a;
     const res = {
-      _i: this.constructor.name,
+      _i: this.constructor.id,
       a: this.attributes.length > 0 ? this.attributes : void 0,
       c: (_a = this.items) == null ? void 0 : _a.map((it) => this.deepSerializeItem(it)),
       f: this.savedCalls.map((it) => it.args ? { n: it.name, a: Array.from(it.args) } : { n: it.name })
@@ -280,6 +280,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], _SchemaItem.prototype, "in", 1);
+__decorateClass([
+  parsable()
+], _SchemaItem.prototype, "setInvalidError", 1);
 var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
@@ -310,6 +313,7 @@ var SchemaArray = class extends SchemaItem {
     return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
+SchemaArray.id = "array";
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
@@ -341,6 +345,7 @@ var SchemaBoolean = class extends SchemaItem {
     return typeof input === "boolean";
   }
 };
+SchemaBoolean.id = "boolean";
 __decorateClass([
   parsable()
 ], SchemaBoolean.prototype, "parseString", 1);
@@ -379,6 +384,7 @@ var SchemaNullable = class extends SchemaItem {
     return super.parseSubItems(input, options);
   }
 };
+SchemaNullable.id = "nullable";
 __decorateClass([
   parsable()
 ], SchemaNullable.prototype, "falsyAsNull", 1);
@@ -395,7 +401,6 @@ var SchemaObject = class extends SchemaItem {
   constructor(model) {
     super([model]);
     this.model = model;
-    this.id = "object";
   }
   isOfType(input) {
     return (0, import_object_util2.isObject)(input) && !(0, import_object_util2.objectFind)(this.model, (item, key) => !item.isOfType(input[key]));
@@ -404,6 +409,7 @@ var SchemaObject = class extends SchemaItem {
     return (0, import_object_util2.isObject)(input) ? (0, import_object_util2.objectMap)(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
+SchemaObject.id = "object";
 
 // src/helpers.ts
 function isNull(value) {
@@ -443,8 +449,8 @@ function parseFormData(schema, data, opts) {
     if (value instanceof SchemaObject) {
       handleSchemaForBoolean(value.model, keys);
     }
-    if (value instanceof SchemaBoolean) {
-      (0, import_object_util3.objectSet)(record, keys, !!data.get(keys.join(".")));
+    if (value instanceof SchemaBoolean && typeof (0, import_object_util3.objectGet)(record, keys) === "undefined") {
+      (0, import_object_util3.objectSet)(record, keys, false);
     }
   };
   const handleSchemaForBoolean = (model, keys = []) => {
@@ -488,6 +494,7 @@ var SchemaAny = class extends SchemaItem {
     return true;
   }
 };
+SchemaAny.id = "any";
 
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
@@ -531,6 +538,7 @@ var SchemaDate = class extends SchemaItem {
     return input instanceof Date;
   }
 };
+SchemaDate.id = "date";
 __decorateClass([
   parsable()
 ], SchemaDate.prototype, "parseString", 1);
@@ -569,6 +577,7 @@ var SchemaRecord = class extends SchemaItem {
     return result;
   }
 };
+SchemaRecord.id = "record";
 
 // src/items/enum.ts
 var SchemaEnum = class extends SchemaItem {
@@ -589,6 +598,7 @@ var SchemaEnum = class extends SchemaItem {
     return typeof input === this.type;
   }
 };
+SchemaEnum.id = "enum";
 
 // src/items/literal.ts
 var SchemaLiteral = class extends SchemaItem {
@@ -601,6 +611,7 @@ var SchemaLiteral = class extends SchemaItem {
     return this.values.some((it) => typeof input === typeof it);
   }
 };
+SchemaLiteral.id = "literal";
 
 // src/items/number.ts
 var SchemaNumber = class extends SchemaItem {
@@ -654,6 +665,7 @@ var SchemaNumber = class extends SchemaItem {
     return this.lte(...params);
   }
 };
+SchemaNumber.id = "number";
 __decorateClass([
   parsable()
 ], SchemaNumber.prototype, "lte", 1);
@@ -732,6 +744,7 @@ var SchemaString = class extends SchemaItem {
     return typeof input === "string";
   }
 };
+SchemaString.id = "string";
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "min", 1);
@@ -773,6 +786,7 @@ var SchemaUnion = class extends SchemaItem {
     return result;
   }
 };
+SchemaUnion.id = "union";
 
 // src/items/intersection.ts
 var import_object_util5 = require("@dzeio/object-util");
@@ -801,6 +815,7 @@ var SchemaIntersection = class extends SchemaItem {
     return result;
   }
 };
+SchemaIntersection.id = "intersection";
 
 // src/items/default.ts
 var SchemaDefault = class extends SchemaItem {
@@ -820,6 +835,7 @@ var SchemaDefault = class extends SchemaItem {
     return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
   }
 };
+SchemaDefault.id = "default";
 
 // src/items/file.ts
 var SchemaFile = class extends SchemaItem {
@@ -839,6 +855,7 @@ var SchemaFile = class extends SchemaItem {
     return input instanceof File;
   }
 };
+SchemaFile.id = "file";
 __decorateClass([
   parsable()
 ], SchemaFile.prototype, "extension", 1);
@@ -867,6 +884,7 @@ var SchemaTuple = class extends SchemaItem {
     return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
   }
 };
+SchemaTuple.id = "tuple";
 
 // src/items/nullish.ts
 var SchemaUndefined = class extends SchemaItem {
@@ -874,26 +892,31 @@ var SchemaUndefined = class extends SchemaItem {
     return typeof input === "undefined";
   }
 };
+SchemaUndefined.id = "undefined";
 var SchemaNull = class extends SchemaItem {
   isOfType(input) {
     return input === null;
   }
 };
+SchemaNull.id = "null";
 var SchemaVoid = class extends SchemaItem {
   isOfType(input) {
     return typeof input === "undefined";
   }
 };
+SchemaVoid.id = "void";
 var SchemaNullish = class extends SchemaItem {
   isOfType(input) {
     return isNull(input);
   }
 };
+SchemaNullish.id = "nullish";
 var SchemaNever = class extends SchemaItem {
   isOfType(_input) {
     return false;
   }
 };
+SchemaNever.id = "never";
 
 // src/Schema.ts
 var import_object_util6 = require("@dzeio/object-util");
@@ -916,7 +939,7 @@ var _Schema = class _Schema extends SchemaObject {
     this.registeredModules.push(module2);
   }
   static getModule(name) {
-    const module2 = this.registeredModules.find((it) => it.name === name);
+    const module2 = this.registeredModules.find((it) => it.id === name);
     if (!module2) {
       console.log("Couldn't find module", name);
     }

package/dist/Schema.mjs

@@ -161,7 +161,7 @@ var _SchemaItem = class _SchemaItem {
   toJSON() {
     var _a;
     const res = {
-      _i: this.constructor.name,
+      _i: this.constructor.id,
       a: this.attributes.length > 0 ? this.attributes : void 0,
       c: (_a = this.items) == null ? void 0 : _a.map((it) => this.deepSerializeItem(it)),
       f: this.savedCalls.map((it) => it.args ? { n: it.name, a: Array.from(it.args) } : { n: it.name })
@@ -230,6 +230,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], _SchemaItem.prototype, "in", 1);
+__decorateClass([
+  parsable()
+], _SchemaItem.prototype, "setInvalidError", 1);
 var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
@@ -260,6 +263,7 @@ var SchemaArray = class extends SchemaItem {
     return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
+SchemaArray.id = "array";
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
@@ -291,6 +295,7 @@ var SchemaBoolean = class extends SchemaItem {
     return typeof input === "boolean";
   }
 };
+SchemaBoolean.id = "boolean";
 __decorateClass([
   parsable()
 ], SchemaBoolean.prototype, "parseString", 1);
@@ -329,6 +334,7 @@ var SchemaNullable = class extends SchemaItem {
     return super.parseSubItems(input, options);
   }
 };
+SchemaNullable.id = "nullable";
 __decorateClass([
   parsable()
 ], SchemaNullable.prototype, "falsyAsNull", 1);
@@ -345,7 +351,6 @@ var SchemaObject = class extends SchemaItem {
   constructor(model) {
     super([model]);
     this.model = model;
-    this.id = "object";
   }
   isOfType(input) {
     return isObject2(input) && !objectFind(this.model, (item, key) => !item.isOfType(input[key]));
@@ -354,6 +359,7 @@ var SchemaObject = class extends SchemaItem {
     return isObject2(input) ? objectMap(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
+SchemaObject.id = "object";
 
 // src/helpers.ts
 function isNull(value) {
@@ -393,8 +399,8 @@ function parseFormData(schema, data, opts) {
     if (value instanceof SchemaObject) {
       handleSchemaForBoolean(value.model, keys);
     }
-    if (value instanceof SchemaBoolean) {
-      objectSet2(record, keys, !!data.get(keys.join(".")));
+    if (value instanceof SchemaBoolean && typeof objectGet(record, keys) === "undefined") {
+      objectSet2(record, keys, false);
     }
   };
   const handleSchemaForBoolean = (model, keys = []) => {
@@ -438,6 +444,7 @@ var SchemaAny = class extends SchemaItem {
     return true;
   }
 };
+SchemaAny.id = "any";
 
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
@@ -481,6 +488,7 @@ var SchemaDate = class extends SchemaItem {
     return input instanceof Date;
   }
 };
+SchemaDate.id = "date";
 __decorateClass([
   parsable()
 ], SchemaDate.prototype, "parseString", 1);
@@ -519,6 +527,7 @@ var SchemaRecord = class extends SchemaItem {
     return result;
   }
 };
+SchemaRecord.id = "record";
 
 // src/items/enum.ts
 var SchemaEnum = class extends SchemaItem {
@@ -539,6 +548,7 @@ var SchemaEnum = class extends SchemaItem {
     return typeof input === this.type;
   }
 };
+SchemaEnum.id = "enum";
 
 // src/items/literal.ts
 var SchemaLiteral = class extends SchemaItem {
@@ -551,6 +561,7 @@ var SchemaLiteral = class extends SchemaItem {
     return this.values.some((it) => typeof input === typeof it);
   }
 };
+SchemaLiteral.id = "literal";
 
 // src/items/number.ts
 var SchemaNumber = class extends SchemaItem {
@@ -604,6 +615,7 @@ var SchemaNumber = class extends SchemaItem {
     return this.lte(...params);
   }
 };
+SchemaNumber.id = "number";
 __decorateClass([
   parsable()
 ], SchemaNumber.prototype, "lte", 1);
@@ -682,6 +694,7 @@ var SchemaString = class extends SchemaItem {
     return typeof input === "string";
   }
 };
+SchemaString.id = "string";
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "min", 1);
@@ -723,6 +736,7 @@ var SchemaUnion = class extends SchemaItem {
     return result;
   }
 };
+SchemaUnion.id = "union";
 
 // src/items/intersection.ts
 import { isObject as isObject4 } from "@dzeio/object-util";
@@ -751,6 +765,7 @@ var SchemaIntersection = class extends SchemaItem {
     return result;
   }
 };
+SchemaIntersection.id = "intersection";
 
 // src/items/default.ts
 var SchemaDefault = class extends SchemaItem {
@@ -770,6 +785,7 @@ var SchemaDefault = class extends SchemaItem {
     return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
   }
 };
+SchemaDefault.id = "default";
 
 // src/items/file.ts
 var SchemaFile = class extends SchemaItem {
@@ -789,6 +805,7 @@ var SchemaFile = class extends SchemaItem {
     return input instanceof File;
   }
 };
+SchemaFile.id = "file";
 __decorateClass([
   parsable()
 ], SchemaFile.prototype, "extension", 1);
@@ -817,6 +834,7 @@ var SchemaTuple = class extends SchemaItem {
     return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
   }
 };
+SchemaTuple.id = "tuple";
 
 // src/items/nullish.ts
 var SchemaUndefined = class extends SchemaItem {
@@ -824,26 +842,31 @@ var SchemaUndefined = class extends SchemaItem {
     return typeof input === "undefined";
   }
 };
+SchemaUndefined.id = "undefined";
 var SchemaNull = class extends SchemaItem {
   isOfType(input) {
     return input === null;
   }
 };
+SchemaNull.id = "null";
 var SchemaVoid = class extends SchemaItem {
   isOfType(input) {
     return typeof input === "undefined";
   }
 };
+SchemaVoid.id = "void";
 var SchemaNullish = class extends SchemaItem {
   isOfType(input) {
     return isNull(input);
   }
 };
+SchemaNullish.id = "nullish";
 var SchemaNever = class extends SchemaItem {
   isOfType(_input) {
     return false;
   }
 };
+SchemaNever.id = "never";
 
 // src/Schema.ts
 import { isObject as isObject5, objectRemap as objectRemap2 } from "@dzeio/object-util";
@@ -866,7 +889,7 @@ var _Schema = class _Schema extends SchemaObject {
     this.registeredModules.push(module);
   }
   static getModule(name) {
-    const module = this.registeredModules.find((it) => it.name === name);
+    const module = this.registeredModules.find((it) => it.id === name);
     if (!module) {
       console.log("Couldn't find module", name);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dzeio/schema",
-	"version": "0.7.0",
+	"version": "0.9.0",
 	"dependencies": {
 		"@dzeio/object-util": "^1.9.2"
 	},