polen 0.11.0-next.17 → 0.11.0-next.19

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.js'
-
-/**
- * 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> =
-    $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,
->(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,
->(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,
->(
-  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 => {
-  // ━ 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()
-}

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'

package/src/sandbox.ts

@@ -1,15 +0,0 @@
-//
-//
-//
-//
-//
-// Temporary Work File
-//
-// ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
-//
-// – Use freely
-// – Try to remember to not commit changes
-// – Included by development TypeScript configuration
-// – Excluded by build TypeScript configuration
-//
-//

package/src/template/components/Changelog/ChangelogVersionPicker.tsx

@@ -1,36 +0,0 @@
-import { Select } from '@radix-ui/themes'
-import React from 'react'
-import { useNavigate } from 'react-router'
-
-interface Props {
-  versions: string[]
-  currentVersion: string
-}
-
-export const ChangelogVersionPicker: React.FC<Props> = ({ versions, currentVersion }) => {
-  const navigate = useNavigate()
-
-  // Don't show selector if only one version
-  if (versions.length <= 1) {
-    return null
-  }
-
-  const handleVersionChange = (newVersion: string) => {
-    navigate(`/changelog/version/${newVersion}`)
-  }
-
-  return (
-    <Select.Root value={currentVersion} onValueChange={handleVersionChange}>
-      <Select.Trigger>
-        Version {currentVersion}
-      </Select.Trigger>
-      <Select.Content>
-        {versions.map(version => (
-          <Select.Item key={version} value={version}>
-            Version {version}
-          </Select.Item>
-        ))}
-      </Select.Content>
-    </Select.Root>
-  )
-}

package/src/template/components/SimpleVersionPicker.tsx

@@ -1,48 +0,0 @@
-import { Version } from '#lib/version/$'
-import { Select } from '@radix-ui/themes'
-import type * as React from 'react'
-
-interface Props {
-  versions: readonly Version.Version[]
-  currentVersion: Version.Version
-  onVersionChange: (version: Version.Version) => void
-  label?: string
-}
-
-/**
- * A generic version picker component that can be used for any versioned content.
- * This is a controlled component - parent manages the state.
- */
-export const SimpleVersionPicker: React.FC<Props> = ({
-  versions,
-  currentVersion,
-  onVersionChange,
-  label = '',
-}) => {
-  // Don't show selector if only one version
-  if (versions.length <= 1) {
-    return null
-  }
-
-  return (
-    <Select.Root
-      value={Version.encodeSync(currentVersion)}
-      onValueChange={(versionEncoded) => onVersionChange(Version.fromString(versionEncoded))}
-    >
-      <Select.Trigger style={{ minWidth: '120px' }}>
-        {label}
-        {label ? ' ' : ''}
-        {Version.encodeSync(currentVersion)}
-      </Select.Trigger>
-      <Select.Content position='popper' sideOffset={5}>
-        {versions.map(version => (
-          <Select.Item key={Version.encodeSync(version)} value={Version.encodeSync(version)}>
-            {label}
-            {label ? ' ' : ''}
-            {Version.encodeSync(version)}
-          </Select.Item>
-        ))}
-      </Select.Content>
-    </Select.Root>
-  )
-}