polen 0.10.0-next.14 → 0.10.0-next.3

package/src/lib/kit-temp.test-d.ts

@@ -1,115 +0,0 @@
-import { Ts } from '@wollybeard/kit'
-import { objFilter, ObjOmit, ObjPick, objPolicyFilter } from './kit-temp.js'
-import type { ObjPolicyFilter } from './kit-temp.js'
-
-// Test object for all tests
-type TestObj = { a: string; b: number; c: boolean; d: string[] }
-declare const testObj: TestObj
-
-// Test 1: objPolicyFilter with allow mode
-{
-  const result = objPolicyFilter('allow', testObj, ['a', 'c'] as const)
-  Ts.assertEqual<{ a: string; c: boolean }>()(result)
-}
-
-// Test 2: objPolicyFilter with deny mode
-{
-  const result = objPolicyFilter('deny', testObj, ['a', 'c'] as const)
-  Ts.assertEqual<{ b: number; d: string[] }>()(result)
-}
-
-// Test 3: objFilter returns Partial<T>
-{
-  const result = objFilter(testObj, (key, value) => value !== 'hello')
-  Ts.assertEqual<Partial<TestObj>>()(result)
-
-  // All properties are optional
-  Ts.assertSub<typeof result.a>()(undefined)
-  Ts.assertSub<typeof result.b>()(undefined)
-  Ts.assertSub<typeof result.c>()(undefined)
-  Ts.assertSub<typeof result.d>()(undefined)
-}
-
-// Test 4: ObjPick type inference
-{
-  const result = ObjPick(testObj, ['a', 'c'] as const)
-  Ts.assertEqual<{ a: string; c: boolean }>()(result)
-}
-
-// Test 5: ObjOmit type inference
-{
-  const result = ObjOmit(testObj, ['a', 'c'] as const)
-  Ts.assertEqual<{ b: number; d: string[] }>()(result)
-}
-
-// Test 6: ObjPolicyFilter type-level function
-{
-  type Allow = ObjPolicyFilter<TestObj, 'a' | 'c', 'allow'>
-  type _TestAllow = Ts.AssertEqual<Allow, { a: string; c: boolean }>
-
-  type Deny = ObjPolicyFilter<TestObj, 'a' | 'c', 'deny'>
-  type _TestDeny = Ts.AssertEqual<Deny, { b: number; d: string[] }>
-
-  type AllowEmpty = ObjPolicyFilter<TestObj, never, 'allow'>
-  type _TestAllowEmpty = Ts.AssertEqual<AllowEmpty, {}>
-
-  type DenyEmpty = ObjPolicyFilter<TestObj, never, 'deny'>
-  type _TestDenyEmpty = Ts.AssertEqual<DenyEmpty, TestObj>
-}
-
-// Test 7: Edge cases
-{
-  // Empty object
-  const empty = {}
-  const allowEmpty = objPolicyFilter('allow', empty, [])
-  const denyEmpty = objPolicyFilter('deny', empty, [])
-  const filterEmpty = objFilter(empty, () => true)
-
-  Ts.assertEqual<{}>()(allowEmpty)
-  Ts.assertEqual<{}>()(denyEmpty)
-  Ts.assertEqual<{}>()(filterEmpty)
-
-  // Single property object
-  const single = { a: 1 }
-  const allowSingle = objPolicyFilter('allow', single, ['a'] as const)
-  const denySingle = objPolicyFilter('deny', single, ['a'] as const)
-  const filterSingle = objFilter(single, () => true)
-
-  Ts.assertEqual<{ a: number }>()(allowSingle)
-  Ts.assertEqual<{}>()(denySingle)
-  Ts.assertEqual<{ a?: number }>()(filterSingle)
-}
-
-// Test 8: Complex nested object
-{
-  type ComplexObj = {
-    nested: { a: string; b: number }
-    array: string[]
-    optional?: boolean
-    readonly ro: string
-  }
-  const complexObj = {} as ComplexObj
-
-  const picked = objPolicyFilter('allow', complexObj, ['nested', 'optional'] as const)
-  Ts.assertEqual<{ nested: { a: string; b: number }; optional?: boolean }>()(picked)
-
-  const omitted = objPolicyFilter('deny', complexObj, ['nested', 'optional'] as const)
-  Ts.assertEqual<{ array: string[]; readonly ro: string }>()(omitted)
-
-  const filtered = objFilter(complexObj, (key) => key !== 'array')
-  Ts.assertEqual<Partial<ComplexObj>>()(filtered)
-}
-
-// Test 9: Keys parameter type inference
-{
-  // With const assertion
-  const keys1 = ['a', 'c'] as const
-  const result1 = objPolicyFilter('allow', testObj, keys1)
-  Ts.assertEqual<{ a: string; c: boolean }>()(result1)
-
-  // Without const assertion (wider type)
-  const keys2: (keyof TestObj)[] = ['a', 'c']
-  const result2 = objPolicyFilter('allow', testObj, keys2)
-  // Result is a union of all possible picks
-  type Result2 = typeof result2 // Pick<TestObj, keyof TestObj>
-}

package/src/lib/kit-temp.test.ts

@@ -1,139 +0,0 @@
-import * as fc from 'fast-check'
-import { describe, expect, test } from 'vitest'
-import { objFilter, ObjOmit, ObjPick, objPolicyFilter } from './kit-temp.js'
-
-describe('objPolicyFilter', () => {
-  const testObj = { a: 1, b: 2, c: 3, d: 4 }
-
-  test('allow mode picks specified keys', () => {
-    expect(objPolicyFilter('allow', testObj, ['a', 'c'])).toEqual({ a: 1, c: 3 })
-    expect(objPolicyFilter('allow', testObj, [])).toEqual({})
-    expect(objPolicyFilter('allow', testObj, ['a', 'z'] as any)).toEqual({ a: 1 })
-  })
-
-  test('deny mode omits specified keys', () => {
-    expect(objPolicyFilter('deny', testObj, ['a', 'c'])).toEqual({ b: 2, d: 4 })
-    expect(objPolicyFilter('deny', testObj, [])).toEqual(testObj)
-    expect(objPolicyFilter('deny', testObj, ['z'] as any)).toEqual(testObj)
-  })
-
-  test('preserves undefined values', () => {
-    const obj = { a: 1, b: undefined, c: 3 }
-    expect(objPolicyFilter('allow', obj, ['a', 'b'])).toEqual({ a: 1, b: undefined })
-  })
-})
-
-describe('objFilter', () => {
-  const testObj = { a: 1, b: 2, c: 3, d: 4 }
-
-  test('filters by predicates', () => {
-    // By value
-    expect(objFilter(testObj, (k, v) => v > 2)).toEqual({ c: 3, d: 4 })
-
-    // By key
-    expect(objFilter(testObj, k => k === 'a' || k === 'c')).toEqual({ a: 1, c: 3 })
-
-    // By full object context
-    expect(objFilter(testObj, (k, v, obj) => {
-      const avg = Object.values(obj).reduce((a, b) => a + b, 0) / Object.keys(obj).length
-      return v < avg
-    })).toEqual({ a: 1, b: 2 })
-  })
-
-  test('edge cases', () => {
-    expect(objFilter(testObj, () => false)).toEqual({})
-    expect(objFilter(testObj, () => true)).toEqual(testObj)
-    expect(objFilter({}, () => true)).toEqual({})
-  })
-})
-
-describe('ObjPick and ObjOmit', () => {
-  test('are aliases for objPolicyFilter', () => {
-    const obj = { a: 1, b: 2, c: 3 }
-    const keys = ['a', 'c'] as const
-
-    expect(ObjPick(obj, keys)).toEqual(objPolicyFilter('allow', obj, keys))
-    expect(ObjOmit(obj, keys)).toEqual(objPolicyFilter('deny', obj, keys))
-  })
-})
-
-describe('property-based tests', () => {
-  test('objPolicyFilter allow/deny are complementary', () => {
-    fc.assert(
-      fc.property(
-        fc.object(),
-        fc.array(fc.string()),
-        (obj, keys) => {
-          const allowed = objPolicyFilter('allow', obj, keys)
-          const denied = objPolicyFilter('deny', obj, keys)
-
-          // Every key in obj is either in allowed or denied, never both
-          Object.keys(obj).forEach(key => {
-            const inAllowed = Object.prototype.hasOwnProperty.call(allowed, key)
-            const inDenied = Object.prototype.hasOwnProperty.call(denied, key)
-            expect(inAllowed).toBe(!inDenied)
-          })
-
-          // Combined they reconstruct the original object (only own properties)
-          const reconstructed = { ...allowed, ...denied }
-          const ownPropsObj = Object.keys(obj).reduce((acc, key) => {
-            acc[key] = obj[key]
-            return acc
-          }, {} as any)
-          expect(reconstructed).toEqual(ownPropsObj)
-        },
-      ),
-    )
-  })
-
-  test('objFilter preserves values unchanged', () => {
-    fc.assert(
-      fc.property(
-        fc.object(),
-        (obj) => {
-          const filtered = objFilter(obj, () => true)
-
-          // Object.keys doesn't include __proto__, so we need to handle it specially
-          const objWithoutProto = Object.keys(obj).reduce((acc, key) => {
-            acc[key] = obj[key]
-            return acc
-          }, {} as any)
-
-          expect(filtered).toEqual(objWithoutProto)
-
-          // Values are the same reference
-          Object.keys(filtered).forEach(key => {
-            expect(filtered[key]).toBe(obj[key])
-          })
-        },
-      ),
-    )
-  })
-
-  test('objPolicyFilter is immutable', () => {
-    fc.assert(
-      fc.property(
-        fc.object(),
-        fc.array(fc.string()),
-        fc.oneof(fc.constant('allow' as const), fc.constant('deny' as const)),
-        (obj, keys, mode) => {
-          const original = { ...obj }
-          objPolicyFilter(mode, obj, keys)
-          expect(obj).toEqual(original)
-        },
-      ),
-    )
-  })
-
-  test('empty keys behavior', () => {
-    fc.assert(
-      fc.property(
-        fc.object(),
-        (obj) => {
-          expect(objPolicyFilter('allow', obj, [])).toEqual({})
-          expect(objPolicyFilter('deny', obj, [])).toEqual(obj)
-        },
-      ),
-    )
-  })
-})

package/src/lib/mask/$$.ts

@@ -1,2 +0,0 @@
-export * from './apply.ts'
-export * from './mask.ts'

package/src/lib/mask/$.test.ts

@@ -1,248 +0,0 @@
-import * as fc from 'fast-check'
-import { describe, expect, test } from 'vitest'
-import { Mask } from './$.ts'
-
-describe('Mask.create', () => {
-  test('boolean options create binary masks', () => {
-    const showMask = Mask.create(true)
-    const hideMask = Mask.create(false)
-
-    expect(showMask.type).toBe('binary')
-    expect(hideMask.type).toBe('binary')
-
-    if (showMask.type === 'binary' && hideMask.type === 'binary') {
-      expect(showMask.show).toBe(true)
-      expect(hideMask.show).toBe(false)
-    }
-  })
-
-  test('array options create allow mode properties mask', () => {
-    const mask = Mask.create(['name', 'age'])
-
-    expect(mask.type).toBe('properties')
-    if (mask.type === 'properties') {
-      expect(mask.mode).toBe('allow')
-      expect(mask.properties).toEqual(['name', 'age'])
-    }
-  })
-
-  test('object options create mode based on values', () => {
-    const allowMask = Mask.create({ name: true, age: true, password: false })
-    const denyMask = Mask.create({ password: false, secret: false })
-
-    expect(allowMask.type).toBe('properties')
-    expect(denyMask.type).toBe('properties')
-
-    if (allowMask.type === 'properties' && denyMask.type === 'properties') {
-      expect(allowMask.mode).toBe('allow')
-      expect(allowMask.properties).toEqual(['name', 'age'])
-
-      expect(denyMask.mode).toBe('deny')
-      expect(denyMask.properties).toEqual(['password', 'secret'])
-    }
-  })
-})
-
-describe('Mask.apply', () => {
-  test('binary masks show/hide data', () => {
-    const data = { a: 1 }
-
-    expect(Mask.apply(data, Mask.create(true))).toBe(data)
-    expect(Mask.apply(data, Mask.create(false))).toBe(undefined)
-  })
-
-  test('properties masks filter objects', () => {
-    const data = { name: 'John', age: 30, password: 'secret' }
-
-    // Allow mode
-    const allowMask = Mask.create(['name', 'age'])
-    expect(Mask.apply(data, allowMask)).toEqual({ name: 'John', age: 30 })
-
-    // Deny mode
-    const denyMask = Mask.create({ password: false })
-    expect(Mask.apply(data, denyMask)).toEqual({ name: 'John', age: 30 })
-  })
-
-  test('properties masks throw for non-objects', () => {
-    const mask = Mask.create(['name'])
-
-    expect(() => Mask.apply('string' as any, mask)).toThrow()
-    expect(() => Mask.apply(123 as any, mask)).toThrow()
-    expect(() => Mask.apply(null as any, mask)).toThrow()
-  })
-})
-
-describe('apply variants', () => {
-  test('applyPartial allows missing properties', () => {
-    const mask = Mask.create<{ name: string; age: number }>(['name', 'age'])
-    const partial = { name: 'John' }
-
-    expect(Mask.applyPartial(partial, mask)).toEqual({ name: 'John' })
-    expect(Mask.applyPartial({}, mask)).toEqual({})
-  })
-
-  test('applyExact works with any data for binary masks', () => {
-    const showMask = Mask.create(true)
-    const hideMask = Mask.create(false)
-
-    expect(Mask.applyExact('hello' as any, showMask)).toBe('hello')
-    expect(Mask.applyExact('hello' as any, hideMask)).toBe(undefined)
-  })
-})
-
-describe('property-based tests', () => {
-  test('binary masks - invariants', () => {
-    fc.assert(
-      fc.property(fc.anything(), (data) => {
-        expect(Mask.apply(data, Mask.create(true))).toBe(data)
-        expect(Mask.apply(data, Mask.create(false))).toBe(undefined)
-      }),
-    )
-  })
-
-  test('properties mask - allow mode filters correctly', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
-        fc.array(fc.string(), { minLength: 1 }),
-        (obj, keys) => {
-          const mask = Mask.create(keys)
-          const result = Mask.apply(obj as any, mask)
-          const resultKeys = Object.keys(result as any)
-
-          // Result contains only keys that were in both mask and object
-          expect(resultKeys.every(key => keys.includes(key))).toBe(true)
-
-          // All requested keys that exist in obj are in result
-          keys.forEach(key => {
-            if (key in obj) {
-              expect(result).toHaveProperty(key, (obj as any)[key])
-            }
-          })
-        },
-      ),
-    )
-  })
-
-  test('properties mask - deny mode filters correctly', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
-        fc.uniqueArray(fc.string(), { minLength: 1 }),
-        (data, keysToRemove) => {
-          const maskSpec = Object.fromEntries(keysToRemove.map(k => [k, false]))
-          const mask = Mask.create(maskSpec)
-
-          expect(mask.type).toBe('properties')
-          if (mask.type !== 'properties') return
-          expect(mask.mode).toBe('deny')
-
-          const result = Mask.apply(data as any, mask)
-
-          // Result should not have any of the denied keys
-          keysToRemove.forEach(key => {
-            expect(Object.prototype.hasOwnProperty.call(result, key)).toBe(false)
-          })
-
-          // Result should have all other keys from data
-          Object.keys(data).forEach(key => {
-            if (!keysToRemove.includes(key)) {
-              expect(Object.prototype.hasOwnProperty.call(result, key)).toBe(true)
-              expect((result as any)[key]).toBe((data as any)[key])
-            }
-          })
-        },
-      ),
-    )
-  })
-
-  test('undefined values are preserved', () => {
-    fc.assert(
-      fc.property(
-        fc.record({
-          a: fc.oneof(fc.anything(), fc.constant(undefined)),
-          b: fc.oneof(fc.anything(), fc.constant(undefined)),
-          c: fc.oneof(fc.anything(), fc.constant(undefined)),
-        }),
-        fc.shuffledSubarray(['a', 'b', 'c'], { minLength: 1 }),
-        (obj, keys) => {
-          const result = Mask.apply(obj as any, Mask.create(keys))
-
-          keys.forEach(key => {
-            if (key in obj) {
-              expect(result).toHaveProperty(key)
-              expect((result as any)[key]).toBe((obj as any)[key])
-            }
-          })
-        },
-      ),
-    )
-  })
-
-  test('apply and applyPartial are consistent for complete data', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(fc.string(), fc.anything()),
-        fc.array(fc.string(), { minLength: 1 }),
-        (data, keys) => {
-          const mask = Mask.create(keys)
-          expect(Mask.apply(data as any, mask)).toEqual(Mask.applyPartial(data as any, mask))
-        },
-      ),
-    )
-  })
-
-  test('non-objects throw with properties masks', () => {
-    fc.assert(
-      fc.property(
-        fc.oneof(
-          fc.string(),
-          fc.integer(),
-          fc.boolean(),
-          fc.constant(null),
-          fc.constant(undefined),
-        ),
-        fc.array(fc.string(), { minLength: 1 }),
-        (nonObject, keys) => {
-          const mask = Mask.create(keys)
-          expect(() => Mask.apply(nonObject as any, mask)).toThrow('Cannot apply properties mask to non-object data')
-        },
-      ),
-    )
-  })
-
-  test('immutability invariants', () => {
-    fc.assert(
-      fc.property(
-        fc.dictionary(
-          fc.string(),
-          fc.oneof(
-            fc.string(),
-            fc.integer(),
-            fc.boolean(),
-            fc.constant(null),
-          ),
-        ),
-        fc.oneof(
-          fc.boolean(),
-          fc.array(fc.string()),
-          fc.dictionary(fc.string(), fc.boolean()),
-        ),
-        (data, maskOptions) => {
-          const mask = Mask.create(maskOptions as any)
-          const originalData = { ...data }
-          const originalMask = JSON.parse(JSON.stringify(mask))
-
-          try {
-            Mask.apply(data as any, mask)
-          } catch {
-            // Ignore errors for invalid combinations
-          }
-
-          expect(data).toEqual(originalData)
-          expect(mask).toEqual(originalMask)
-        },
-      ),
-    )
-  })
-})

package/src/lib/mask/$.ts

@@ -1 +0,0 @@
-export * as Mask from './$$.ts'

package/src/lib/mask/apply.ts

@@ -1,134 +0,0 @@
-import { type ExtendsExact, objPolicyFilter } from '#lib/kit-temp'
-import { Obj } from '@wollybeard/kit'
-import { never } from '@wollybeard/kit/language'
-import type { GetDataType, Mask } from './mask.ts'
-
-/**
- * Type-level function that applies a mask to data.
- *
- * @template Data - The data type
- * @template M - The mask type
- *
- * Binary masks:
- * - show=true returns the data unchanged
- * - show=false returns undefined
- *
- * Properties masks:
- * - 'allow' mode returns Pick<Data, keys>
- * - 'deny' mode returns Omit<Data, keys>
- * - Non-objects throw an error at runtime
- */
-// dprint-ignore
-export type Apply<Data, M extends Mask<any>> =
-    M extends { type: 'binary', show: boolean }
-      ? M['show'] extends true
-        ? Data
-        : undefined
-      : M extends { type: 'properties', mode: string, properties: any[] }
-        ? Data extends object
-          ? M['mode'] extends 'allow'
-            ? Pick<Data, Extract<M['properties'][number], keyof Data>>
-            : Omit<Data, Extract<M['properties'][number], keyof Data>>
-          : never  // Non-objects not allowed with property masks
-        : never
-
-/**
- * Apply mask to data with standard covariance.
- *
- * Data must be assignable to the mask's expected type (may have excess properties).
- *
- * @param data - The data to mask
- * @param mask - The mask to apply
- * @returns The masked data
- *
- * @example
- * ```ts
- * const user = { name: 'John', email: 'john@example.com', password: 'secret' }
- * const mask = Mask.pick<User>(['name', 'email'])
- * const safeUser = apply(user, mask) // { name: 'John', email: 'john@example.com' }
- * ```
- */
-export const apply = <
-  data extends GetDataType<mask>,
-  mask extends Mask<any>,
->(data: data, mask: mask): Apply<data, mask> => {
-  return applyInternal(data, mask) as Apply<data, mask>
-}
-
-/**
- * Apply mask to partial data.
- *
- * Data may have only a subset of the mask's expected properties.
- * Useful when working with incomplete data or optional fields.
- *
- * @param data - The partial data to mask
- * @param mask - The mask to apply
- * @returns The masked data
- *
- * @example
- * ```ts
- * const partialUser = { name: 'John' } // missing email
- * const mask = Mask.pick<User>(['name', 'email'])
- * const result = applyPartial(partialUser, mask) // { name: 'John' }
- * ```
- */
-export const applyPartial = <
-  data extends Partial<GetDataType<mask>>,
-  mask extends Mask<any>,
->(data: data, mask: mask): Apply<data, mask> => {
-  return applyInternal(data, mask) as Apply<data, mask>
-}
-
-/**
- * Apply mask to data with exact type matching.
- *
- * Data must exactly match the mask's expected type - no missing or excess properties.
- * Provides the strictest type checking.
- *
- * @param data - The data to mask (must exactly match expected type)
- * @param mask - The mask to apply
- * @returns The masked data
- *
- * @example
- * ```ts
- * type User = { name: string; email: string }
- * const mask = Mask.pick<User>(['name'])
- *
- * // This works - exact match
- * const user: User = { name: 'John', email: 'john@example.com' }
- * const result = applyExact(user, mask)
- *
- * // This fails - has extra property
- * const userWithExtra = { name: 'John', email: 'john@example.com', age: 30 }
- * const result2 = applyExact(userWithExtra, mask) // Type error!
- * ```
- */
-export const applyExact = <
-  data,
-  mask extends Mask<any>,
->(
-  data: ExtendsExact<data, GetDataType<mask>>,
-  mask: mask,
-): Apply<data, mask> => {
-  return applyInternal(data, mask) as Apply<data, mask>
-}
-
-// Internal implementation
-const applyInternal = (data: any, mask: Mask<any>): any => {
-  // ━ Handle binary mask
-  if (mask.type === 'binary') {
-    return mask.show ? data : undefined
-  }
-
-  // ━ Handle properties mask
-  if (mask.type === 'properties') {
-    // Properties mask requires object data
-    if (!Obj.is(data)) {
-      throw new Error('Cannot apply properties mask to non-object data')
-    }
-
-    return objPolicyFilter(mask.mode, data, mask.properties)
-  }
-
-  never()
-}