@livon/schema 0.27.0-rc.1

package/dist/testing/mocks/schema.mock.js

@@ -0,0 +1,74 @@
+import { vi } from "vitest";
+const createSchemaStateMock = (overrides = {})=>({
+        get: vi.fn(()=>void 0),
+        set: vi.fn(()=>void 0),
+        update: vi.fn(()=>void 0),
+        snapshot: vi.fn(()=>({})),
+        ...overrides
+    });
+const createSchemaContextMock = (overrides = {})=>{
+    const state = overrides.state ?? createSchemaStateMock();
+    const getBuildContext = vi.fn(()=>overrides.buildContext);
+    const setBuildContext = vi.fn(()=>void 0);
+    const getRequestContext = vi.fn(()=>overrides.requestContext);
+    const setRequestContext = vi.fn((_input)=>void 0);
+    return {
+        getBuildContext,
+        setBuildContext,
+        getRequestContext,
+        setRequestContext,
+        get request () {
+            return overrides.requestContext;
+        },
+        state,
+        ...overrides
+    };
+};
+const createDefaultAstNode = (name, type)=>({
+        name,
+        type
+    });
+const createBaseSchemaMock = (overrides = {})=>{
+    const name = overrides.name ?? 'schema.mock';
+    const type = overrides.type ?? 'schema.mock';
+    const astNode = overrides.astNode ?? createDefaultAstNode(name, type);
+    const outputValue = overrides.outputValue;
+    const validateResult = overrides.validateResult ?? {
+        ok: true,
+        value: outputValue
+    };
+    const schema = {};
+    schema.name = name;
+    schema.type = type;
+    schema.ast = vi.fn(()=>astNode);
+    schema.validate = vi.fn(()=>validateResult);
+    schema.parse = vi.fn(()=>outputValue);
+    schema.typed = vi.fn((input)=>input);
+    schema.optional = vi.fn(()=>schema);
+    schema.nullable = vi.fn(()=>schema);
+    schema.describe = vi.fn(()=>schema);
+    schema.refine = vi.fn(()=>schema);
+    schema.before = vi.fn(()=>schema);
+    schema.after = vi.fn(()=>schema);
+    schema.and = vi.fn(()=>schema);
+    return {
+        ...schema,
+        ...overrides
+    };
+};
+const createSchemaWithChainMock = (input = {})=>{
+    const schema = createBaseSchemaMock({
+        name: input.name,
+        type: input.type
+    });
+    (input.chainKeys ?? []).forEach((chainKey)=>{
+        schema[chainKey] = vi.fn(()=>schema);
+    });
+    return input.overrides ? Object.assign(schema, input.overrides) : schema;
+};
+const createSchemaFactoryMock = ()=>vi.fn((factoryInput)=>createSchemaWithChainMock({
+            name: factoryInput.name,
+            type: factoryInput.type,
+            chainKeys: Object.keys(factoryInput.chain ?? {})
+        }));
+export { createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock, createSchemaStateMock, createSchemaWithChainMock };

package/dist/tuple.cjs

@@ -0,0 +1,58 @@
+"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__, {
+    tuple: ()=>tuple
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const tuple = ({ name, items, doc })=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'tuple',
+        doc,
+        ast: (ctx)=>{
+            const build = ctx.getBuildContext();
+            return {
+                type: 'tuple',
+                name,
+                children: items.map((item)=>item.ast(build ?? void 0))
+            };
+        },
+        validate: (input, ctx)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isArray)()(input)) throw {
+                message: 'Expected tuple',
+                code: 'tuple.type'
+            };
+            const result = items.map((schema, index)=>schema.parse(input[index], ctx));
+            return result;
+        }
+    });
+exports.tuple = __webpack_exports__.tuple;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "tuple"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tuple.d.ts

@@ -0,0 +1,33 @@
+import { Schema, SchemaDoc } from './types.js';
+type AnySchema = Schema<any>;
+export interface TupleSchemaInput<TItems extends readonly AnySchema[]> {
+    name: string;
+    items: TItems;
+    doc?: SchemaDoc;
+}
+/**
+ * tuple 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/tuple
+ *
+ * @example
+ * // Creates a tuple schema for numeric x/y coordinates.
+ * const Coordinates = tuple({
+ *   name: 'coordinates',
+ *   items: [number(), number()] as const,
+ * });
+ * Coordinates.parse([10, 20]);
+ *
+ * @example
+ * // Extends tuple validation to also allow undefined.
+ * const MaybeCoordinates = tuple({
+ *   name: 'coordinates',
+ *   items: [number(), number()] as const,
+ * }).optional();
+ * MaybeCoordinates.parse(undefined);
+ */
+export declare const tuple: <TItems extends readonly AnySchema[]>({ name, items, doc, }: TupleSchemaInput<TItems>) => import("./schemaFactory.js").SchemaWithChain<{ [K in keyof TItems]: ReturnType<TItems[K]["parse"]>; }, import("./schemaFactory.js").SchemaFactoryChainDefinition<{ [K in keyof TItems]: ReturnType<TItems[K]["parse"]>; }>>;
+export {};

package/dist/tuple.js

@@ -0,0 +1,24 @@
+import { schemaFactory } from "./schemaFactory.js";
+import { isArray } from "./typeGuards.js";
+const tuple = ({ name, items, doc })=>schemaFactory({
+        name,
+        type: 'tuple',
+        doc,
+        ast: (ctx)=>{
+            const build = ctx.getBuildContext();
+            return {
+                type: 'tuple',
+                name,
+                children: items.map((item)=>item.ast(build ?? void 0))
+            };
+        },
+        validate: (input, ctx)=>{
+            if (!isArray()(input)) throw {
+                message: 'Expected tuple',
+                code: 'tuple.type'
+            };
+            const result = items.map((schema, index)=>schema.parse(input[index], ctx));
+            return result;
+        }
+    });
+export { tuple };

package/dist/tuple.spec.cjs

@@ -0,0 +1,162 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_tuple_cjs_namespaceObject = require("./tuple.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', ()=>({
+        isArray: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isArrayMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isArray);
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const isArrayGuardSpy = external_vitest_namespaceObject.vi.fn((input)=>Array.isArray(input));
+const isArrayGuard = (input)=>isArrayGuardSpy(input);
+const buildContextMock = {
+    buildId: 'build-tuple',
+    builder: {
+        add: external_vitest_namespaceObject.vi.fn((node)=>node),
+        getAll: external_vitest_namespaceObject.vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)({
+    buildContext: buildContextMock
+});
+const firstSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'first',
+    parse: external_vitest_namespaceObject.vi.fn((value)=>`first:${String(value)}`),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'string',
+            name: 'First'
+        }))
+});
+const secondSchemaMock = (0, index_cjs_namespaceObject.createBaseSchemaMock)({
+    name: 'second',
+    parse: external_vitest_namespaceObject.vi.fn((value)=>Number(value)),
+    ast: external_vitest_namespaceObject.vi.fn(()=>({
+            type: 'number',
+            name: 'Second'
+        }))
+});
+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)('tuple()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+        isArrayMock.mockImplementation(()=>isArrayGuard);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isArrayMock.mockClear();
+        isArrayGuardSpy.mockClear();
+        external_vitest_namespaceObject.vi.mocked(firstSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(firstSchemaMock.ast).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondSchemaMock.ast).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.mocked(firstSchemaMock.parse).mockClear();
+        external_vitest_namespaceObject.vi.mocked(secondSchemaMock.parse).mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isArrayMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when tuple schema is created', ()=>{
+            const result = (0, external_tuple_cjs_namespaceObject.tuple)({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Coordinates');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('tuple');
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should build ast from tuple item schemas when build context is available', ()=>{
+            (0, external_tuple_cjs_namespaceObject.tuple)({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(ast).toEqual({
+                type: 'tuple',
+                name: 'Coordinates',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'First'
+                    },
+                    {
+                        type: 'number',
+                        name: 'Second'
+                    }
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(firstSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+            (0, external_vitest_namespaceObject.expect)(secondSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        (0, external_vitest_namespaceObject.it)('should parse tuple elements when input is an array', ()=>{
+            (0, external_tuple_cjs_namespaceObject.tuple)({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate([
+                'x',
+                '2'
+            ], schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toEqual([
+                'first:x',
+                2
+            ]);
+            (0, external_vitest_namespaceObject.expect)(firstSchemaMock.parse).toHaveBeenCalledWith('x', schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(secondSchemaMock.parse).toHaveBeenCalledWith('2', schemaContextMock);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw tuple.type when input is not an array', ()=>{
+            isArrayGuardSpy.mockReturnValueOnce(false);
+            (0, external_tuple_cjs_namespaceObject.tuple)({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            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: 'Expected tuple',
+                code: 'tuple.type'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tuple.spec.d.ts

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

package/dist/tuple.spec.js

@@ -0,0 +1,156 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { schemaFactory } from "./schemaFactory.js";
+import { tuple } from "./tuple.js";
+import { isArray } from "./typeGuards.js";
+import { captureThrow, createBaseSchemaMock, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isArray: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isArrayMock = vi.mocked(isArray);
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const isArrayGuardSpy = vi.fn((input)=>Array.isArray(input));
+const isArrayGuard = (input)=>isArrayGuardSpy(input);
+const buildContextMock = {
+    buildId: 'build-tuple',
+    builder: {
+        add: vi.fn((node)=>node),
+        getAll: vi.fn(()=>[])
+    },
+    schemaPath: [],
+    buildOptions: {}
+};
+const schemaContextMock = createSchemaContextMock({
+    buildContext: buildContextMock
+});
+const firstSchemaMock = createBaseSchemaMock({
+    name: 'first',
+    parse: vi.fn((value)=>`first:${String(value)}`),
+    ast: vi.fn(()=>({
+            type: 'string',
+            name: 'First'
+        }))
+});
+const secondSchemaMock = createBaseSchemaMock({
+    name: 'second',
+    parse: vi.fn((value)=>Number(value)),
+    ast: vi.fn(()=>({
+            type: 'number',
+            name: 'Second'
+        }))
+});
+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('tuple()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+        isArrayMock.mockImplementation(()=>isArrayGuard);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isArrayMock.mockClear();
+        isArrayGuardSpy.mockClear();
+        vi.mocked(firstSchemaMock.parse).mockClear();
+        vi.mocked(firstSchemaMock.ast).mockClear();
+        vi.mocked(secondSchemaMock.parse).mockClear();
+        vi.mocked(secondSchemaMock.ast).mockClear();
+    });
+    afterEach(()=>{
+        vi.mocked(firstSchemaMock.parse).mockClear();
+        vi.mocked(secondSchemaMock.parse).mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isArrayMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when tuple schema is created', ()=>{
+            const result = tuple({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Coordinates');
+            expect(factoryInput.type).toBe('tuple');
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should build ast from tuple item schemas when build context is available', ()=>{
+            tuple({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const ast = factoryInput.ast(schemaContextMock);
+            expect(ast).toEqual({
+                type: 'tuple',
+                name: 'Coordinates',
+                children: [
+                    {
+                        type: 'string',
+                        name: 'First'
+                    },
+                    {
+                        type: 'number',
+                        name: 'Second'
+                    }
+                ]
+            });
+            expect(firstSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+            expect(secondSchemaMock.ast).toHaveBeenCalledWith(buildContextMock);
+        });
+        it('should parse tuple elements when input is an array', ()=>{
+            tuple({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate([
+                'x',
+                '2'
+            ], schemaContextMock);
+            expect(parsed).toEqual([
+                'first:x',
+                2
+            ]);
+            expect(firstSchemaMock.parse).toHaveBeenCalledWith('x', schemaContextMock);
+            expect(secondSchemaMock.parse).toHaveBeenCalledWith('2', schemaContextMock);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw tuple.type when input is not an array', ()=>{
+            isArrayGuardSpy.mockReturnValueOnce(false);
+            tuple({
+                name: 'Coordinates',
+                items: [
+                    firstSchemaMock,
+                    secondSchemaMock
+                ]
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected tuple',
+                code: 'tuple.type'
+            });
+        });
+    });
+});

package/dist/typeGuards.cjs

@@ -0,0 +1,60 @@
+"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__, {
+    isArray: ()=>isArray,
+    isBoolean: ()=>isBoolean,
+    isDate: ()=>isDate,
+    isNumber: ()=>isNumber,
+    isRecord: ()=>isRecord,
+    isString: ()=>isString,
+    isUint8Array: ()=>isUint8Array
+});
+const isString = (input)=>'string' == typeof input;
+const isNumber = (input)=>'number' == typeof input && !Number.isNaN(input);
+const isBoolean = (input)=>'boolean' == typeof input;
+const isDate = (input)=>input instanceof Date && !Number.isNaN(input.getTime());
+const isUint8Array = (input)=>input instanceof Uint8Array;
+const isRecord = (input)=>null !== input && 'object' == typeof input && !Array.isArray(input);
+const isArray = ()=>(input)=>Array.isArray(input);
+exports.isArray = __webpack_exports__.isArray;
+exports.isBoolean = __webpack_exports__.isBoolean;
+exports.isDate = __webpack_exports__.isDate;
+exports.isNumber = __webpack_exports__.isNumber;
+exports.isRecord = __webpack_exports__.isRecord;
+exports.isString = __webpack_exports__.isString;
+exports.isUint8Array = __webpack_exports__.isUint8Array;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isArray",
+    "isBoolean",
+    "isDate",
+    "isNumber",
+    "isRecord",
+    "isString",
+    "isUint8Array"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/typeGuards.d.ts

@@ -0,0 +1,93 @@
+export interface TypeGuard<T> {
+    (input: unknown): input is T;
+}
+/**
+ * isString 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/type-guards
+ *
+ * @example
+ * const result = isString(undefined as never);
+ */
+export declare const isString: (input: unknown) => input is string;
+/**
+ * isNumber 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/type-guards
+ *
+ * @example
+ * const result = isNumber(undefined as never);
+ */
+export declare const isNumber: (input: unknown) => input is number;
+/**
+ * isBoolean 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/type-guards
+ *
+ * @example
+ * const result = isBoolean(undefined as never);
+ */
+export declare const isBoolean: (input: unknown) => input is boolean;
+/**
+ * isDate 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/type-guards
+ *
+ * @example
+ * const result = isDate(undefined as never);
+ */
+export declare const isDate: (input: unknown) => input is Date;
+/**
+ * isUint8Array 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/type-guards
+ *
+ * @example
+ * const result = isUint8Array(undefined as never);
+ */
+export declare const isUint8Array: (input: unknown) => input is Uint8Array;
+export interface UnknownRecord {
+    [key: string]: unknown;
+}
+/**
+ * isRecord 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/type-guards
+ *
+ * @example
+ * const result = isRecord(undefined as never);
+ */
+export declare const isRecord: (input: unknown) => input is UnknownRecord;
+export interface ArrayTypeGuard<T> {
+    (input: unknown): input is readonly T[];
+}
+/**
+ * isArray 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/type-guards
+ *
+ * @example
+ * const result = isArray(undefined as never);
+ */
+export declare const isArray: <T>() => ArrayTypeGuard<T>;

package/dist/typeGuards.js

@@ -0,0 +1,8 @@
+const isString = (input)=>'string' == typeof input;
+const isNumber = (input)=>'number' == typeof input && !Number.isNaN(input);
+const isBoolean = (input)=>'boolean' == typeof input;
+const isDate = (input)=>input instanceof Date && !Number.isNaN(input.getTime());
+const isUint8Array = (input)=>input instanceof Uint8Array;
+const isRecord = (input)=>null !== input && 'object' == typeof input && !Array.isArray(input);
+const isArray = ()=>(input)=>Array.isArray(input);
+export { isArray, isBoolean, isDate, isNumber, isRecord, isString, isUint8Array };