polen 0.11.0-next.16 → 0.11.0-next.18

package/src/lib/mask/mask.test-d.ts

@@ -1,156 +0,0 @@
-import { Ts } from '@wollybeard/kit'
-import { Mask } from './$.js'
-import type { InferOptions, Mask as MaskType, PropertiesMask } from './mask.js'
-
-// Test 1: InferOptions with unknown should accept all option types
-{
-  type Options = InferOptions<unknown>
-
-  // This is a type-level assertion - we need to use a different pattern
-  type _Test = Ts.AssertExact<Options, boolean | string[] | Record<string, boolean>>
-
-  // All of these should be valid options
-  const option1: Options = true
-  const option2: Options = false
-  const option3: Options = [`name`, `age`]
-  const option4: Options = []
-  const option5: Options = { name: true, age: false }
-  const option6: Options = {}
-}
-
-// Test 2: Mask.create with unknown data type should accept all option types
-{
-  // Boolean options
-  const mask1 = Mask.create(true)
-  const mask2 = Mask.create(false)
-  // Without explicit type parameter, returns union type
-  Ts.assertEqual<MaskType<unknown>>()(mask1)
-  Ts.assertEqual<MaskType<unknown>>()(mask2)
-
-  // Array options (no type parameter needed)
-  const mask3 = Mask.create([`name`, `age`])
-  const mask4 = Mask.create([])
-  const mask5 = Mask.create([`a`, `b`, `c`])
-  // Returns union type with inferred properties
-  Ts.assertEqual<MaskType<{ name: any; age: any }>>()(mask3)
-  Ts.assertEqual<MaskType<unknown>>()(mask4)
-  Ts.assertEqual<MaskType<{ a: any; b: any; c: any }>>()(mask5)
-
-  // Object options
-  const mask6 = Mask.create({ name: true, age: false })
-  const mask7 = Mask.create({})
-  const mask8 = Mask.create({ foo: true, bar: true, baz: false })
-  // Returns union type with inferred properties
-  Ts.assertEqual<MaskType<unknown>>()(mask6)
-  Ts.assertEqual<MaskType<unknown>>()(mask7)
-  Ts.assertEqual<MaskType<unknown>>()(mask8)
-}
-
-// Test 3: With specific data type, options are constrained
-{
-  interface User {
-    name: string
-    age: number
-    email: string
-  }
-
-  // Valid options
-  const mask1 = Mask.create<User>(true)
-  const mask2 = Mask.create<User>([`name`, `age`])
-  const mask3 = Mask.create<User>({ name: true, age: false, email: true })
-
-  // With explicit type parameter, still returns union type
-  Ts.assertEqual<MaskType<User>>()(mask1)
-  Ts.assertEqual<MaskType<User>>()(mask2)
-  Ts.assertEqual<MaskType<User>>()(mask3)
-
-  // Invalid cases would be compile errors
-  // const mask4 = Mask.create<User>(['invalid']) // Error: 'invalid' is not a key of User
-  // const mask5 = Mask.create<User>({ invalid: true }) // Error: 'invalid' is not a property of User
-}
-
-// Test 4: Non-object types only accept boolean
-{
-  const mask1 = Mask.create<string>(true)
-  const mask2 = Mask.create<string>(false)
-
-  Ts.assertEqual<MaskType<string>>()(mask1)
-  Ts.assertEqual<MaskType<string>>()(mask2)
-
-  // Invalid cases would be compile errors
-  // const mask3 = Mask.create<string>(['prop']) // Error: string is not an object
-  // const mask4 = Mask.create<string>({ prop: true }) // Error: string is not an object
-}
-
-// Test 5: Test inference in practical scenarios
-{
-  // Should infer PropertiesMask with object data type
-  const userMask = Mask.create([`name`, `email`, `password`])
-  Ts.assertEqual<MaskType<{ name: any; email: any; password: any }>>()(userMask)
-
-  // When mask is a union type, apply returns a union of possible results
-  const user1 = { name: `John`, email: `john@example.com`, password: `secret`, extra: `data` }
-  const maskedUser1 = Mask.apply(user1, userMask)
-  // Result is a union type that includes the properties mask result
-  type MaskedUser1 = typeof maskedUser1
-  // Can't use assertSub with union types
-
-  // For partial data, use applyPartial
-  const user2 = { name: `Jane`, email: `jane@example.com` }
-  const maskedUser2 = Mask.applyPartial(user2, userMask)
-  // Result is a union type
-  type MaskedUser2 = typeof maskedUser2
-}
-
-// Test 6: Pick and omit helpers
-{
-  const pick1 = Mask.pick([`name`, `email`])
-  const omit1 = Mask.omit([`password`, `secret`])
-
-  // Infers specific property types
-  Ts.assertEqual<PropertiesMask<{ name: any; email: any }>>()(pick1)
-  Ts.assertEqual<PropertiesMask<{ password: any; secret: any }>>()(omit1)
-
-  interface User {
-    name: string
-    email: string
-    password: string
-  }
-  const pick2 = Mask.pick<User>([`name`, `email`])
-  const omit2 = Mask.omit<User>([`password`])
-
-  Ts.assertEqual<PropertiesMask<User>>()(pick2)
-  Ts.assertEqual<PropertiesMask<User>>()(omit2)
-}
-
-// Test 7: Apply type transformations
-{
-  interface User {
-    name: string
-    email: string
-    password: string
-  }
-  const user: User = { name: `John`, email: `john@example.com`, password: `secret` }
-
-  // Binary mask
-  const showMask = Mask.create<User>(true)
-  const hideMask = Mask.create<User>(false)
-  const shown = Mask.apply(user, showMask)
-  const hidden = Mask.apply(user, hideMask)
-
-  // showMask and hideMask are MaskType<User> (union types), so results are unions
-  type ShownType = typeof shown // Omit<User, keyof User> | undefined
-  type HiddenType = typeof hidden // Omit<User, keyof User> | undefined
-
-  // Properties mask - allow mode
-  const allowMask = Mask.create<User>([`name`, `email`])
-  const allowed = Mask.apply(user, allowMask)
-  // Result is a union due to mask being a union type
-  type AllowedType = typeof allowed
-
-  // Properties mask - deny mode
-  const denyMask = Mask.create<User>({ password: false })
-  const denied = Mask.apply(user, denyMask)
-  // Result is a union due to mask being a union type
-  type DeniedType = typeof denied
-}

package/src/lib/mask/mask.ts

@@ -1,244 +0,0 @@
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Mask
-//
-//
-
-/**
- * A mask that can either hide/show data entirely (BinaryMask) or
- * selectively hide/show object properties (PropertiesMask).
- *
- * @template $Data - The data type being masked
- */
-export type Mask<$Data = any> = BinaryMask<$Data> | PropertiesMask<$Data extends object ? $Data : object>
-
-/**
- * Create a mask based on the provided options.
- *
- * @param options - Mask configuration:
- *   - `boolean`: Creates a binary mask (true = show, false = hide)
- *   - `string[]`: Creates a properties mask that allows only the specified keys
- *   - `object`: Creates a properties mask based on true/false values per key
- *
- * @returns A mask that can be applied to data
- *
- * @example
- * ```ts
- * // Binary mask
- * const showAll = create(true)
- * const hideAll = create(false)
- *
- * // Properties mask with array
- * const allowMask = create<User>(['name', 'email'])
- *
- * // Properties mask with object
- * const objectMask = create<User>({
- *   name: true,
- *   email: true,
- *   password: false
- * })
- * ```
- */
-export const create = <$Data = unknown>(
-  options: InferOptions<$Data>,
-): Mask<$Data> => {
-  if (typeof options === `boolean`) {
-    return createBinary(options) as any
-  }
-
-  // Array input -> PropertiesMask with 'allow' mode
-  if (Array.isArray(options)) {
-    return createProperties(`allow`, options as any) as any
-  }
-
-  // Object input -> PropertiesMask based on true/false values
-  const entries = Object.entries(options)
-
-  const allowedKeys = entries
-    .filter(([_, include]) => include === true)
-    .map(([key]) => key)
-
-  const deniedKeys = entries
-    .filter(([_, include]) => include === false)
-    .map(([key]) => key)
-
-  // If we have denied keys, use deny mode
-  if (deniedKeys.length > 0 && allowedKeys.length === 0) {
-    return createProperties(`deny`, deniedKeys) as any
-  }
-
-  // Default to allow mode with allowed keys
-  return createProperties(`allow`, allowedKeys) as any
-}
-
-/**
- * Valid options for creating a mask for the given data type.
- *
- * @template $Data - The data type to be masked
- */
-export type InferOptions<$Data> = unknown extends $Data ? boolean | string[] | Record<string, boolean>
-  : $Data extends object ? (
-      | boolean
-      | (keyof $Data)[]
-      | Partial<
-        {
-          [K in keyof $Data]: boolean
-        }
-      >
-    )
-  : boolean
-
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • PropertiesMask
-//
-//
-
-/**
- * A mask that selectively shows or hides object properties.
- *
- * @template $Data - The object type being masked
- */
-export interface PropertiesMask<$Data extends object = object> {
-  type: `properties`
-  /** Whether to allow only specified properties or deny them */
-  mode: `allow` | `deny`
-  /** The list of property keys to allow or deny */
-  properties: (keyof $Data)[]
-}
-
-/**
- * Create a properties mask.
- *
- * @param mode - 'allow' to show only specified properties, 'deny' to hide them
- * @param properties - Array of property keys to allow or deny
- * @returns A PropertiesMask
- */
-export const createProperties = <$Data extends object = object>(
-  mode: `allow` | `deny`,
-  properties: (keyof $Data)[],
-): PropertiesMask<$Data> => ({
-  type: `properties`,
-  mode,
-  properties,
-})
-
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • BinaryMask
-//
-//
-
-/**
- * A mask that either shows or hides data entirely.
- *
- * @template _$Data - The data type being masked (used for type inference)
- */
-export interface BinaryMask<_$Data = any> {
-  type: `binary`
-  /** Whether to show (true) or hide (false) the data */
-  show: boolean
-}
-
-/**
- * Create a binary mask.
- *
- * @param show - Whether to show (true) or hide (false) the data
- * @returns A BinaryMask
- */
-export const createBinary = <$Data = any>(show: boolean): BinaryMask<$Data> => ({
-  type: `binary`,
-  show,
-})
-
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Convenience Constructors with Semantic Names
-//
-//
-
-/**
- * Create a mask that shows all data.
- * @returns A BinaryMask with show=true
- */
-export const show = (): BinaryMask => ({
-  type: `binary`,
-  show: true,
-})
-
-/**
- * Create a mask that hides all data.
- * @returns A BinaryMask with show=false
- */
-export const hide = (): BinaryMask => ({
-  type: `binary`,
-  show: false,
-})
-
-/**
- * Create a mask that shows only the specified properties.
- *
- * @param properties - Array of property keys to show
- * @returns A PropertiesMask in 'allow' mode
- *
- * @example
- * ```ts
- * const userMask = pick<User>(['name', 'email'])
- * // Only 'name' and 'email' will be shown
- * ```
- */
-export const pick = <$Data extends object = object>(
-  properties: (keyof $Data)[],
-): PropertiesMask<$Data> => ({
-  type: `properties`,
-  mode: `allow`,
-  properties,
-})
-
-/**
- * Create a mask that hides the specified properties.
- *
- * @param properties - Array of property keys to hide
- * @returns A PropertiesMask in 'deny' mode
- *
- * @example
- * ```ts
- * const userMask = omit<User>(['password', 'ssn'])
- * // Everything except 'password' and 'ssn' will be shown
- * ```
- */
-export const omit = <$Data extends object = object>(
-  properties: (keyof $Data)[],
-): PropertiesMask<$Data> => ({
-  type: `properties`,
-  mode: `deny`,
-  properties,
-})
-
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Utilities
-//
-//
-
-/**
- * Extract the data type from a mask.
- *
- * @template $Mask - The mask type
- * @returns The data type the mask is designed for
- */
-// dprint-ignore
-export type GetDataType<$Mask extends Mask> =
-  $Mask extends BinaryMask<infer $Data>     ? $Data :
-  $Mask extends PropertiesMask<infer $Data> ? $Data
-                                            : never

package/src/lib/version-selection/$$.ts

@@ -1 +0,0 @@
-export * from './version-selection.js'