@scalar/validation 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @scalar/validation@0.1.0 build /home/runner/work/scalar/scalar/packages/validation
+> tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json
+

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @scalar/validation
+
+## 0.1.0
+
+### Minor Changes
+
+- [#8567](https://github.com/scalar/scalar/pull/8567): feat: initial commit ✨

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Scalar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# `@scalar/validation`
+
+Small, schema-first helpers to **check** unknown data and **coerce** it into predictable shapes. Schemas are plain JavaScript objects (easy to serialize or log), and TypeScript can infer output types with `Static`.
+
+## Install
+
+This package lives in the Scalar monorepo. In workspace consumers:
+
+```bash
+pnpm add @scalar/validation
+```
+
+## Quick start
+
+```ts
+import { coerce, number, object, string, validate, type Static } from '@scalar/validation'
+
+const userSchema = object({
+  id: number(),
+  name: string(),
+})
+
+type User = Static<typeof userSchema>
+
+validate(userSchema, { id: 1, name: 'Ada' }) // true
+validate(userSchema, { id: 1, name: 2 }) // false
+
+// Best-effort shaping: invalid primitives fall back to defaults
+coerce(userSchema, { id: 'x', name: 'Ada' }) // { id: 0, name: 'Ada' }
+```
+
+## Concepts
+
+### `validate(schema, value)`
+
+Returns `true` if `value` satisfies `schema`, otherwise `false`.
+
+- **`undefined` schema** — always fails.
+- **`number()`** — finite numbers only (`NaN` and `Infinity` fail).
+- **`object({ ... })`** — value must be a **plain object** (see [Objects and records](#objects-and-records)). Each declared property is validated; **extra properties are not rejected**.
+- **`union([...])`** — matches if **any** branch matches.
+
+### `coerce(schema, value)`
+
+Returns a value typed as `Static<typeof schema>`. It is **not** strict validation: it **normalizes** toward the schema.
+
+- Valid primitives are returned as-is.
+- Invalid **number** → `0`, invalid **string** → `''`, invalid **boolean** → `false`.
+- **`nullable()`** — result is always `null`.
+- **`notDefined()`** — result is always `undefined`.
+- **`literal(x)`** — result is always the schema’s literal `x` (the declared constant).
+- **`array` / `object` / `record`** — built recursively; wrong shapes become empty containers or defaulted fields.
+- **`union`** — picks a branch using a **scoring** heuristic (object shape and literal tags weigh more than “property exists”).
+- Optional third argument: internal **`WeakMap` cache** for cyclic graphs; you normally omit it.
+
+Use **`validate`** when you need a yes/no. Use **`coerce`** when you want a stable default-filled structure (for example normalizing config or parsed JSON).
+
+## Schema builders
+
+| Builder | Validates | `Static` type (idea) |
+|--------|-----------|----------------------|
+| `number()` | Finite `number` | `number` |
+| `string()` | `string` | `string` |
+| `boolean()` | `boolean` | `boolean` |
+| `nullable()` | `null` only | `null` |
+| `notDefined()` | `undefined` only | `undefined` |
+| `any()` | Anything | `any` |
+| `literal(v)` | Strict equality to `v` | `typeof v` |
+| `array(item)` | Array; every item matches `item` | `Static<item>[]` |
+| `record(key, value)` | Plain object; keys and values match | `Record<…, …>` |
+| `object(props)` | Plain object; each key in `props` | Object of static fields |
+| `union([a, b, …])` | Matches any member | Union of branches |
+| `optional(s)` | Shorthand for `union([s, notDefined()])` | `Static<s> \| undefined` |
+| `lazy(() => schema)` | Defers schema (recursion) | Inferred from inner schema |
+| `evaluate(fn, schema)` | Runs `fn(value)` then validates `schema` | `Static<schema>` |
+
+```ts
+import { lazy, object, string, union, literal } from '@scalar/validation'
+
+// Discriminated-style union
+const message = union([
+  object({ type: literal('text'), body: string() }),
+  object({ type: literal('ping') }),
+])
+```
+
+### `evaluate` — parse then validate
+
+```ts
+import { evaluate, number, string } from '@scalar/validation'
+
+const trimmed = evaluate((v) => (typeof v === 'string' ? v.trim() : v), string())
+
+validate(trimmed, '  hi  ') // true (after trim)
+```
+
+## Objects and records
+
+**Plain object** means: not `null`, and prototype is `Object.prototype` or `null`. Arrays, `Date`, and most class instances **do not** count as objects for `object()` / `record()` validation.
+
+**`object`** checks only the keys you list. Missing keys are read as `undefined`, so pair them with `optional(...)` when a field may be absent.
+
+**`record`** during **validation** checks every key against the key schema and every value against the value schema. During **coercion**, entries keep their string keys as-is and only values are coerced.
+
+## TypeScript: `Static` and `Schema`
+
+- **`Static<S>`** — inferred TypeScript type for data that matches schema `S` (depth-limited to avoid infinite recursion on very deep types).
+- **`Schema`** — union of all schema shapes; use when you store or pass schemas around.
+
+## Development
+
+```bash
+pnpm --filter @scalar/validation test
+pnpm --filter @scalar/validation types:check
+pnpm --filter @scalar/validation build
+```
+
+## License
+
+MIT

package/dist/coerce.d.ts

@@ -0,0 +1,22 @@
+import type { Schema } from './schema.js';
+import type { Static } from './types.js';
+/**
+ * Coerces an unknown value toward the static type implied by `schema`. Values that
+ * pass {@link validate} for that branch are kept; otherwise primitives default to
+ * `0`, `''`, or `false`, and arrays, records, and objects are built recursively.
+ * Unions pick the best-matching branch; `evaluate` runs `expression` before the inner schema.
+ *
+ * @example
+ * ```ts
+ * import { coerce, number, object, string } from '@scalar/validation'
+ *
+ * coerce(number(), 42) // 42
+ * coerce(number(), 'nope') // 0 — invalid number uses default
+ * coerce(object({ id: number(), name: string() }), { id: '1', name: 'Ada' }) // { id: 0, name: 'Ada' }
+ * ```
+ *
+ * The optional `cache` argument tracks visited object–schema pairs to stop infinite recursion
+ * on cyclic graphs; callers normally omit it.
+ */
+export declare const coerce: <S extends Schema>(schema: S, value: unknown, cache?: WeakMap<object, Set<Schema>>) => Static<S>;
+//# sourceMappingURL=coerce.d.ts.map

package/dist/coerce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerce.d.ts","sourceRoot":"","sources":["../src/coerce.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAwDrC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,EACrC,QAAQ,CAAC,EACT,OAAO,OAAO,EACd,QAAO,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAiB,KAClD,MAAM,CAAC,CAAC,CA0FV,CAAA"}

package/dist/coerce.js

@@ -0,0 +1,149 @@
+import { isObject } from './helpers/is-object.js';
+import { validate } from './validate.js';
+/**
+ * Computes a "score" indicating how well a value matches a schema,
+ * used for picking the best branch in union coercion.
+ *
+ * Higher score means a closer match. Literals and matching object shapes
+ * are weighted more heavily. Objects are scored by shape/literals;
+ * arrays/records by structural type; primitives by validation; unions try all branches.
+ */
+const scoreUnion = (schema, value) => {
+    if (schema.type === 'object') {
+        if (!isObject(value)) {
+            return 0;
+        }
+        // For each key in the schema's properties:
+        // - +10 if the value matches an explicit literal for the key.
+        // - +1 if the property exists (not literal match).
+        return Object.keys(schema.properties).reduce((acc, key) => {
+            const exists = key in value;
+            const isLiteralMatch = schema.properties[key].type === 'literal' && value[key] === schema.properties[key].value;
+            if (isLiteralMatch) {
+                return acc + 10;
+            }
+            return acc + (exists ? 1 : 0);
+        }, 0);
+    }
+    if (schema.type === 'array') {
+        // Score 1 if value is an array, otherwise 0
+        return Array.isArray(value) ? 1 : 0;
+    }
+    if (schema.type === 'record') {
+        // TODO: implement smarter scoring for records (just a placeholder for now)
+        return isObject(value) ? 1 : 0;
+    }
+    if (schema.type === 'union') {
+        // For a union, use the highest score among all sub-schemas
+        return Math.max(...schema.schemas.map((schema) => scoreUnion(schema, value)));
+    }
+    if (schema.type === 'lazy') {
+        // For a lazy schema, evaluate the inner schema and recurse
+        return scoreUnion(schema.schema(), value);
+    }
+    if (schema.type === 'evaluate') {
+        // For an evaluate schema, evaluate the expression and recurse
+        return scoreUnion(schema.schema, schema.expression(value));
+    }
+    // For primitives and any other type, return 1 if valid, otherwise 0
+    return validate(schema, value) ? 1 : 0;
+};
+/**
+ * Coerces an unknown value toward the static type implied by `schema`. Values that
+ * pass {@link validate} for that branch are kept; otherwise primitives default to
+ * `0`, `''`, or `false`, and arrays, records, and objects are built recursively.
+ * Unions pick the best-matching branch; `evaluate` runs `expression` before the inner schema.
+ *
+ * @example
+ * ```ts
+ * import { coerce, number, object, string } from '@scalar/validation'
+ *
+ * coerce(number(), 42) // 42
+ * coerce(number(), 'nope') // 0 — invalid number uses default
+ * coerce(object({ id: number(), name: string() }), { id: '1', name: 'Ada' }) // { id: 0, name: 'Ada' }
+ * ```
+ *
+ * The optional `cache` argument tracks visited object–schema pairs to stop infinite recursion
+ * on cyclic graphs; callers normally omit it.
+ */
+export const coerce = (schema, value, cache = new WeakMap()) => {
+    // Prevent infinite recursion
+    if (isObject(value) && cache.get(value)?.has(schema)) {
+        return value;
+    }
+    // Track visited schemas to prevent infinite recursion
+    if (isObject(value)) {
+        const schemas = cache.get(value) || new Set();
+        schemas.add(schema);
+        cache.set(value, schemas);
+    }
+    // If no schema is provided, return the value as is
+    if (!schema) {
+        return value;
+    }
+    if (schema.type === 'any') {
+        return value;
+    }
+    if (schema.type === 'number') {
+        if (validate(schema, value)) {
+            return value;
+        }
+        return 0;
+    }
+    if (schema.type === 'string') {
+        if (validate(schema, value)) {
+            return value;
+        }
+        return '';
+    }
+    if (schema.type === 'boolean') {
+        if (validate(schema, value)) {
+            return value;
+        }
+        return false;
+    }
+    if (schema.type === 'nullable') {
+        return null;
+    }
+    if (schema.type === 'notDefined') {
+        return undefined;
+    }
+    if (schema.type === 'array') {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value.map((item) => coerce(schema.items, item, cache));
+    }
+    if (schema.type === 'record') {
+        if (!isObject(value)) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, coerce(schema.value, value, cache)]));
+    }
+    if (schema.type === 'object') {
+        const keys = Object.keys(schema.properties);
+        const target = isObject(value) ? value : null;
+        return Object.fromEntries(keys.map((key) => [key, coerce(schema.properties[key], target?.[key], cache)]));
+    }
+    if (schema.type === 'union') {
+        const branch = schema.schemas.reduce((acc, schema) => {
+            const score = scoreUnion(schema, value);
+            return score > acc.score ? { schema, score } : acc;
+        }, { schema: schema.schemas[0], score: 0 });
+        // We need some way to pick one of the union values
+        return coerce(branch.schema, value, cache);
+    }
+    if (schema.type === 'literal') {
+        return schema.value;
+    }
+    if (schema.type === 'lazy') {
+        return coerce(schema.schema(), value, cache);
+    }
+    if (schema.type === 'evaluate') {
+        return coerce(schema.schema, schema.expression(value), cache);
+    }
+    // We need to assert here that schema has the type never so we know we handle all cases
+    const _exhaustive = schema;
+    console.warn('Unknown schema type:', _exhaustive);
+    return value;
+};

package/dist/helpers/is-object.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Stolen from |@scalar/helpers/object/is-object.ts|
+ * so we don't have to depend on it.
+ */
+/**
+ * Returns true if the provided value is a record object
+ * (i.e. not null, not an array, and has an actual object as the prototype).
+ *
+ * Differs from the previous isObject in that it returns false for Date,
+ * RegExp, Error, Map, Set, WeakMap, WeakSet, Promise, and other non-plain objects.
+ *
+ * Examples:
+ *   isObject({})                  // true
+ *   isObject({ a: 1 })            // true
+ *   isObject([])                  // false (Array)
+ *   isObject(null)                // false
+ *   isObject(123)                 // false
+ *   isObject('string')            // false
+ *   isObject(new Error('test'))   // false
+ *   isObject(new Date())          // false
+ *   isObject(Object.create(null)) // true
+ */
+export declare const isObject: (value: unknown) => value is Record<string | number | symbol, unknown>;
+//# sourceMappingURL=is-object.d.ts.map

package/dist/helpers/is-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object.d.ts","sourceRoot":"","sources":["../../src/helpers/is-object.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAO1F,CAAA"}

package/dist/helpers/is-object.js

@@ -0,0 +1,29 @@
+/**
+ * Stolen from |@scalar/helpers/object/is-object.ts|
+ * so we don't have to depend on it.
+ */
+/**
+ * Returns true if the provided value is a record object
+ * (i.e. not null, not an array, and has an actual object as the prototype).
+ *
+ * Differs from the previous isObject in that it returns false for Date,
+ * RegExp, Error, Map, Set, WeakMap, WeakSet, Promise, and other non-plain objects.
+ *
+ * Examples:
+ *   isObject({})                  // true
+ *   isObject({ a: 1 })            // true
+ *   isObject([])                  // false (Array)
+ *   isObject(null)                // false
+ *   isObject(123)                 // false
+ *   isObject('string')            // false
+ *   isObject(new Error('test'))   // false
+ *   isObject(new Date())          // false
+ *   isObject(Object.create(null)) // true
+ */
+export const isObject = (value) => {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { coerce } from './coerce.js';
+export { type Schema, any, array, boolean, evaluate, lazy, literal, notDefined, nullable, number, object, optional, record, string, union, } from './schema.js';
+export type { Static } from './types.js';
+export { validate } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EACL,KAAK,MAAM,EACX,GAAG,EACH,KAAK,EACL,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,UAAU,EACV,QAAQ,EACR,MAAM,EACN,MAAM,EACN,QAAQ,EACR,MAAM,EACN,MAAM,EACN,KAAK,GACN,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { coerce } from './coerce.js';
+export { any, array, boolean, evaluate, lazy, literal, notDefined, nullable, number, object, optional, record, string, union, } from './schema.js';
+export { validate } from './validate.js';

package/dist/schema.d.ts

@@ -0,0 +1,85 @@
+/** Schema for finite numeric values. {@link Static} resolves to `number`. */
+export type NumberSchema = {
+    type: 'number';
+};
+/** Schema for string values. {@link Static} resolves to `string`. */
+export type StringSchema = {
+    type: 'string';
+};
+/** Schema for boolean values. {@link Static} resolves to `boolean`. */
+export type BooleanSchema = {
+    type: 'boolean';
+};
+/** Schema for `null`. {@link Static} resolves to `null`. */
+export type NullableSchema = {
+    type: 'nullable';
+};
+/** Schema for a missing or omitted value. {@link Static} resolves to `undefined`. */
+export type NotDefinedSchema = {
+    type: 'notDefined';
+};
+/** Schema that accepts any value without narrowing. {@link Static} resolves to `any`. */
+export type AnySchema = {
+    type: 'any';
+};
+/** Schema for homogeneous lists. {@link Static} resolves to an array of the item static type. */
+export type ArraySchema<Item extends Schema> = {
+    type: 'array';
+    items: Item;
+};
+/** Schema for key-value maps with uniform value shape. Keys are constrained to string or number schemas. */
+export type RecordSchema<Key extends StringSchema | NumberSchema | AnySchema, Value extends Schema> = {
+    type: 'record';
+    key: Key;
+    value: Value;
+};
+/** Schema for objects with a fixed set of named properties, each with its own schema. */
+export type ObjectSchema<Properties extends Record<string, Schema>> = {
+    type: 'object';
+    properties: Properties;
+};
+/** Schema that matches if any member schema matches (discriminated union when literals or object tags differ). */
+export type UnionSchema<Schemas extends Schema[]> = {
+    type: 'union';
+    schemas: Schemas;
+};
+/** Schema for a single exact constant (string, number, boolean, or bigint). {@link Static} is that literal type. */
+export type LiteralSchema<T extends string | number | boolean | bigint> = {
+    type: 'literal';
+    value: T;
+};
+/**
+ * Schema for self-referential or recursive types (such as trees or linked lists).
+ * The `schema` property is a factory function returning a schema instance, allowing
+ * references to itself without causing circular definition errors at type-level.
+ */
+export type LazySchema<S extends () => Schema> = {
+    type: 'lazy';
+    schema: S;
+};
+/**
+ * Schema that runs a coercion or transform (`expression`) on the input, then validates with the inner schema.
+ * Use when parsing needs a preprocessing step before the usual rules apply.
+ */
+export type EvaluateSchema<S extends Schema> = {
+    type: 'evaluate';
+    expression: (value: unknown) => unknown;
+    schema: S;
+};
+export type Schema = NumberSchema | StringSchema | BooleanSchema | NullableSchema | NotDefinedSchema | AnySchema | ArraySchema<any> | RecordSchema<any, any> | ObjectSchema<Record<string, any>> | UnionSchema<any[]> | LiteralSchema<any> | LazySchema<any> | EvaluateSchema<any>;
+declare const number: () => NumberSchema;
+declare const string: () => StringSchema;
+declare const boolean: () => BooleanSchema;
+declare const nullable: () => NullableSchema;
+declare const notDefined: () => NotDefinedSchema;
+declare const any: () => AnySchema;
+declare const array: <Item extends Schema>(items: Item) => ArraySchema<Item>;
+declare const record: <Key extends StringSchema | AnySchema, Value extends Schema>(key: Key, value: Value) => RecordSchema<Key, Value>;
+declare const object: <Properties extends Record<string, Schema>>(properties: Properties) => ObjectSchema<Properties>;
+declare const union: <Schemas extends Schema[]>(schemas: Schemas) => UnionSchema<Schemas>;
+declare const optional: <S extends Schema>(schema: S) => UnionSchema<(NotDefinedSchema | S)[]>;
+declare const literal: <Value extends string | number | boolean | bigint>(value: Value) => LiteralSchema<Value>;
+declare const lazy: <S extends () => Schema>(schema: S) => LazySchema<S>;
+declare const evaluate: <S extends Schema>(expression: (value: unknown) => unknown, schema: S) => EvaluateSchema<S>;
+export { number, string, boolean, nullable, notDefined, any, array, record, object, union, optional, literal, lazy, evaluate, };
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/dist/schema.js

@@ -0,0 +1,50 @@
+const number = () => ({
+    type: 'number',
+});
+const string = () => ({
+    type: 'string',
+});
+const boolean = () => ({
+    type: 'boolean',
+});
+const nullable = () => ({
+    type: 'nullable',
+});
+const notDefined = () => ({
+    type: 'notDefined',
+});
+const any = () => ({
+    type: 'any',
+});
+const array = (items) => ({
+    type: 'array',
+    items,
+});
+const record = (key, value) => ({
+    type: 'record',
+    key,
+    value,
+});
+const object = (properties) => ({
+    type: 'object',
+    properties,
+});
+const union = (schemas) => ({
+    type: 'union',
+    schemas,
+});
+const optional = (schema) => union([schema, notDefined()]);
+const literal = (value) => ({
+    type: 'literal',
+    value,
+});
+const lazy = (schema) => ({
+    type: 'lazy',
+    schema,
+});
+const evaluate = (expression, schema) => ({
+    type: 'evaluate',
+    expression,
+    schema,
+});
+export { number, string, boolean, nullable, notDefined, any, array, record, object, union, optional, literal, lazy, evaluate, };

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import type { AnySchema, ArraySchema, BooleanSchema, EvaluateSchema, LazySchema, LiteralSchema, NotDefinedSchema, NullableSchema, NumberSchema, ObjectSchema, RecordSchema, StringSchema, UnionSchema } from './schema.js';
+export type Static<T> = _Static<T, 10>;
+type _Static<T, Depth extends number = 10> = Depth extends 0 ? any : T extends LiteralSchema<infer Value> ? Value : T extends NumberSchema ? number : T extends StringSchema ? string : T extends BooleanSchema ? boolean : T extends NullableSchema ? null : T extends NotDefinedSchema ? undefined : T extends AnySchema ? any : T extends ArraySchema<infer Item> ? Array<_Static<Item, Prev<Depth>>> : T extends RecordSchema<infer Key, infer Value> ? Record<_Static<Key, Prev<Depth>> & PropertyKey, _Static<Value, Prev<Depth>>> : T extends ObjectSchema<infer Properties> ? {
+    [K in keyof Properties]: _Static<Properties[K], Prev<Depth>>;
+} : T extends UnionSchema<infer Schemas> ? _Static<Schemas[number], Prev<Depth>> : T extends EvaluateSchema<infer S> ? _Static<S, Prev<Depth>> : T extends LazySchema<infer S> ? _Static<ReturnType<S>, Prev<Depth>> : never;
+type Prev<T extends number> = T extends 10 ? 9 : T extends 9 ? 8 : T extends 8 ? 7 : T extends 7 ? 6 : T extends 6 ? 5 : T extends 5 ? 4 : T extends 4 ? 3 : T extends 3 ? 2 : T extends 2 ? 1 : T extends 1 ? 0 : 0;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,aAAa,EACb,cAAc,EACd,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,WAAW,EACZ,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;AAGtC,KAAK,OAAO,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,GAAG,EAAE,IAAI,KAAK,SAAS,CAAC,GACxD,GAAG,GACH,CAAC,SAAS,aAAa,CAAC,MAAM,KAAK,CAAC,GAClC,KAAK,GACL,CAAC,SAAS,YAAY,GACpB,MAAM,GACN,CAAC,SAAS,YAAY,GACpB,MAAM,GACN,CAAC,SAAS,aAAa,GACrB,OAAO,GACP,CAAC,SAAS,cAAc,GACtB,IAAI,GACJ,CAAC,SAAS,gBAAgB,GACxB,SAAS,GACT,CAAC,SAAS,SAAS,GACjB,GAAG,GACH,CAAC,SAAS,WAAW,CAAC,MAAM,IAAI,CAAC,GAC/B,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GACjC,CAAC,SAAS,YAAY,CAAC,MAAM,GAAG,EAAE,MAAM,KAAK,CAAC,GAC5C,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAC5E,CAAC,SAAS,YAAY,CAAC,MAAM,UAAU,CAAC,GACtC;KAAG,CAAC,IAAI,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;CAAE,GAChE,CAAC,SAAS,WAAW,CAAC,MAAM,OAAO,CAAC,GAClC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GACrC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAC/B,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GACvB,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GACnC,KAAK,CAAA;AAGnC,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,EAAE,GACtC,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,SAAS,CAAC,GACT,CAAC,GACD,CAAC,CAAA"}

package/dist/types.js

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

package/dist/validate.d.ts

@@ -0,0 +1,34 @@
+import type { Schema } from './schema.js';
+/**
+ * Validates that a given value matches the specified schema.
+ *
+ * The schema describes the expected structure/type of data.
+ * Supported schema types include:
+ * - 'any':         Accepts any value.
+ * - 'number':      Only numbers are valid.
+ * - 'string':      Only strings are valid.
+ * - 'boolean':     Only booleans are valid.
+ * - 'nullable':    Only `null` is valid.
+ * - 'notDefined':  Only `undefined` is valid.
+ * - 'array':       Array with all items validated recursively.
+ * - 'record':      Object with string/number keys and values, checked recursively.
+ * - 'object':      Object with fixed property keys, each validated recursively.
+ * - 'union':       Accepts if value matches any of the listed schemas.
+ * - 'literal':     Exact match with a literal value.
+ * - 'recursive':   Schema referring to itself for nested validation (e.g. trees).
+ * - 'evaluate':    Transforms value then validates against an inner schema.
+ *
+ * @example
+ * ```ts
+ * import { number, object, string, validate } from '@scalar/validation'
+ *
+ * const schema = object({ id: number(), name: string() })
+ * validate(schema, { id: 1, name: 'Ada' }) // true
+ * validate(schema, { id: 1, name: 2 }) // false
+ * ```
+ *
+ * If schema is `undefined`, validation fails.
+ * Returns true if the value matches the schema, false otherwise.
+ */
+export declare const validate: (schema: Schema | undefined, value: unknown) => boolean;
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,GAAG,SAAS,EAAE,OAAO,OAAO,KAAG,OAwDrE,CAAA"}