@atproto/lex-schema 0.0.9 → 0.0.11

package/src/schema/unknown.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { UnknownSchema } from './unknown.js'
+import { unknown } from './unknown.js'
 
 describe('UnknownSchema', () => {
   describe('basic validation', () => {
-    const schema = new UnknownSchema()
+    const schema = unknown()
 
     it('accepts strings', () => {
       const result = schema.safeParse('hello')
@@ -81,7 +81,7 @@ describe('UnknownSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new UnknownSchema()
+    const schema = unknown()
 
     it('accepts zero', () => {
       const result = schema.safeParse(0)
@@ -252,7 +252,7 @@ describe('UnknownSchema', () => {
   })
 
   describe('special JavaScript values', () => {
-    const schema = new UnknownSchema()
+    const schema = unknown()
 
     it('accepts objects with null prototype', () => {
       const obj = Object.create(null)

package/src/schema/unknown.ts

@@ -1,10 +1,12 @@
-import { Schema, ValidationResult, ValidatorContext } from '../core.js'
+import { Schema, ValidationContext } from '../core.js'
+import { memoizedOptions } from '../util/memoize.js'
 
 export class UnknownSchema extends Schema<unknown> {
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<unknown> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     return ctx.success(input)
   }
 }
+
+export const unknown = /*#__PURE__*/ memoizedOptions(function () {
+  return new UnknownSchema()
+})

package/src/schema/with-default.ts

@@ -0,0 +1,35 @@
+import {
+  InferInput,
+  InferOutput,
+  Schema,
+  ValidationContext,
+  Validator,
+} from '../core.js'
+
+export class WithDefaultSchema<
+  const TValidator extends Validator,
+> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {
+  constructor(
+    readonly validator: TValidator,
+    readonly defaultValue: InferInput<TValidator>,
+  ) {
+    super()
+  }
+
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    // When in a validation context, the output should not be altered,
+    // so we don't apply the default.
+    if (input === undefined && ctx.options.mode !== 'validate') {
+      return ctx.validate(this.defaultValue, this.validator)
+    }
+
+    return ctx.validate(input, this.validator)
+  }
+}
+
+export function withDefault<const TValidator extends Validator>(
+  validator: TValidator,
+  defaultValue: InferInput<TValidator>,
+) {
+  return new WithDefaultSchema<TValidator>(validator, defaultValue)
+}

package/src/schema.ts

@@ -1,9 +1,3 @@
-// Global schemas
-export * from './schema/_parameters.js'
-
-// Utilities
-export * from './schema/refine.js'
-
 // Concrete Types
 export * from './schema/array.js'
 export * from './schema/blob.js'
@@ -29,7 +23,9 @@ export * from './schema/intersection.js'
 export * from './schema/nullable.js'
 export * from './schema/optional.js'
 export * from './schema/ref.js'
+export * from './schema/refine.js'
 export * from './schema/union.js'
+export * from './schema/with-default.js'
 
 // Lexicon specific Types
 export * from './schema/params.js'

package/src/util/assertion-util.ts

@@ -1,40 +1 @@
-export type AssertFn<T> = <I extends string>(input: I) => asserts input is I & T
-export type CastFn<T> = <I extends string>(input: I) => I & T
 export type CheckFn<T> = <I extends string>(input: I) => input is I & T
-
-export function createAssertFunction<T extends string>(
-  checkFn: (input: string) => input is T,
-  errorMessage?: string,
-): AssertFn<T>
-export function createAssertFunction<T extends string>(
-  checkFn: (input: string) => boolean,
-  errorMessage?: string,
-): AssertFn<T>
-export function createAssertFunction<T extends string>(
-  checkFn: (input: string) => boolean,
-  errorMessage = 'Invalid format',
-): AssertFn<T> {
-  return (input: string) => {
-    if (!checkFn(input)) throw new Error(errorMessage)
-  }
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function createCastFunction<T>(assertFn: AssertFn<T>): CastFn<T> {
-  return <I extends string>(input: I) => {
-    assertFn(input)
-    return input as I & T
-  }
-}
-
-/*@__NO_SIDE_EFFECTS__ */
-export function createCheckFunction<T>(assertFn: AssertFn<T>): CheckFn<T> {
-  return <I extends string>(input: I): input is I & T => {
-    try {
-      assertFn(input)
-      return true
-    } catch {
-      return false
-    }
-  }
-}

package/src/util/memoize.ts

@@ -1,57 +1,37 @@
 /*@__NO_SIDE_EFFECTS__*/
-export function memoizedOptions<
-  F extends (options?: NonNullable<unknown>) => any,
->(
-  fn: F,
-  keyFn?: (
-    options: NonNullable<Parameters<F>[0]>,
-  ) => string | number | boolean | null | void,
-): F {
-  let emptyOptionsValue: ReturnType<F> | undefined
+export function memoizedOptions<F extends (...args: any[]) => any>(fn: F): F {
+  let cache: null | { value: ReturnType<F> } = null
 
-  if (keyFn) {
-    const cache = new Map<string | number | boolean | null, ReturnType<F>>()
-    const fromCache = (
-      options: NonNullable<Parameters<F>[0]>,
-    ): ReturnType<F> => {
-      const key = keyFn(options)
-      if (key !== undefined) {
-        const cached = cache.get(key)
-        if (cached) return cached
-        const result = fn(options) as ReturnType<F>
-        cache.set(key, result)
-        return result
-      }
-
-      return fn(options)
+  return function cached(...args: any[]): ReturnType<F> {
+    // Not using the cache if there are args
+    if (args.length > 0) {
+      return fn(...args)
     }
 
-    return ((options: Parameters<F>[0]): ReturnType<F> => {
-      // Non-empty options case
-      if (options) for (const _ in options) return fromCache(options)
-
-      // Empty or missing options case
-      return (emptyOptionsValue ??= fn(options))
-    }) as F
-  }
-
-  return ((options: Parameters<F>[0]): ReturnType<F> => {
-    // Non-empty options case
-    if (options) for (const _ in options) return fn(options)
+    if (cache != null) {
+      return cache.value
+    }
 
-    // Empty or missing options case
-    return (emptyOptionsValue ??= fn(options))
-  }) as F
+    const value = fn(...args)
+    cache = { value }
+    return value
+  } as F
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function memoizedTransformer<F extends (arg: any) => any>(fn: F): F {
-  const cache = new WeakMap<object, ReturnType<F>>()
-  return ((arg: Parameters<F>[0]): ReturnType<F> => {
-    const cached = cache.get(arg)
+export function memoizedTransformer<
+  F extends (key: any, ...args: any[]) => unknown,
+>(fn: F): F {
+  let cache: WeakMap<object, ReturnType<F>>
+
+  return function cached(key: any, ...args: any[]): any {
+    if (args.length > 0) return fn(key, ...args)
+
+    cache ??= new WeakMap()
+    const cached = cache.get(key)
     if (cached) return cached
-    const result = fn(arg) as ReturnType<F>
-    cache.set(arg, result)
+    const result = fn(key, ...args) as ReturnType<F>
+    cache.set(key, result)
     return result
-  }) as F
+  } as F
 }

package/dist/schema/_parameters.d.ts

@@ -1,17 +0,0 @@
-import { Infer } from '../core.js';
-import { ArraySchema } from './array.js';
-import { BooleanSchema } from './boolean.js';
-import { DictSchema } from './dict.js';
-import { IntegerSchema } from './integer.js';
-import { StringSchema } from './string.js';
-import { UnionSchema } from './union.js';
-export type ParamScalar = Infer<typeof paramScalarSchema>;
-declare const paramScalarSchema: UnionSchema<[BooleanSchema, IntegerSchema, StringSchema<{}>]>;
-export type Param = Infer<typeof paramSchema>;
-export declare const paramSchema: UnionSchema<[UnionSchema<[BooleanSchema, IntegerSchema, StringSchema<{}>]>, ArraySchema<UnionSchema<[BooleanSchema, IntegerSchema, StringSchema<{}>]>>]>;
-export type Params = {
-    [_: string]: undefined | Param;
-};
-export declare const paramsSchema: DictSchema<StringSchema<{}>, UnionSchema<[UnionSchema<[BooleanSchema, IntegerSchema, StringSchema<{}>]>, ArraySchema<UnionSchema<[BooleanSchema, IntegerSchema, StringSchema<{}>]>>]>>;
-export {};
-//# sourceMappingURL=_parameters.d.ts.map

package/dist/schema/_parameters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_parameters.d.ts","sourceRoot":"","sources":["../../src/schema/_parameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAExC,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACzD,QAAA,MAAM,iBAAiB,+DAIrB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAC7C,eAAO,MAAM,WAAW,0JAGtB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,CAAA;CAAE,CAAA;AACvD,eAAO,MAAM,YAAY,wLAGI,CAAA"}

package/dist/schema/_parameters.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paramsSchema = exports.paramSchema = void 0;
-const array_js_1 = require("./array.js");
-const boolean_js_1 = require("./boolean.js");
-const dict_js_1 = require("./dict.js");
-const integer_js_1 = require("./integer.js");
-const string_js_1 = require("./string.js");
-const union_js_1 = require("./union.js");
-const paramScalarSchema = new union_js_1.UnionSchema([
-    new boolean_js_1.BooleanSchema({}),
-    new integer_js_1.IntegerSchema({}),
-    new string_js_1.StringSchema({}),
-]);
-exports.paramSchema = new union_js_1.UnionSchema([
-    paramScalarSchema,
-    new array_js_1.ArraySchema(paramScalarSchema, {}),
-]);
-exports.paramsSchema = new dict_js_1.DictSchema(new string_js_1.StringSchema({}), exports.paramSchema);
-//# sourceMappingURL=_parameters.js.map

package/dist/schema/_parameters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_parameters.js","sourceRoot":"","sources":["../../src/schema/_parameters.ts"],"names":[],"mappings":";;;AACA,yCAAwC;AACxC,6CAA4C;AAC5C,uCAAsC;AACtC,6CAA4C;AAC5C,2CAA0C;AAC1C,yCAAwC;AAGxC,MAAM,iBAAiB,GAAG,IAAI,sBAAW,CAAC;IACxC,IAAI,0BAAa,CAAC,EAAE,CAAC;IACrB,IAAI,0BAAa,CAAC,EAAE,CAAC;IACrB,IAAI,wBAAY,CAAC,EAAE,CAAC;CACrB,CAAC,CAAA;AAGW,QAAA,WAAW,GAAG,IAAI,sBAAW,CAAC;IACzC,iBAAiB;IACjB,IAAI,sBAAW,CAAC,iBAAiB,EAAE,EAAE,CAAC;CACvC,CAAC,CAAA;AAGW,QAAA,YAAY,GAAG,IAAI,oBAAU,CACxC,IAAI,wBAAY,CAAC,EAAE,CAAC,EACpB,mBAAW,CACgB,CAAA","sourcesContent":["import { Infer, Validator } from '../core.js'\nimport { ArraySchema } from './array.js'\nimport { BooleanSchema } from './boolean.js'\nimport { DictSchema } from './dict.js'\nimport { IntegerSchema } from './integer.js'\nimport { StringSchema } from './string.js'\nimport { UnionSchema } from './union.js'\n\nexport type ParamScalar = Infer<typeof paramScalarSchema>\nconst paramScalarSchema = new UnionSchema([\n  new BooleanSchema({}),\n  new IntegerSchema({}),\n  new StringSchema({}),\n])\n\nexport type Param = Infer<typeof paramSchema>\nexport const paramSchema = new UnionSchema([\n  paramScalarSchema,\n  new ArraySchema(paramScalarSchema, {}),\n])\n\nexport type Params = { [_: string]: undefined | Param }\nexport const paramsSchema = new DictSchema(\n  new StringSchema({}),\n  paramSchema,\n) satisfies Validator<Params>\n"]}

package/src/schema/_parameters.test.ts

@@ -1,417 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { paramSchema, paramsSchema } from './_parameters.js'
-
-describe('paramSchema', () => {
-  describe('scalar values', () => {
-    it('validates boolean values', () => {
-      const result = paramSchema.safeParse(true)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates integer values', () => {
-      const result = paramSchema.safeParse(42)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates string values', () => {
-      const result = paramSchema.safeParse('hello')
-      expect(result.success).toBe(true)
-    })
-
-    it('validates empty strings', () => {
-      const result = paramSchema.safeParse('')
-      expect(result.success).toBe(true)
-    })
-
-    it('validates zero', () => {
-      const result = paramSchema.safeParse(0)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates negative integers', () => {
-      const result = paramSchema.safeParse(-50)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates false boolean', () => {
-      const result = paramSchema.safeParse(false)
-      expect(result.success).toBe(true)
-    })
-  })
-
-  describe('array values', () => {
-    it('validates arrays of booleans', () => {
-      const result = paramSchema.safeParse([true, false, true])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays of integers', () => {
-      const result = paramSchema.safeParse([1, 2, 3, 4])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays of strings', () => {
-      const result = paramSchema.safeParse(['foo', 'bar', 'baz'])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates empty arrays', () => {
-      const result = paramSchema.safeParse([])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays with single element', () => {
-      const result = paramSchema.safeParse(['single'])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays with mixed scalar types', () => {
-      const result = paramSchema.safeParse([true, 42, 'text'])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays with negative integers', () => {
-      const result = paramSchema.safeParse([-1, -2, -3])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays with empty strings', () => {
-      const result = paramSchema.safeParse(['', 'non-empty', ''])
-      expect(result.success).toBe(true)
-    })
-
-    it('validates arrays with zero', () => {
-      const result = paramSchema.safeParse([0, 1, 2])
-      expect(result.success).toBe(true)
-    })
-
-    it('rejects nested arrays', () => {
-      const result = paramSchema.safeParse([
-        [1, 2],
-        [3, 4],
-      ])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with null values', () => {
-      const result = paramSchema.safeParse([1, null, 3])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with undefined values', () => {
-      const result = paramSchema.safeParse([1, undefined, 3])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with object values', () => {
-      const result = paramSchema.safeParse([1, { key: 'value' }, 3])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with floating point numbers', () => {
-      const result = paramSchema.safeParse([1, 2.5, 3])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with NaN', () => {
-      const result = paramSchema.safeParse([1, NaN, 3])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays with Infinity', () => {
-      const result = paramSchema.safeParse([1, Infinity, 3])
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('invalid values', () => {
-    it('rejects null values', () => {
-      const result = paramSchema.safeParse(null)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects undefined values', () => {
-      const result = paramSchema.safeParse(undefined)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects object values', () => {
-      const result = paramSchema.safeParse({ key: 'value' })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects floating point numbers', () => {
-      const result = paramSchema.safeParse(3.14)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects NaN', () => {
-      const result = paramSchema.safeParse(NaN)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects Infinity', () => {
-      const result = paramSchema.safeParse(Infinity)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects -Infinity', () => {
-      const result = paramSchema.safeParse(-Infinity)
-      expect(result.success).toBe(false)
-    })
-  })
-})
-
-describe('paramsSchema', () => {
-  it('validates empty object', () => {
-    const result = paramsSchema.safeParse({})
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with boolean parameters', () => {
-    const result = paramsSchema.safeParse({
-      enabled: true,
-      disabled: false,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with integer parameters', () => {
-    const result = paramsSchema.safeParse({
-      limit: 10,
-      offset: 0,
-      count: 100,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with string parameters', () => {
-    const result = paramsSchema.safeParse({
-      name: 'Alice',
-      query: 'search term',
-      cursor: 'abc123',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with array parameters', () => {
-    const result = paramsSchema.safeParse({
-      tags: ['tag1', 'tag2', 'tag3'],
-      ids: [1, 2, 3, 4],
-      flags: [true, false, true],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with mixed parameter types', () => {
-    const result = paramsSchema.safeParse({
-      name: 'Alice',
-      age: 30,
-      active: true,
-      tags: ['user', 'admin'],
-      limit: 50,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with empty string parameters', () => {
-    const result = paramsSchema.safeParse({
-      query: '',
-      cursor: '',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with negative integer parameters', () => {
-    const result = paramsSchema.safeParse({
-      offset: -10,
-      delta: -5,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with empty array parameters', () => {
-    const result = paramsSchema.safeParse({
-      tags: [],
-      ids: [],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with arrays of mixed scalar types', () => {
-    const result = paramsSchema.safeParse({
-      values: [true, 42, 'text'],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates object with numeric string keys', () => {
-    const result = paramsSchema.safeParse({
-      '0': 'value0',
-      '1': 'value1',
-      '2': 'value2',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects non-object values', () => {
-    const result = paramsSchema.safeParse('not an object')
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects null values', () => {
-    const result = paramsSchema.safeParse(null)
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects undefined values', () => {
-    const result = paramsSchema.safeParse(undefined)
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects arrays', () => {
-    const result = paramsSchema.safeParse([1, 2, 3])
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with null parameter values', () => {
-    const result = paramsSchema.safeParse({
-      name: 'Alice',
-      invalid: null,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with floating point parameter values', () => {
-    const result = paramsSchema.safeParse({
-      value: 3.14,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with NaN parameter values', () => {
-    const result = paramsSchema.safeParse({
-      value: NaN,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with Infinity parameter values', () => {
-    const result = paramsSchema.safeParse({
-      value: Infinity,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with object parameter values', () => {
-    const result = paramsSchema.safeParse({
-      nested: { key: 'value' },
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with nested array parameter values', () => {
-    const result = paramsSchema.safeParse({
-      nested: [
-        [1, 2],
-        [3, 4],
-      ],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with arrays containing invalid values', () => {
-    const result = paramsSchema.safeParse({
-      tags: ['valid', null, 'also valid'],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with arrays containing objects', () => {
-    const result = paramsSchema.safeParse({
-      items: [1, { key: 'value' }, 3],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects object with arrays containing floating point numbers', () => {
-    const result = paramsSchema.safeParse({
-      values: [1, 2.5, 3],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects when one parameter is invalid', () => {
-    const result = paramsSchema.safeParse({
-      valid1: 'string',
-      valid2: 42,
-      invalid: null,
-      valid3: true,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  describe('edge cases', () => {
-    it('validates single parameter', () => {
-      const result = paramsSchema.safeParse({
-        single: 'value',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates many parameters', () => {
-      const manyParams: Record<string, string> = {}
-      for (let i = 0; i < 100; i++) {
-        manyParams[`param${i}`] = `value${i}`
-      }
-      const result = paramsSchema.safeParse(manyParams)
-      expect(result.success).toBe(true)
-    })
-
-    it('validates parameters with long string values', () => {
-      const result = paramsSchema.safeParse({
-        longString: 'a'.repeat(1000),
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates parameters with large integer values', () => {
-      const result = paramsSchema.safeParse({
-        largeInt: 2147483647,
-        negativeInt: -2147483648,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates parameters with long arrays', () => {
-      const result = paramsSchema.safeParse({
-        longArray: Array.from({ length: 100 }, (_, i) => i),
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('validates parameters with special characters in keys', () => {
-      const result = paramsSchema.safeParse({
-        'key-with-dashes': 'value',
-        key_with_underscores: 'value',
-        'key.with.dots': 'value',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('preserves original object when no transformations occur', () => {
-      const input = {
-        name: 'Alice',
-        age: 30,
-        tags: ['user'],
-      }
-      const result = paramsSchema.safeParse(input)
-
-      if (result.success) {
-        expect(result.value).toBe(input)
-      } else {
-        throw new Error('Expected validation to succeed')
-      }
-    })
-  })
-})