@livon/schema 0.27.0-rc.1

package/dist/literal.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    literal: ()=>literal
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const literal = ({ name, value, doc })=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: `literal<${String(value)}>`,
+        doc,
+        ast: ()=>({
+                type: 'literal',
+                name,
+                constraints: {
+                    value
+                }
+            }),
+        validate: (input)=>{
+            if (input !== value) throw {
+                message: `Expected ${String(value)}`,
+                code: 'literal.value'
+            };
+            return value;
+        }
+    });
+exports.literal = __webpack_exports__.literal;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "literal"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/literal.d.ts

@@ -0,0 +1,25 @@
+import { SchemaDoc } from './types.js';
+export interface LiteralSchemaInput<T extends string | number | boolean> {
+    name: string;
+    value: T;
+    doc?: SchemaDoc;
+}
+/**
+ * literal is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/literal
+ *
+ * @example
+ * // Creates a literal schema that accepts only the value 'ok'.
+ * const Status = literal({ name: 'status', value: 'ok' });
+ * Status.parse('ok');
+ *
+ * @example
+ * // Extends the same literal rule to also allow undefined.
+ * const MaybeStatus = literal({ name: 'status', value: 'ok' }).optional();
+ * MaybeStatus.parse(undefined);
+ */
+export declare const literal: <const T extends string | number | boolean>({ name, value, doc, }: LiteralSchemaInput<T>) => import("./schemaFactory.js").SchemaWithChain<T, import("./schemaFactory.js").SchemaFactoryChainDefinition<T>>;

package/dist/literal.js

@@ -0,0 +1,21 @@
+import { schemaFactory } from "./schemaFactory.js";
+const literal = ({ name, value, doc })=>schemaFactory({
+        name,
+        type: `literal<${String(value)}>`,
+        doc,
+        ast: ()=>({
+                type: 'literal',
+                name,
+                constraints: {
+                    value
+                }
+            }),
+        validate: (input)=>{
+            if (input !== value) throw {
+                message: `Expected ${String(value)}`,
+                code: 'literal.value'
+            };
+            return value;
+        }
+    });
+export { literal };

package/dist/literal.spec.cjs

@@ -0,0 +1,93 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_literal_cjs_namespaceObject = require("./literal.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)();
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('literal()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        schemaFactoryMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when literal metadata is provided', ()=>{
+            const result = (0, external_literal_cjs_namespaceObject.literal)({
+                name: 'Room',
+                value: 'global'
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Room');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('literal<global>');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'literal',
+                name: 'Room',
+                constraints: {
+                    value: 'global'
+                }
+            });
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should pass doc metadata to schemaFactory when doc is provided', ()=>{
+            const doc = {
+                summary: 'literal doc'
+            };
+            (0, external_literal_cjs_namespaceObject.literal)({
+                name: 'Mode',
+                value: 'fast',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual(doc);
+        });
+        (0, external_vitest_namespaceObject.it)('should return literal value when input matches literal', ()=>{
+            (0, external_literal_cjs_namespaceObject.literal)({
+                name: 'Flag',
+                value: true
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(true, schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(true);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw schema error payload when input does not match literal', ()=>{
+            (0, external_literal_cjs_namespaceObject.literal)({
+                name: 'Flag',
+                value: false
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate(true, schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected false',
+                code: 'literal.value'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/literal.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/literal.spec.js

@@ -0,0 +1,87 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { literal } from "./literal.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { captureThrow, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const schemaContextMock = createSchemaContextMock();
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+describe('literal()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+    });
+    afterEach(()=>{
+        schemaFactoryMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when literal metadata is provided', ()=>{
+            const result = literal({
+                name: 'Room',
+                value: 'global'
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Room');
+            expect(factoryInput.type).toBe('literal<global>');
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'literal',
+                name: 'Room',
+                constraints: {
+                    value: 'global'
+                }
+            });
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should pass doc metadata to schemaFactory when doc is provided', ()=>{
+            const doc = {
+                summary: 'literal doc'
+            };
+            literal({
+                name: 'Mode',
+                value: 'fast',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.doc).toEqual(doc);
+        });
+        it('should return literal value when input matches literal', ()=>{
+            literal({
+                name: 'Flag',
+                value: true
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(true, schemaContextMock);
+            expect(parsed).toBe(true);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw schema error payload when input does not match literal', ()=>{
+            literal({
+                name: 'Flag',
+                value: false
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate(true, schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected false',
+                code: 'literal.value'
+            });
+        });
+    });
+});

package/dist/number.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    number: ()=>number
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const number = ({ name = 'number', doc } = {})=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'number',
+        doc,
+        ast: ()=>({
+                type: 'number',
+                name
+            }),
+        validate: (input)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isNumber)(input)) throw {
+                message: 'Data is not a number',
+                code: 'number.type'
+            };
+            return input;
+        },
+        chain: {
+            min: (data, _ctx)=>(min)=>{
+                    if (data < min) throw {
+                        message: `Expected number >= ${min}`,
+                        code: 'number.min',
+                        context: {
+                            min
+                        }
+                    };
+                    return data;
+                },
+            max: (data, _ctx)=>(max)=>{
+                    if (data > max) throw {
+                        message: `Expected number <= ${max}`,
+                        code: 'number.max',
+                        context: {
+                            max
+                        }
+                    };
+                    return data;
+                },
+            int: (data, _ctx)=>()=>{
+                    if (!Number.isInteger(data)) throw {
+                        message: 'Expected integer',
+                        code: 'number.int'
+                    };
+                    return data;
+                },
+            positive: (data, _ctx)=>()=>{
+                    if (data <= 0) throw {
+                        message: 'Expected positive number',
+                        code: 'number.positive'
+                    };
+                    return data;
+                }
+        }
+    });
+exports.number = __webpack_exports__.number;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "number"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/number.d.ts

@@ -0,0 +1,84 @@
+import { SchemaContext, SchemaDoc } from './types.js';
+export interface NumberFactoryInput {
+    name?: string;
+    doc?: SchemaDoc;
+}
+/**
+ * Chain operation: validates minimum numeric value.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/number
+ *
+ * @example
+ * // Enforces a minimum numeric value.
+ * number().min(0)
+ */
+export interface NumberChainMin {
+    (data: number, ctx: SchemaContext): (min: number) => number;
+}
+/**
+ * Chain operation: validates maximum numeric value.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/number
+ *
+ * @example
+ * // Enforces a maximum numeric value.
+ * number().max(100)
+ */
+export interface NumberChainMax {
+    (data: number, ctx: SchemaContext): (max: number) => number;
+}
+/**
+ * Chain operation: validates integer-only numbers.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/number
+ *
+ * @example
+ * // Restricts accepted values to integers only.
+ * number().int()
+ */
+export interface NumberChainInt {
+    (data: number, ctx: SchemaContext): () => number;
+}
+/**
+ * Chain operation: validates positive numbers.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/number
+ *
+ * @example
+ * // Restricts accepted values to positive numbers.
+ * number().positive()
+ */
+export interface NumberChainPositive {
+    (data: number, ctx: SchemaContext): () => number;
+}
+/**
+ * Chain map for `number()` schemas.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/number
+ */
+export interface NumberChainDefinition {
+    min: NumberChainMin;
+    max: NumberChainMax;
+    int: NumberChainInt;
+    positive: NumberChainPositive;
+}
+export type NumberSchema = ReturnType<typeof number>;
+/**
+ * number is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/number
+ *
+ * @example
+ * // Creates a basic number schema and validates an age.
+ * const Age = number();
+ * Age.parse(21);
+ *
+ * @example
+ * // Combines chain rules for integer, positive, and minimum age checks.
+ * const AdultAge = number().int().positive().min(18);
+ * AdultAge.parse(21);
+ */
+export declare const number: ({ name, doc }?: NumberFactoryInput) => import("./schemaFactory.js").SchemaWithChain<number, import("./schemaFactory.js").SchemaFactoryChainDefinition<number>>;

package/dist/number.js

@@ -0,0 +1,55 @@
+import { schemaFactory } from "./schemaFactory.js";
+import { isNumber } from "./typeGuards.js";
+const number = ({ name = 'number', doc } = {})=>schemaFactory({
+        name,
+        type: 'number',
+        doc,
+        ast: ()=>({
+                type: 'number',
+                name
+            }),
+        validate: (input)=>{
+            if (!isNumber(input)) throw {
+                message: 'Data is not a number',
+                code: 'number.type'
+            };
+            return input;
+        },
+        chain: {
+            min: (data, _ctx)=>(min)=>{
+                    if (data < min) throw {
+                        message: `Expected number >= ${min}`,
+                        code: 'number.min',
+                        context: {
+                            min
+                        }
+                    };
+                    return data;
+                },
+            max: (data, _ctx)=>(max)=>{
+                    if (data > max) throw {
+                        message: `Expected number <= ${max}`,
+                        code: 'number.max',
+                        context: {
+                            max
+                        }
+                    };
+                    return data;
+                },
+            int: (data, _ctx)=>()=>{
+                    if (!Number.isInteger(data)) throw {
+                        message: 'Expected integer',
+                        code: 'number.int'
+                    };
+                    return data;
+                },
+            positive: (data, _ctx)=>()=>{
+                    if (data <= 0) throw {
+                        message: 'Expected positive number',
+                        code: 'number.positive'
+                    };
+                    return data;
+                }
+        }
+    });
+export { number };

package/dist/number.spec.cjs

@@ -0,0 +1,155 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_number_cjs_namespaceObject = require("./number.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+external_vitest_namespaceObject.vi.mock('./typeGuards.js', ()=>({
+        isNumber: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isNumberMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isNumber);
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)();
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('number()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isNumberMock.mockReset();
+        isNumberMock.mockReturnValue(true);
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        isNumberMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isNumberMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when number schema is created', ()=>{
+            const result = (0, external_number_cjs_namespaceObject.number)();
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('number');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('number');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'number',
+                name: 'number'
+            });
+            (0, external_vitest_namespaceObject.expect)(Object.keys(factoryInput.chain)).toEqual([
+                'min',
+                'max',
+                'int',
+                'positive'
+            ]);
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'number doc'
+            };
+            (0, external_number_cjs_namespaceObject.number)({
+                name: 'Count',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Count');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual(doc);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'number',
+                name: 'Count'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should validate input through isNumber when input is number', ()=>{
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(42, schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(42);
+            (0, external_vitest_namespaceObject.expect)(isNumberMock).toHaveBeenCalledWith(42);
+        });
+        (0, external_vitest_namespaceObject.it)('should return input for all chain methods when constraints are valid', ()=>{
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.min(5, schemaContextMock)(1)).toBe(5);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.max(5, schemaContextMock)(8)).toBe(5);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.int(5, schemaContextMock)()).toBe(5);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.positive(5, schemaContextMock)()).toBe(5);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw schema error payload when input is not number', ()=>{
+            isNumberMock.mockReturnValue(false);
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('x', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Data is not a number',
+                code: 'number.type'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw min error when value is below minimum', ()=>{
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.min(1, schemaContextMock)(5));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected number >= 5',
+                code: 'number.min',
+                context: {
+                    min: 5
+                }
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw max error when value is above maximum', ()=>{
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.max(10, schemaContextMock)(8));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected number <= 8',
+                code: 'number.max',
+                context: {
+                    max: 8
+                }
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw int error when value is not integer', ()=>{
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.int(2.5, schemaContextMock)());
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected integer',
+                code: 'number.int'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw positive error when value is not positive', ()=>{
+            (0, external_number_cjs_namespaceObject.number)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.positive(0, schemaContextMock)());
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected positive number',
+                code: 'number.positive'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/number.spec.d.ts

@@ -0,0 +1 @@
+export {};