@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/with-default.ts

@@ -1,81 +0,0 @@
-import {
-  InferInput,
-  InferOutput,
-  Schema,
-  ValidationContext,
-  Validator,
-} from '../core.js'
-
-/**
- * Schema wrapper that provides a default value when the input is undefined.
- *
- * In parse mode, when the input is `undefined`, the default value is used
- * instead. In validate mode, undefined values pass through unchanged (the
- * default is not applied).
- *
- * @template TValidator - The wrapped validator type
- *
- * @example
- * ```ts
- * const schema = new WithDefaultSchema(l.integer(), 0)
- * schema.parse(undefined) // 0
- * schema.parse(42)        // 42
- * ```
- */
-export class WithDefaultSchema<
-  const TValidator extends Validator,
-> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {
-  readonly type = 'withDefault' as const
-
-  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)
-  }
-}
-
-/**
- * Creates a schema that applies a default value when the input is undefined.
- *
- * Commonly used with `optional()` to provide fallback values for missing
- * properties. The default value is validated against the schema.
- *
- * @param validator - The validator for the value
- * @param defaultValue - The default value to use when input is undefined
- * @returns A new {@link WithDefaultSchema} instance
- *
- * @example
- * ```ts
- * // Integer with default
- * const countSchema = l.withDefault(l.integer(), 0)
- * countSchema.parse(undefined) // 0
- * countSchema.parse(5)         // 5
- *
- * // Commonly combined with optional in objects
- * const settingsSchema = l.object({
- *   theme: l.optional(l.withDefault(l.string(), 'light')),
- *   pageSize: l.optional(l.withDefault(l.integer(), 25)),
- * })
- * settingsSchema.parse({}) // { theme: 'light', pageSize: 25 }
- *
- * // Boolean with default
- * const enabledSchema = l.withDefault(l.boolean(), false)
- * ```
- */
-export function withDefault<const TValidator extends Validator>(
-  validator: TValidator,
-  defaultValue: InferInput<TValidator>,
-) {
-  return new WithDefaultSchema<TValidator>(validator, defaultValue)
-}

package/src/schema.ts

@@ -1,43 +0,0 @@
-// Concrete Types
-export * from './schema/array.js'
-export * from './schema/blob.js'
-export * from './schema/boolean.js'
-export * from './schema/bytes.js'
-export * from './schema/cid.js'
-export * from './schema/dict.js'
-export * from './schema/enum.js'
-export * from './schema/integer.js'
-export * from './schema/lex-map.js'
-export * from './schema/lex-value.js'
-export * from './schema/literal.js'
-export * from './schema/never.js'
-export * from './schema/null.js'
-export * from './schema/object.js'
-export * from './schema/regexp.js'
-export * from './schema/string.js'
-export * from './schema/unknown.js'
-
-// Composite Types
-export * from './schema/custom.js'
-export * from './schema/discriminated-union.js'
-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'
-export * from './schema/payload.js'
-export * from './schema/permission-set.js'
-export * from './schema/permission.js'
-export * from './schema/procedure.js'
-export * from './schema/query.js'
-export * from './schema/record.js'
-export * from './schema/subscription.js'
-export * from './schema/token.js'
-export * from './schema/typed-object.js'
-export * from './schema/typed-ref.js'
-export * from './schema/typed-union.js'

package/src/util/array-agg.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { arrayAgg } from './array-agg.js'
-
-describe('arrayAgg', () => {
-  it('aggregates items based on comparison and aggregation functions', () => {
-    const input = [1, 1, 2, 2, 3, 3, 3]
-    const result = arrayAgg(
-      input,
-      (a, b) => a === b,
-      (items) => ({ value: items[0], count: items.length }),
-    )
-    expect(result).toEqual([
-      { value: 1, count: 2 },
-      { value: 2, count: 2 },
-      { value: 3, count: 3 },
-    ])
-  })
-
-  it('returns an empty array when input is empty', () => {
-    const input: number[] = []
-    const result = arrayAgg(
-      input,
-      (a, b) => a === b,
-      (items) => ({ value: items[0], count: items.length }),
-    )
-    expect(result).toEqual([])
-  })
-
-  it('handles non-consecutive grouping', () => {
-    const input = [1, 2, 1, 2, 3, 1]
-    const result = arrayAgg(
-      input,
-      (a, b) => a === b,
-      (items) => ({ value: items[0], count: items.length }),
-    )
-    expect(result).toEqual([
-      { value: 1, count: 3 },
-      { value: 2, count: 2 },
-      { value: 3, count: 1 },
-    ])
-  })
-})

package/src/util/array-agg.ts

@@ -1,44 +0,0 @@
-/**
- * Aggregates items in an array based on a comparison function and an aggregation function.
- *
- * @param arr - The input array to aggregate.
- * @param cmp - A comparison function that determines if two items belong to the same group.
- * @param agg - An aggregation function that combines items in a group into a single item.
- * @returns An array of aggregated items.
- * @example
- * ```ts
- * const input = [1, 1, 2, 2, 3, 3, 3]
- * const result = arrayAgg(
- *   input,
- *   (a, b) => a === b,
- *   (items) => { value: items[0], sum: items.reduce((sum, item) => sum + item, 0) },
- * )
- * // result is [{ value: 1, sum: 2 }, { value: 2, sum: 4 }, { value: 3, sum: 6 }]
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function arrayAgg<T, O>(
-  arr: readonly T[],
-  cmp: (a: T, b: T) => boolean,
-  agg: (items: [T, ...T[]]) => O,
-): O[] {
-  if (arr.length === 0) return []
-
-  const groups: [T, ...T[]][] = [[arr[0]]]
-  const skipped = Array<undefined | boolean>(arr.length)
-
-  outer: for (let i = 1; i < arr.length; i++) {
-    if (skipped[i]) continue
-    const item = arr[i]
-    for (let j = 0; j < groups.length; j++) {
-      if (cmp(item, groups[j][0])) {
-        groups[j].push(item)
-        skipped[i] = true
-        continue outer
-      }
-    }
-    groups.push([item])
-  }
-
-  return groups.map(agg)
-}

package/src/util/assertion-util.ts

@@ -1 +0,0 @@
-export type CheckFn<T> = <I extends string>(input: I) => input is I & T

package/src/util/if-any.ts

@@ -1,3 +0,0 @@
-export type IfAny<T, TrueValue, FalseValue> = 0 extends 1 & T
-  ? TrueValue
-  : FalseValue

package/src/util/lazy-property.ts

@@ -1,14 +0,0 @@
-/*@__NO_SIDE_EFFECTS__*/
-export function lazyProperty<
-  O extends object,
-  const K extends keyof O,
-  const V extends O[K],
->(obj: O, key: K, value: V): V {
-  Object.defineProperty(obj, key, {
-    value,
-    writable: false,
-    enumerable: false,
-    configurable: true,
-  })
-  return value
-}

package/src/util/memoize.ts

@@ -1,37 +0,0 @@
-/*@__NO_SIDE_EFFECTS__*/
-export function memoizedOptions<F extends (...args: any[]) => any>(fn: F): F {
-  let cache: null | { value: ReturnType<F> } = null
-
-  return function cached(...args: any[]): ReturnType<F> {
-    // Not using the cache if there are args
-    if (args.length > 0) {
-      return fn(...args)
-    }
-
-    if (cache != null) {
-      return cache.value
-    }
-
-    const value = fn(...args)
-    cache = { value }
-    return value
-  } as F
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-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(key, ...args) as ReturnType<F>
-    cache.set(key, result)
-    return result
-  } as F
-}

package/tsconfig.build.json

@@ -1,12 +0,0 @@
-{
-  "extends": ["../../../tsconfig/isomorphic.json"],
-  "include": ["./src"],
-  "exclude": ["**/*.test.ts"],
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "importHelpers": true,
-    "target": "ES2023",
-    "rootDir": "./src",
-    "outDir": "./dist",
-  },
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "include": [],
-  "references": [
-    { "path": "./tsconfig.build.json" },
-    { "path": "./tsconfig.tests.json" },
-  ],
-}

package/tsconfig.tests.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig/vitest.json",
-  "include": ["./tests", "./src/**/*.test.ts"],
-  "compilerOptions": {
-    "noImplicitAny": true,
-    "rootDir": "./",
-  },
-}