@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/integer.test.ts

@@ -1,314 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { integer } from './integer.js'
-import { withDefault } from './with-default.js'
-
-describe('IntegerSchema', () => {
-  describe('basic validation', () => {
-    const schema = integer()
-
-    it('validates integers', () => {
-      const result = schema.safeParse(42)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates zero', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates negative integers', () => {
-      const result = schema.safeParse(-42)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates large integers', () => {
-      const result = schema.safeParse(Number.MAX_SAFE_INTEGER)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates small integers', () => {
-      const result = schema.safeParse(Number.MIN_SAFE_INTEGER)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects floats', () => {
-      const result = schema.safeParse(3.14)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects strings', () => {
-      const result = schema.safeParse('42')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects booleans', () => {
-      const result = schema.safeParse(true)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects null', () => {
-      const result = schema.safeParse(null)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects undefined', () => {
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects objects', () => {
-      const result = schema.safeParse({})
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays', () => {
-      const result = schema.safeParse([42])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects NaN', () => {
-      const result = schema.safeParse(NaN)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Infinity', () => {
-      const result = schema.safeParse(Infinity)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects -Infinity', () => {
-      const result = schema.safeParse(-Infinity)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('default value', () => {
-    const schema = withDefault(integer(), 10)
-
-    it('uses default when undefined is provided', () => {
-      const result = schema.safeParse(undefined)
-      expect(result).toMatchObject({
-        success: true,
-        value: 10,
-      })
-    })
-
-    it('does not use default when explicit value is provided', () => {
-      const result = schema.safeParse(20)
-      expect(result).toMatchObject({
-        success: true,
-        value: 20,
-      })
-    })
-
-    it('does not use default when zero is provided', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(0)
-      }
-    })
-  })
-
-  describe('minimum constraint', () => {
-    const schema = integer({ minimum: 10 })
-
-    it('accepts values equal to minimum', () => {
-      const result = schema.safeParse(10)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts values greater than minimum', () => {
-      const result = schema.safeParse(20)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects values less than minimum', () => {
-      const result = schema.safeParse(5)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects zero when minimum is positive', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects negative values when minimum is positive', () => {
-      const result = schema.safeParse(-10)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('maximum constraint', () => {
-    const schema = integer({ maximum: 100 })
-
-    it('accepts values equal to maximum', () => {
-      const result = schema.safeParse(100)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts values less than maximum', () => {
-      const result = schema.safeParse(50)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects values greater than maximum', () => {
-      const result = schema.safeParse(150)
-      expect(result.success).toBe(false)
-    })
-
-    it('accepts zero when maximum is positive', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts negative values when maximum is positive', () => {
-      const result = schema.safeParse(-10)
-      expect(result.success).toBe(true)
-    })
-  })
-
-  describe('minimum and maximum constraints', () => {
-    const schema = integer({ minimum: 10, maximum: 100 })
-
-    it('accepts values within range', () => {
-      const result = schema.safeParse(50)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts minimum value', () => {
-      const result = schema.safeParse(10)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts maximum value', () => {
-      const result = schema.safeParse(100)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects values below minimum', () => {
-      const result = schema.safeParse(5)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects values above maximum', () => {
-      const result = schema.safeParse(150)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('negative range constraints', () => {
-    const schema = integer({ minimum: -100, maximum: -10 })
-
-    it('accepts negative values within range', () => {
-      const result = schema.safeParse(-50)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts minimum negative value', () => {
-      const result = schema.safeParse(-100)
-      expect(result.success).toBe(true)
-    })
-
-    it('accepts maximum negative value', () => {
-      const result = schema.safeParse(-10)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects values below minimum', () => {
-      const result = schema.safeParse(-150)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects values above maximum', () => {
-      const result = schema.safeParse(-5)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects zero', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects positive values', () => {
-      const result = schema.safeParse(10)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('zero constraints', () => {
-    const schema = integer({ minimum: 0, maximum: 0 })
-
-    it('accepts zero', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects positive values', () => {
-      const result = schema.safeParse(1)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects negative values', () => {
-      const result = schema.safeParse(-1)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('combined with default value', () => {
-    const schema = withDefault(integer({ minimum: 10, maximum: 100 }), 50)
-
-    it('uses default when undefined is provided', () => {
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(50)
-      }
-    })
-
-    it('validates explicit values with constraints', () => {
-      const result = schema.safeParse(75)
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects explicit values outside constraints', () => {
-      const result = schema.safeParse(5)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('handles minimum of 0', () => {
-      const schema = integer({ minimum: 0 })
-      expect(schema.safeParse(0).success).toBe(true)
-      expect(schema.safeParse(-1).success).toBe(false)
-      expect(schema.safeParse(1).success).toBe(true)
-    })
-
-    it('handles maximum of 0', () => {
-      const schema = integer({ maximum: 0 })
-      expect(schema.safeParse(0).success).toBe(true)
-      expect(schema.safeParse(1).success).toBe(false)
-      expect(schema.safeParse(-1).success).toBe(true)
-    })
-
-    it('handles very large ranges', () => {
-      const schema = integer({
-        minimum: Number.MIN_SAFE_INTEGER,
-        maximum: Number.MAX_SAFE_INTEGER,
-      })
-      expect(schema.safeParse(Number.MIN_SAFE_INTEGER).success).toBe(true)
-      expect(schema.safeParse(Number.MAX_SAFE_INTEGER).success).toBe(true)
-      expect(schema.safeParse(0).success).toBe(true)
-    })
-
-    it('allows unconstrained schema', () => {
-      const schema = integer()
-      expect(schema.safeParse(Number.MIN_SAFE_INTEGER).success).toBe(true)
-      expect(schema.safeParse(Number.MAX_SAFE_INTEGER).success).toBe(true)
-      expect(schema.safeParse(0).success).toBe(true)
-      expect(schema.safeParse(-999999).success).toBe(true)
-      expect(schema.safeParse(999999).success).toBe(true)
-    })
-  })
-})

package/src/schema/integer.ts

@@ -1,86 +0,0 @@
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Configuration options for integer schema validation.
- *
- * @property minimum - Minimum allowed value (inclusive)
- * @property maximum - Maximum allowed value (inclusive)
- */
-export type IntegerSchemaOptions = {
-  minimum?: number
-  maximum?: number
-}
-
-/**
- * Schema for validating integer values with optional range constraints.
- *
- * Only accepts safe integers (values that can be exactly represented in JavaScript).
- * Use {@link IntegerSchemaOptions} to constrain the allowed range.
- *
- * @example
- * ```ts
- * const schema = new IntegerSchema({ minimum: 0, maximum: 100 })
- * const result = schema.validate(42)
- * ```
- */
-export class IntegerSchema extends Schema<number> {
-  readonly type = 'integer' as const
-
-  constructor(readonly options?: IntegerSchemaOptions) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!isInteger(input)) {
-      return ctx.issueUnexpectedType(input, 'integer')
-    }
-
-    if (this.options?.minimum != null && input < this.options.minimum) {
-      return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)
-    }
-
-    if (this.options?.maximum != null && input > this.options.maximum) {
-      return ctx.issueTooBig(input, 'integer', this.options.maximum, input)
-    }
-
-    return ctx.success(input)
-  }
-}
-
-/**
- * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.
- */
-function isInteger(input: unknown): input is number {
-  return Number.isSafeInteger(input)
-}
-
-/**
- * Creates an integer schema with optional minimum and maximum constraints.
- *
- * Validates that the input is a safe integer (can be exactly represented in JavaScript)
- * and optionally falls within a specified range.
- *
- * @param options - Optional configuration for minimum and maximum values
- * @returns A new {@link IntegerSchema} instance
- *
- * @example
- * ```ts
- * // Basic integer
- * const countSchema = l.integer()
- *
- * // With minimum value
- * const positiveSchema = l.integer({ minimum: 1 })
- *
- * // With range constraints
- * const percentSchema = l.integer({ minimum: 0, maximum: 100 })
- *
- * // Age validation
- * const ageSchema = l.integer({ minimum: 0, maximum: 150 })
- * ```
- */
-export const integer = /*#__PURE__*/ memoizedOptions(function (
-  options?: IntegerSchemaOptions,
-) {
-  return new IntegerSchema(options)
-})

package/src/schema/intersection.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { boolean } from './boolean.js'
-import { dict } from './dict.js'
-import { enumSchema } from './enum.js'
-import { intersection } from './intersection.js'
-import { object } from './object.js'
-import { string } from './string.js'
-
-describe('IntersectionSchema', () => {
-  const schema = intersection(
-    object({
-      title: string(),
-    }),
-    dict(enumSchema(['tag1', 'tag2']), boolean()),
-  )
-
-  it('validates extra properties with the provided validator', () => {
-    const result = schema.safeParse({
-      title: 'My Post',
-      tag1: true,
-      tag2: false,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects extra properties that fail the provided validator', () => {
-    const result = schema.safeParse({
-      title: 'My Post',
-      tag1: 'not a boolean',
-    })
-    expect(result.success).toBe(false)
-  })
-})

package/src/schema/intersection.ts

@@ -1,113 +0,0 @@
-import {
-  InferInput,
-  InferOutput,
-  Schema,
-  Simplify,
-  ValidationContext,
-} from '../core.js'
-import { DictSchema } from './dict.js'
-import { ObjectSchema } from './object.js'
-
-/**
- * Type utility for computing the intersection of two object types.
- *
- * Allows to more accurately represent the intersection of two object types
- * where both types may share some keys, and one of them uses an index
- * signature.
- *
- * @template A - First object type (typically from ObjectSchema)
- * @template B - Second object type (typically from DictSchema)
- *
- * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}
- */
-export type Intersect<A, B> = B[keyof B] extends never
-  ? A
-  : keyof A & keyof B extends never
-    ? // If A and B don't overlap, just return A & B
-      A & B
-    : // Otherwise, properly represent the fact that accessing using an
-      // index signature could return a value from either A or B
-      A & { [K in keyof B]: B[K] | A[keyof A & K] }
-
-/**
- * Schema for combining an object schema with a dictionary schema.
- *
- * Validates that the input matches both the fixed object shape and allows
- * additional properties that match the dictionary schema. Properties defined
- * in the object schema are validated by the object, and remaining properties
- * are validated by the dictionary.
- *
- * @template Left - The ObjectSchema type for fixed properties
- * @template Right - The DictSchema type for additional properties
- *
- * @example
- * ```ts
- * const schema = new IntersectionSchema(
- *   l.object({ name: l.string() }),
- *   l.dict(l.string(), l.integer())
- * )
- * // Validates: { name: 'test', score: 100, count: 5 }
- * ```
- */
-export class IntersectionSchema<
-  const Left extends ObjectSchema = any,
-  const Right extends DictSchema = any,
-> extends Schema<
-  Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,
-  Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>
-> {
-  readonly type = 'intersection' as const
-
-  constructor(
-    protected readonly left: Left,
-    protected readonly right: Right,
-  ) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    const leftResult = ctx.validate(input, this.left)
-    if (!leftResult.success) return leftResult
-
-    return this.right.validateInContext(leftResult.value, ctx, {
-      ignoredKeys: this.left.validatorsMap,
-    })
-  }
-}
-
-/**
- * Creates an intersection schema combining fixed object properties with dynamic dictionary properties.
- *
- * Useful for objects that have a known set of properties plus additional
- * arbitrary properties that follow a pattern.
- *
- * @param left - Object schema defining the fixed, known properties
- * @param right - Dictionary schema for validating additional properties
- * @returns A new {@link IntersectionSchema} instance
- *
- * @example
- * ```ts
- * // Object with fixed and dynamic properties
- * const configSchema = l.intersection(
- *   l.object({
- *     version: l.integer(),
- *     name: l.string(),
- *   }),
- *   l.dict(l.string(), l.string()) // Additional string properties
- * )
- *
- * configSchema.parse({
- *   version: 1,
- *   name: 'my-config',
- *   customField: 'value',
- *   anotherField: 'another',
- * })
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function intersection<
-  const Left extends ObjectSchema,
-  const Right extends DictSchema,
->(left: Left, right: Right) {
-  return new IntersectionSchema<Left, Right>(left, right)
-}