@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/literal.ts

@@ -1,70 +0,0 @@
-import { Schema, ValidationContext } from '../core.js'
-
-/**
- * Schema that only accepts a specific literal value.
- *
- * Validates that the input is exactly equal to the specified value using
- * strict equality (===).
- *
- * @template TValue - The literal type (null, string, number, or boolean)
- *
- * @example
- * ```ts
- * const schema = new LiteralSchema('admin')
- * schema.validate('admin') // success
- * schema.validate('user')  // fails
- * ```
- */
-export class LiteralSchema<
-  const TValue extends null | string | number | boolean,
-> extends Schema<TValue> {
-  readonly type = 'literal' as const
-
-  constructor(readonly value: TValue) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (input !== this.value) {
-      return ctx.issueInvalidValue(input, [this.value])
-    }
-
-    return ctx.success(this.value)
-  }
-}
-
-/**
- * Creates a literal schema that only accepts the exact specified value.
- *
- * Useful for discriminator fields in unions, constant values, or type narrowing.
- *
- * @param value - The exact value that must be matched
- * @returns A new {@link LiteralSchema} instance
- *
- * @example
- * ```ts
- * // String literal
- * const roleSchema = l.literal('admin')
- *
- * // Number literal
- * const versionSchema = l.literal(1)
- *
- * // Boolean literal
- * const enabledSchema = l.literal(true)
- *
- * // Null literal
- * const nullSchema = l.literal(null)
- *
- * // In discriminated unions
- * const actionSchema = l.discriminatedUnion('type', [
- *   l.object({ type: l.literal('create'), data: l.unknown() }),
- *   l.object({ type: l.literal('delete'), id: l.string() }),
- * ])
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function literal<const V extends null | string | number | boolean>(
-  value: V,
-) {
-  return new LiteralSchema<V>(value)
-}

package/src/schema/never.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { never } from './never.js'
-
-describe('NeverSchema', () => {
-  describe('basic validation', () => {
-    const schema = never()
-
-    it('rejects strings', () => {
-      const result = schema.safeParse('string')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects numbers', () => {
-      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([])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects empty strings', () => {
-      const result = schema.safeParse('')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects zero', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects false', () => {
-      const result = schema.safeParse(false)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    const schema = never()
-
-    it('rejects BigInt', () => {
-      const result = schema.safeParse(BigInt(123))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Symbol', () => {
-      const result = schema.safeParse(Symbol('test'))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects functions', () => {
-      const result = schema.safeParse(() => {})
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Date objects', () => {
-      const result = schema.safeParse(new Date())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects RegExp objects', () => {
-      const result = schema.safeParse(/test/)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects nested objects', () => {
-      const result = schema.safeParse({ nested: { value: 'test' } })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects nested arrays', () => {
-      const result = schema.safeParse([
-        [1, 2],
-        [3, 4],
-      ])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Map objects', () => {
-      const result = schema.safeParse(new Map())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Set objects', () => {
-      const result = schema.safeParse(new Set())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Error objects', () => {
-      const result = schema.safeParse(new Error('test'))
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('complex data types', () => {
-    const schema = never()
-
-    it('rejects class instances', () => {
-      class TestClass {
-        value = 'test'
-      }
-      const result = schema.safeParse(new TestClass())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with values', () => {
-      const result = schema.safeParse([1, 2, 3, 'four', true])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects objects with properties', () => {
-      const result = schema.safeParse({
-        name: 'test',
-        age: 30,
-        active: true,
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Promise objects', () => {
-      const result = schema.safeParse(Promise.resolve(42))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Buffer objects', () => {
-      const result = schema.safeParse(Buffer.from('test'))
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('special number values', () => {
-    const schema = never()
-
-    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 negative Infinity', () => {
-      const result = schema.safeParse(-Infinity)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects negative zero', () => {
-      const result = schema.safeParse(-0)
-      expect(result.success).toBe(false)
-    })
-  })
-})

package/src/schema/never.ts

@@ -1,56 +0,0 @@
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Schema that always fails validation.
- *
- * Represents an impossible type - no value can satisfy this schema.
- * Useful for exhaustiveness checking or marking impossible branches.
- *
- * @example
- * ```ts
- * const schema = new NeverSchema()
- * schema.validate(anything) // always fails
- * ```
- */
-export class NeverSchema extends Schema<never> {
-  readonly type = 'never' as const
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    return ctx.issueUnexpectedType(input, 'never')
-  }
-}
-
-/**
- * Creates a never schema that always fails validation.
- *
- * Useful for exhaustiveness checking in TypeScript or marking impossible
- * code paths.
- *
- * @returns A new {@link NeverSchema} instance
- *
- * @example
- * ```ts
- * // Exhaustiveness checking
- * type Status = 'active' | 'inactive'
- *
- * function handleStatus(status: Status) {
- *   switch (status) {
- *     case 'active': return 'Active'
- *     case 'inactive': return 'Inactive'
- *     default:
- *       // TypeScript will error if we miss a case
- *       l.never().parse(status)
- *   }
- * }
- *
- * // In impossible union branches
- * const schema = l.object({
- *   type: l.literal('fixed'),
- *   dynamic: l.never(), // This property can never exist
- * })
- * ```
- */
-export const never = /*#__PURE__*/ memoizedOptions(function () {
-  return new NeverSchema()
-})

package/src/schema/null.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { nullSchema } from './null.js'
-
-describe('NullSchema', () => {
-  describe('basic validation', () => {
-    const schema = nullSchema()
-
-    it('validates null', () => {
-      const result = schema.safeParse(null)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe(null)
-      }
-    })
-
-    it('rejects strings', () => {
-      const result = schema.safeParse('null')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects numbers', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects booleans', () => {
-      const result = schema.safeParse(false)
-      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([])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects empty string', () => {
-      const result = schema.safeParse('')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    const schema = nullSchema()
-
-    it('rejects falsy values', () => {
-      const result = schema.safeParse(0)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects string "null"', () => {
-      const result = schema.safeParse('null')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects NaN', () => {
-      const result = schema.safeParse(NaN)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects nested null in object', () => {
-      const result = schema.safeParse({ value: null })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects nested null in array', () => {
-      const result = schema.safeParse([null])
-      expect(result.success).toBe(false)
-    })
-  })
-})

package/src/schema/null.ts

@@ -1,49 +0,0 @@
-import { Schema, ValidationContext } from '../core.js'
-import { memoizedOptions } from '../util/memoize.js'
-
-/**
- * Schema for validating null values.
- *
- * Only accepts the JavaScript `null` value. Rejects `undefined` and all
- * other values.
- *
- * @example
- * ```ts
- * const schema = new NullSchema()
- * schema.validate(null)      // success
- * schema.validate(undefined) // fails
- * ```
- */
-export class NullSchema extends Schema<null> {
-  readonly type = 'null' as const
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (input !== null) {
-      return ctx.issueUnexpectedType(input, 'null')
-    }
-
-    return ctx.success(null)
-  }
-}
-
-/**
- * Creates a null schema that only accepts the null value.
- *
- * Useful for explicitly representing null in union types or optional fields.
- *
- * @returns A new {@link NullSchema} instance
- *
- * @example
- * ```ts
- * // Explicit null
- * const nullOnlySchema = l.null()
- *
- * // Nullable string (string or null)
- * const nullableStringSchema = l.union([l.string(), l.null()])
- * ```
- */
-export const nullSchema = /*#__PURE__*/ memoizedOptions(function () {
-  return new NullSchema()
-})
-
-export { nullSchema as null }