@livon/schema 0.27.0-rc.1

package/dist/enumeration.d.ts

@@ -0,0 +1,50 @@
+import { SchemaFactoryChainDefinition, SchemaWithChain } from './schemaFactory.js';
+import type { SchemaDoc } from './types.js';
+export type EnumValues = readonly [string | number, ...(string | number)[]];
+/**
+ * Chain operation: enforces one exact enum literal.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/enumeration
+ *
+ * @example
+ * // Restricts parsed values to one exact enum literal.
+ * enumeration('Role').values('admin', 'user').literal('admin')
+ */
+export interface EnumLiteralChain<TValue extends string | number> {
+    (data: TValue): (only: TValue) => TValue;
+}
+/**
+ * Chain map for enum schemas.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/enumeration
+ */
+export interface EnumChainDefinition<TValue extends string | number> extends SchemaFactoryChainDefinition<TValue> {
+    literal: EnumLiteralChain<TValue>;
+}
+/**
+ * Factory returned by `enumeration(...)`.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/enumeration
+ */
+export interface EnumFactory {
+    values: <TValues extends EnumValues>(...values: TValues) => SchemaWithChain<TValues[number], EnumChainDefinition<TValues[number]>>;
+}
+/**
+ * enumeration 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/enumeration
+ *
+ * @example
+ * // Creates an enum schema that accepts only 'admin' or 'user'.
+ * const Role = enumeration('Role').values('admin', 'user');
+ * Role.parse('admin');
+ *
+ * @example
+ * // Adds a chain rule so only the 'admin' enum literal is accepted.
+ * const AdminRole = enumeration('Role').values('admin', 'user').literal('admin');
+ * AdminRole.parse('admin');
+ */
+export declare const enumeration: (name: string, doc?: SchemaDoc) => EnumFactory;

package/dist/enumeration.js

@@ -0,0 +1,40 @@
+import { schemaFactory } from "./schemaFactory.js";
+const enumeration = (name, doc)=>({
+        values: (...values)=>schemaFactory({
+                name: `enum:${name}`,
+                type: 'enum',
+                doc,
+                ast: ()=>({
+                        type: 'enum',
+                        name,
+                        constraints: {
+                            values
+                        }
+                    }),
+                validate: (input)=>{
+                    if (!values.includes(input)) throw {
+                        message: `Input "${String(input)}" is not valid for enum "${name}". Valid values: ${values.join(', ')}`,
+                        code: 'enum.value',
+                        context: {
+                            name,
+                            values
+                        }
+                    };
+                    return input;
+                },
+                chain: {
+                    literal: (data)=>(only)=>{
+                            if (data !== only) throw {
+                                message: `Input "${String(data)}" does not match literal "${String(only)}" for enum "${name}".`,
+                                code: 'enum.literal',
+                                context: {
+                                    name,
+                                    only
+                                }
+                            };
+                            return data;
+                        }
+                }
+            })
+    });
+export { enumeration };

package/dist/enumeration.spec.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_enumeration_cjs_namespaceObject = require("./enumeration.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)('enumeration()', ()=>{
+    (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 return enum factory when enumeration is created', ()=>{
+            const result = (0, external_enumeration_cjs_namespaceObject.enumeration)('Role');
+            (0, external_vitest_namespaceObject.expect)(typeof result.values).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(0);
+        });
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when values() is called', ()=>{
+            const result = (0, external_enumeration_cjs_namespaceObject.enumeration)('Role', {
+                summary: 'enum doc'
+            });
+            const schema = result.values('user', 'admin');
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('enum:Role');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('enum');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual({
+                summary: 'enum doc'
+            });
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'enum',
+                name: 'Role',
+                constraints: {
+                    values: [
+                        'user',
+                        'admin'
+                    ]
+                }
+            });
+            (0, external_vitest_namespaceObject.expect)(Object.keys(factoryInput.chain)).toEqual([
+                'literal'
+            ]);
+            (0, external_vitest_namespaceObject.expect)(schema).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should validate enum value and literal chain when values are included', ()=>{
+            (0, external_enumeration_cjs_namespaceObject.enumeration)('Role').values('user', 'admin');
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.validate('admin', schemaContextMock)).toBe('admin');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.chain.literal('admin')('admin')).toBe('admin');
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw enum.value when input is not part of values', ()=>{
+            (0, external_enumeration_cjs_namespaceObject.enumeration)('Role').values('user', 'admin');
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('guest', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Input "guest" is not valid for enum "Role". Valid values: user, admin',
+                code: 'enum.value',
+                context: {
+                    name: 'Role',
+                    values: [
+                        'user',
+                        'admin'
+                    ]
+                }
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should throw enum.literal when literal() does not match selected value', ()=>{
+            (0, external_enumeration_cjs_namespaceObject.enumeration)('Role').values('user', 'admin');
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.chain.literal('user')('admin'));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Input "user" does not match literal "admin" for enum "Role".',
+                code: 'enum.literal',
+                context: {
+                    name: 'Role',
+                    only: 'admin'
+                }
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/enumeration.spec.d.ts

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

package/dist/enumeration.spec.js

@@ -0,0 +1,104 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { enumeration } from "./enumeration.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('enumeration()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+    });
+    afterEach(()=>{
+        schemaFactoryMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should return enum factory when enumeration is created', ()=>{
+            const result = enumeration('Role');
+            expect(typeof result.values).toBe('function');
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(0);
+        });
+        it('should delegate to schemaFactory when values() is called', ()=>{
+            const result = enumeration('Role', {
+                summary: 'enum doc'
+            });
+            const schema = result.values('user', 'admin');
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('enum:Role');
+            expect(factoryInput.type).toBe('enum');
+            expect(factoryInput.doc).toEqual({
+                summary: 'enum doc'
+            });
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'enum',
+                name: 'Role',
+                constraints: {
+                    values: [
+                        'user',
+                        'admin'
+                    ]
+                }
+            });
+            expect(Object.keys(factoryInput.chain)).toEqual([
+                'literal'
+            ]);
+            expect(schema).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should validate enum value and literal chain when values are included', ()=>{
+            enumeration('Role').values('user', 'admin');
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.validate('admin', schemaContextMock)).toBe('admin');
+            expect(factoryInput.chain.literal('admin')('admin')).toBe('admin');
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw enum.value when input is not part of values', ()=>{
+            enumeration('Role').values('user', 'admin');
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('guest', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Input "guest" is not valid for enum "Role". Valid values: user, admin',
+                code: 'enum.value',
+                context: {
+                    name: 'Role',
+                    values: [
+                        'user',
+                        'admin'
+                    ]
+                }
+            });
+        });
+        it('should throw enum.literal when literal() does not match selected value', ()=>{
+            enumeration('Role').values('user', 'admin');
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.chain.literal('user')('admin'));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Input "user" does not match literal "admin" for enum "Role".',
+                code: 'enum.literal',
+                context: {
+                    name: 'Role',
+                    only: 'admin'
+                }
+            });
+        });
+    });
+});

package/dist/hydrate.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/hydrate.d.ts

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

package/dist/index.cjs

@@ -0,0 +1,145 @@
+"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__, {
+    enumeration: ()=>external_enumeration_cjs_namespaceObject.enumeration,
+    createSchemaContext: ()=>external_context_cjs_namespaceObject.createSchemaContext,
+    binary: ()=>external_binary_cjs_namespaceObject.binary,
+    runFieldOperation: ()=>external_operation_cjs_namespaceObject.runFieldOperation,
+    string: ()=>external_string_cjs_namespaceObject.string,
+    date: ()=>external_date_cjs_namespaceObject.date,
+    object: ()=>external_object_cjs_namespaceObject.object,
+    runOperation: ()=>external_operation_cjs_namespaceObject.runOperation,
+    mergeDoc: ()=>external_doc_cjs_namespaceObject.mergeDoc,
+    createSchemaValidationError: ()=>external_SchemaValidationError_cjs_namespaceObject.createSchemaValidationError,
+    boolean: ()=>external_boolean_cjs_namespaceObject.boolean,
+    subscription: ()=>external_api_cjs_namespaceObject.subscription,
+    union: ()=>external_union_cjs_namespaceObject.union,
+    after: ()=>external_after_cjs_namespaceObject.after,
+    api: ()=>external_api_cjs_namespaceObject.api,
+    tuple: ()=>external_tuple_cjs_namespaceObject.tuple,
+    schemaModule: ()=>external_schemaModule_cjs_namespaceObject.schemaModule,
+    array: ()=>external_array_cjs_namespaceObject.array,
+    normalizeDoc: ()=>external_doc_cjs_namespaceObject.normalizeDoc,
+    schemaFactory: ()=>external_schemaFactory_cjs_namespaceObject.schemaFactory,
+    composeApi: ()=>external_api_cjs_namespaceObject.composeApi,
+    or: ()=>external_or_cjs_namespaceObject.or,
+    and: ()=>external_and_cjs_namespaceObject.and,
+    before: ()=>external_before_cjs_namespaceObject.before,
+    typeGuards: ()=>external_typeGuards_cjs_namespaceObject,
+    literal: ()=>external_literal_cjs_namespaceObject.literal,
+    fieldOperation: ()=>external_operation_cjs_namespaceObject.fieldOperation,
+    number: ()=>external_number_cjs_namespaceObject.number,
+    operation: ()=>external_operation_cjs_namespaceObject.operation,
+    createSchemaModuleInput: ()=>external_schemaModule_cjs_namespaceObject.createSchemaModuleInput
+});
+const external_SchemaValidationError_cjs_namespaceObject = require("./SchemaValidationError.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const external_string_cjs_namespaceObject = require("./string.cjs");
+const external_number_cjs_namespaceObject = require("./number.cjs");
+const external_boolean_cjs_namespaceObject = require("./boolean.cjs");
+const external_date_cjs_namespaceObject = require("./date.cjs");
+const external_enumeration_cjs_namespaceObject = require("./enumeration.cjs");
+const external_array_cjs_namespaceObject = require("./array.cjs");
+const external_object_cjs_namespaceObject = require("./object.cjs");
+const external_union_cjs_namespaceObject = require("./union.cjs");
+const external_or_cjs_namespaceObject = require("./or.cjs");
+const external_tuple_cjs_namespaceObject = require("./tuple.cjs");
+const external_literal_cjs_namespaceObject = require("./literal.cjs");
+const external_binary_cjs_namespaceObject = require("./binary.cjs");
+const external_api_cjs_namespaceObject = require("./api.cjs");
+const external_operation_cjs_namespaceObject = require("./operation.cjs");
+const external_before_cjs_namespaceObject = require("./before.cjs");
+const external_after_cjs_namespaceObject = require("./after.cjs");
+const external_and_cjs_namespaceObject = require("./and.cjs");
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_schemaModule_cjs_namespaceObject = require("./schemaModule.cjs");
+const external_doc_cjs_namespaceObject = require("./doc.cjs");
+exports.after = __webpack_exports__.after;
+exports.and = __webpack_exports__.and;
+exports.api = __webpack_exports__.api;
+exports.array = __webpack_exports__.array;
+exports.before = __webpack_exports__.before;
+exports.binary = __webpack_exports__.binary;
+exports.boolean = __webpack_exports__.boolean;
+exports.composeApi = __webpack_exports__.composeApi;
+exports.createSchemaContext = __webpack_exports__.createSchemaContext;
+exports.createSchemaModuleInput = __webpack_exports__.createSchemaModuleInput;
+exports.createSchemaValidationError = __webpack_exports__.createSchemaValidationError;
+exports.date = __webpack_exports__.date;
+exports.enumeration = __webpack_exports__.enumeration;
+exports.fieldOperation = __webpack_exports__.fieldOperation;
+exports.literal = __webpack_exports__.literal;
+exports.mergeDoc = __webpack_exports__.mergeDoc;
+exports.normalizeDoc = __webpack_exports__.normalizeDoc;
+exports.number = __webpack_exports__.number;
+exports.object = __webpack_exports__.object;
+exports.operation = __webpack_exports__.operation;
+exports.or = __webpack_exports__.or;
+exports.runFieldOperation = __webpack_exports__.runFieldOperation;
+exports.runOperation = __webpack_exports__.runOperation;
+exports.schemaFactory = __webpack_exports__.schemaFactory;
+exports.schemaModule = __webpack_exports__.schemaModule;
+exports.string = __webpack_exports__.string;
+exports.subscription = __webpack_exports__.subscription;
+exports.tuple = __webpack_exports__.tuple;
+exports.typeGuards = __webpack_exports__.typeGuards;
+exports.union = __webpack_exports__.union;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "after",
+    "and",
+    "api",
+    "array",
+    "before",
+    "binary",
+    "boolean",
+    "composeApi",
+    "createSchemaContext",
+    "createSchemaModuleInput",
+    "createSchemaValidationError",
+    "date",
+    "enumeration",
+    "fieldOperation",
+    "literal",
+    "mergeDoc",
+    "normalizeDoc",
+    "number",
+    "object",
+    "operation",
+    "or",
+    "runFieldOperation",
+    "runOperation",
+    "schemaFactory",
+    "schemaModule",
+    "string",
+    "subscription",
+    "tuple",
+    "typeGuards",
+    "union"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Public package entrypoint for `@livon/schema`.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/schema
+ */
+export { createSchemaValidationError } from './SchemaValidationError.js';
+export type { SchemaValidationError } from './SchemaValidationError.js';
+export { schemaFactory } from './schemaFactory.js';
+export type { SchemaWithChain, SchemaFactoryChainDefinition } from './schemaFactory.js';
+export * as typeGuards from './typeGuards.js';
+export { string } from './string.js';
+export { number } from './number.js';
+export { boolean } from './boolean.js';
+export { date } from './date.js';
+export { enumeration } from './enumeration.js';
+export { array } from './array.js';
+export { object } from './object.js';
+export { union } from './union.js';
+export { or } from './or.js';
+export { tuple } from './tuple.js';
+export { literal } from './literal.js';
+export { binary } from './binary.js';
+export { api, composeApi, subscription } from './api.js';
+export type { Api, ApiFieldShape, ApiShape, Subscription, SubscriptionShape, SubscriptionInput, SubscriptionFilter, SubscriptionExecutor, } from './api.js';
+export { fieldOperation, operation, runFieldOperation, runOperation } from './operation.js';
+export type { Operation, FieldOperation, OperationRooms } from './operation.js';
+export { before } from './before.js';
+export { after } from './after.js';
+export { and } from './and.js';
+export { createSchemaContext } from './context.js';
+export { schemaModule, createSchemaModuleInput } from './schemaModule.js';
+export { normalizeDoc, mergeDoc } from './doc.js';
+export type { Schema, SchemaIssue, SchemaResult, SchemaBuildContext, SchemaBuildContextInput, SchemaRequestContext, SchemaRequestContextInput, SchemaContext, Publisher, PublishInput, Shape, Infer, AstNode, SchemaDoc, AstBuilder, Logger, PublishAck, AckConfig, AckMode, } from './types.js';
+export type { SchemaModuleInput, SchemaModuleLike, SchemaModuleOptions, SchemaModuleDecoder, SchemaModuleEncoder, SchemaModuleGetRequestContext, SchemaModuleNow, } from './schemaModule.js';

package/dist/index.js

@@ -0,0 +1,24 @@
+import { createSchemaValidationError } from "./SchemaValidationError.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { string } from "./string.js";
+import { number } from "./number.js";
+import { boolean as external_boolean_js_boolean } from "./boolean.js";
+import { date } from "./date.js";
+import { enumeration } from "./enumeration.js";
+import { array } from "./array.js";
+import { object } from "./object.js";
+import { union } from "./union.js";
+import { or } from "./or.js";
+import { tuple } from "./tuple.js";
+import { literal } from "./literal.js";
+import { binary } from "./binary.js";
+import { api, composeApi, subscription } from "./api.js";
+import { fieldOperation, operation, runFieldOperation, runOperation } from "./operation.js";
+import { before } from "./before.js";
+import { after } from "./after.js";
+import { and } from "./and.js";
+import { createSchemaContext } from "./context.js";
+import { createSchemaModuleInput, schemaModule } from "./schemaModule.js";
+import { mergeDoc, normalizeDoc } from "./doc.js";
+import * as __rspack_external__typeGuards_js_2b25dd2c from "./typeGuards.js";
+export { after, and, api, array, before, binary, external_boolean_js_boolean as boolean, composeApi, createSchemaContext, createSchemaModuleInput, createSchemaValidationError, date, enumeration, fieldOperation, literal, mergeDoc, normalizeDoc, number, object, operation, or, runFieldOperation, runOperation, schemaFactory, schemaModule, string, subscription, tuple, __rspack_external__typeGuards_js_2b25dd2c as typeGuards, union };

package/dist/index.spec.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_index_cjs_namespaceObject = require("./index.cjs");
+(0, external_vitest_namespaceObject.describe)('index exports', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{});
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{});
+    (0, external_vitest_namespaceObject.afterEach)(()=>{});
+    (0, external_vitest_namespaceObject.afterAll)(()=>{});
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should expose schema builder functions when package entrypoint is imported', ()=>{
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.string).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.number).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.object).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.array).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.union).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.or).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.tuple).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.literal).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.binary).toBe('function');
+        });
+        (0, external_vitest_namespaceObject.it)('should expose api and runtime integration helpers when package entrypoint is imported', ()=>{
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.api).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.composeApi).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.subscription).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.operation).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.fieldOperation).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.schemaModule).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.createSchemaModuleInput).toBe('function');
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should keep typeGuards namespace defined when package entrypoint is imported', ()=>{
+            (0, external_vitest_namespaceObject.expect)(external_index_cjs_namespaceObject.typeGuards).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.typeGuards.isString).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof external_index_cjs_namespaceObject.typeGuards.isRecord).toBe('function');
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.spec.d.ts

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

package/dist/index.spec.js

@@ -0,0 +1,37 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { api, array, binary, composeApi, createSchemaModuleInput, fieldOperation, literal, number, object, operation, or, schemaModule, string, subscription, tuple, typeGuards, union } from "./index.js";
+describe('index exports', ()=>{
+    beforeAll(()=>{});
+    beforeEach(()=>{});
+    afterEach(()=>{});
+    afterAll(()=>{});
+    describe('happy', ()=>{
+        it('should expose schema builder functions when package entrypoint is imported', ()=>{
+            expect(typeof string).toBe('function');
+            expect(typeof number).toBe('function');
+            expect(typeof object).toBe('function');
+            expect(typeof array).toBe('function');
+            expect(typeof union).toBe('function');
+            expect(typeof or).toBe('function');
+            expect(typeof tuple).toBe('function');
+            expect(typeof literal).toBe('function');
+            expect(typeof binary).toBe('function');
+        });
+        it('should expose api and runtime integration helpers when package entrypoint is imported', ()=>{
+            expect(typeof api).toBe('function');
+            expect(typeof composeApi).toBe('function');
+            expect(typeof subscription).toBe('function');
+            expect(typeof operation).toBe('function');
+            expect(typeof fieldOperation).toBe('function');
+            expect(typeof schemaModule).toBe('function');
+            expect(typeof createSchemaModuleInput).toBe('function');
+        });
+    });
+    describe('sad', ()=>{
+        it('should keep typeGuards namespace defined when package entrypoint is imported', ()=>{
+            expect(typeGuards).toBeDefined();
+            expect(typeof typeGuards.isString).toBe('function');
+            expect(typeof typeGuards.isRecord).toBe('function');
+        });
+    });
+});