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

package/src/lib/graph/graph.ts

@@ -1,197 +0,0 @@
-import { S } from '#lib/kit-temp/effect'
-
-// ─── Schema ──────────────────────────────────────────────────────────────────
-
-/**
- * Dependency graph for tracking relationships between nodes
- * Used to efficiently handle dependencies in various contexts
- */
-export const DependencyGraph = S.Struct({
-  /**
-   * Map from parent ID to array of child IDs (parent depends on children)
-   */
-  dependencies: S.Record({ key: S.String, value: S.Array(S.String) }),
-
-  /**
-   * Map from child ID to array of parent IDs (child is depended on by parents)
-   */
-  dependents: S.Record({ key: S.String, value: S.Array(S.String) }),
-}).annotations({
-  identifier: 'DependencyGraph',
-  description: 'A directed graph tracking dependencies between nodes',
-})
-
-export type DependencyGraph = typeof DependencyGraph.Type
-
-// ─── Constructors ────────────────────────────────────────────────────────────
-
-export const make = DependencyGraph.make
-
-/**
- * Create an empty dependency graph
- */
-export const create = (): DependencyGraph =>
-  make({
-    dependencies: {},
-    dependents: {},
-  })
-
-// ─── Domain Logic ────────────────────────────────────────────────────────────
-
-/**
- * Add a dependency relationship (immutable)
- * @param graph - The dependency graph
- * @param parent - The parent node ID
- * @param child - The child node ID that the parent depends on
- * @returns A new graph with the dependency added
- */
-export const addDependency = (
-  graph: DependencyGraph,
-  parent: string,
-  child: string,
-): DependencyGraph => {
-  // Get existing arrays or create empty ones
-  const children = graph.dependencies[parent] || []
-  const parents = graph.dependents[child] || []
-
-  // Add child if not already present
-  const newChildren = children.includes(child) ? children : [...children, child]
-
-  // Add parent if not already present
-  const newParents = parents.includes(parent) ? parents : [...parents, parent]
-
-  return make({
-    dependencies: {
-      ...graph.dependencies,
-      [parent]: newChildren,
-    },
-    dependents: {
-      ...graph.dependents,
-      [child]: newParents,
-    },
-  })
-}
-
-/**
- * Add a dependency relationship (mutable)
- * @param graph - The dependency graph to mutate
- * @param parent - The parent node ID
- * @param child - The child node ID that the parent depends on
- */
-export const addDependencyMutable = (
-  graph: DependencyGraph,
-  parent: string,
-  child: string,
-): void => {
-  // Cast to mutable for mutation
-  const mutableGraph = graph as {
-    dependencies: Record<string, string[]>
-    dependents: Record<string, string[]>
-  }
-
-  // Add to dependencies
-  if (!mutableGraph.dependencies[parent]) {
-    mutableGraph.dependencies[parent] = []
-  }
-  if (!mutableGraph.dependencies[parent].includes(child)) {
-    mutableGraph.dependencies[parent].push(child)
-  }
-
-  // Add to dependents
-  if (!mutableGraph.dependents[child]) {
-    mutableGraph.dependents[child] = []
-  }
-  if (!mutableGraph.dependents[child].includes(parent)) {
-    mutableGraph.dependents[child].push(parent)
-  }
-}
-
-/**
- * Find all nodes that have no dependencies (leaf nodes)
- */
-export const findLeafNodes = (graph: DependencyGraph): Set<string> => {
-  const leaves = new Set<string>()
-
-  // Check all nodes that appear as children
-  for (const child of Object.keys(graph.dependents)) {
-    const deps = graph.dependencies[child]
-    if (!deps || deps.length === 0) {
-      leaves.add(child)
-    }
-  }
-
-  return leaves
-}
-
-/**
- * Check if all dependencies of a node have been processed
- */
-export const areDependenciesReady = (
-  node: string,
-  graph: DependencyGraph,
-  processed: Set<string>,
-): boolean => {
-  const deps = graph.dependencies[node]
-  if (!deps) return true
-
-  return deps.every(dep => processed.has(dep))
-}
-
-/**
- * Get topological ordering of nodes (children before parents)
- * This ensures we process dependencies before the nodes that depend on them
- *
- * @param graph - The dependency graph
- * @returns Array of node IDs in topological order
- */
-export const topologicalSort = (graph: DependencyGraph): string[] => {
-  const result: string[] = []
-  const visited = new Set<string>()
-  const visiting = new Set<string>() // For cycle detection
-
-  // Get all nodes
-  const allNodes = new Set<string>()
-  for (const parent of Object.keys(graph.dependencies)) {
-    allNodes.add(parent)
-  }
-  for (const child of Object.keys(graph.dependents)) {
-    allNodes.add(child)
-  }
-
-  const visit = (node: string): void => {
-    if (visited.has(node)) return
-
-    if (visiting.has(node)) {
-      // Cycle detected - just skip this node
-      return
-    }
-
-    visiting.add(node)
-
-    // Visit all children first
-    const children = graph.dependencies[node]
-    if (children) {
-      for (const child of children) {
-        visit(child)
-      }
-    }
-
-    visiting.delete(node)
-    visited.add(node)
-    result.push(node)
-  }
-
-  // Visit all nodes
-  for (const node of allNodes) {
-    visit(node)
-  }
-
-  return result
-}
-
-// ─── Codec ───────────────────────────────────────────────────────────────────
-
-export const decode = S.decode(DependencyGraph)
-export const decodeSync = S.decodeSync(DependencyGraph)
-export const encode = S.encode(DependencyGraph)
-export const encodeSync = S.encodeSync(DependencyGraph)

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

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

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

@@ -1,226 +0,0 @@
-import * as fc from 'fast-check'
-import { describe, expect, test } from 'vitest'
-import { Test } from '../../../tests/unit/helpers/test.js'
-import { Mask } from './$.js'
-
-// dprint-ignore
-Test.suite<{ options: any; expectedType: 'binary' | 'properties'; expectedMode?: 'allow' | 'deny'; expectedShow?: boolean; expectedProperties?: string[] }>('Mask.create', [
-  { name: 'boolean true creates binary show mask',       options: true,                                        expectedType: 'binary',     expectedShow: true },
-  { name: 'boolean false creates binary hide mask',      options: false,                                       expectedType: 'binary',     expectedShow: false },
-  { name: 'array creates allow mode properties mask',    options: ['name', 'age'],                             expectedType: 'properties', expectedMode: 'allow', expectedProperties: ['name', 'age'] },
-  { name: 'object with true values creates allow mode',  options: { name: true, age: true, password: false },  expectedType: 'properties', expectedMode: 'allow', expectedProperties: ['name', 'age'] },
-  { name: 'object with false values creates deny mode',  options: { password: false, secret: false },          expectedType: 'properties', expectedMode: 'deny',  expectedProperties: ['password', 'secret'] },
-], ({ options, expectedType, expectedMode, expectedShow, expectedProperties }) => {
-  const mask = Mask.create(options)
-  expect(mask.type).toBe(expectedType)
-  
-  if (expectedType === 'binary' && mask.type === 'binary') {
-    expect(mask.show).toBe(expectedShow)
-  }
-  
-  if (expectedType === 'properties' && mask.type === 'properties') {
-    expect(mask.mode).toBe(expectedMode)
-    expect(mask.properties).toEqual(expectedProperties)
-  }
-})
-
-// dprint-ignore
-Test.suite<{ data: any; maskOptions: any; shouldThrow?: boolean; expected?: any }>('Mask.apply', [
-  { name: 'binary show mask returns data',               data: { a: 1 },                                 maskOptions: true,              expected: { a: 1 } },
-  { name: 'binary hide mask returns undefined',          data: { a: 1 },                                 maskOptions: false,             expected: undefined },
-  { name: 'allow mode filters properties',               data: { name: 'John', age: 30, password: 'secret' }, maskOptions: ['name', 'age'],    expected: { name: 'John', age: 30 } },
-  { name: 'deny mode removes properties',                data: { name: 'John', age: 30, password: 'secret' }, maskOptions: { password: false }, expected: { name: 'John', age: 30 } },
-  { name: 'properties mask throws for string',           data: 'string',                                 maskOptions: ['name'],          shouldThrow: true },
-  { name: 'properties mask throws for number',           data: 123,                                      maskOptions: ['name'],          shouldThrow: true },
-  { name: 'properties mask throws for null',             data: null,                                     maskOptions: ['name'],          shouldThrow: true },
-], ({ data, maskOptions, shouldThrow, expected }) => {
-  const mask = Mask.create(maskOptions)
-  
-  if (shouldThrow) {
-    expect(() => Mask.apply(data as any, mask)).toThrow()
-  } else {
-    const result = Mask.apply(data, mask)
-    if (expected === undefined) {
-      expect(result).toBe(undefined)
-    } else {
-      expect(result).toEqual(expected)
-    }
-  }
-})
-
-// dprint-ignore
-Test.suite<{ method: 'applyPartial' | 'applyExact'; data: any; maskOptions: any; expected: any }>('apply variants', [
-  { name: 'applyPartial allows missing properties',      method: 'applyPartial', data: { name: 'John' },  maskOptions: ['name', 'age'], expected: { name: 'John' } },
-  { name: 'applyPartial with empty object',              method: 'applyPartial', data: {},                maskOptions: ['name', 'age'], expected: {} },
-  { name: 'applyExact with binary show mask',            method: 'applyExact',   data: 'hello',           maskOptions: true,             expected: 'hello' },
-  { name: 'applyExact with binary hide mask',            method: 'applyExact',   data: 'hello',           maskOptions: false,            expected: undefined },
-], ({ method, data, maskOptions, expected }) => {
-  const mask = Mask.create(maskOptions)
-  
-  const result = method === 'applyPartial' 
-    ? Mask.applyPartial(data, mask)
-    : Mask.applyExact(data as any, mask)
-    
-  if (expected === undefined) {
-    expect(result).toBe(undefined)
-  } else {
-    expect(result).toEqual(expected)
-  }
-})
-
-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 are own properties of obj are in result
-          keys.forEach(key => {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-              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 (Object.prototype.hasOwnProperty.call(obj, key)) {
-              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 './$$.js'

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()
-}