polen 0.11.0-next.2 → 0.11.0-next.21

package/src/lib/diagnostic/reporter.ts

@@ -0,0 +1,74 @@
+import { Group } from '@wollybeard/kit'
+import type { Diagnostic } from './diagnostic.js'
+import { Severity } from './severity.js'
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+const getIcon = (severity: Diagnostic['severity']): string => {
+  switch (severity) {
+    case Severity.enums.error:
+      return '✗'
+    case Severity.enums.warning:
+      return '⚠'
+    case Severity.enums.info:
+      return 'ⓘ'
+  }
+}
+
+const formatSummary = (diagnostics: Diagnostic[]): string => {
+  const errors = diagnostics.filter(d => d.severity === Severity.enums.error)
+  const warnings = diagnostics.filter(d => d.severity === Severity.enums.warning)
+  const infos = diagnostics.filter(d => d.severity === Severity.enums.info)
+
+  const parts = [
+    errors.length > 0 && `${errors.length} error${errors.length === 1 ? '' : 's'}`,
+    warnings.length > 0 && `${warnings.length} warning${warnings.length === 1 ? '' : 's'}`,
+    infos.length > 0 && `${infos.length} info${infos.length === 1 ? '' : 's'}`,
+  ].filter(Boolean)
+
+  return parts.join(', ')
+}
+
+// ============================================================================
+// Reporter
+// ============================================================================
+
+/**
+ * Reports diagnostics to the console, grouped by source.
+ *
+ * This is a generic reporter that works with any diagnostic
+ * that extends DiagnosticBase. It groups diagnostics by their
+ * source field and displays them with appropriate icons and
+ * formatting.
+ *
+ * @param diagnostics - Array of diagnostics to report
+ *
+ * @example
+ * ```typescript
+ * const diagnostics = [
+ *   { type: 'missing-file', severity: 'error', message: 'File not found', source: 'file-router' },
+ *   { type: 'unused-default', severity: 'warning', message: 'Default never used', source: 'examples' }
+ * ]
+ * report(diagnostics)
+ * ```
+ */
+export const report = (diagnostics: Diagnostic[]): void => {
+  if (diagnostics.length === 0) return
+
+  // Group diagnostics by source using kit's Group.by
+  const bySource = Group.by(diagnostics, 'source')
+
+  // Report each source's diagnostics
+  for (const [source, sourceDiagnostics] of Object.entries(bySource)) {
+    if (!sourceDiagnostics) continue
+    const summary = formatSummary(sourceDiagnostics)
+    console.warn(`\n${source} found ${summary}:\n`)
+
+    sourceDiagnostics.forEach((diagnostic, index) => {
+      const icon = getIcon(diagnostic.severity)
+      console.warn(`${icon} ${index + 1}. ${diagnostic.message}\n`)
+    })
+  }
+}

package/src/lib/diagnostic/severity.ts

@@ -0,0 +1,93 @@
+import { S } from '#lib/kit-temp/effect'
+import { Order } from 'effect'
+
+// ============================================================================
+// Schema - Severity
+// ============================================================================
+
+export const Severity = S.Enums(
+  {
+    error: 'error',
+    warning: 'warning',
+    info: 'info',
+  } as const,
+).annotations({
+  identifier: 'DiagnosticSeverity',
+  description: 'The severity level of a diagnostic message',
+})
+
+Severity.enums.error
+
+export type Severity = typeof Severity.Type
+
+// ============================================================================
+// Severity Literals
+// ============================================================================
+
+export const Error = S.Literal(Severity.enums.error)
+export const Warning = S.Literal(Severity.enums.warning)
+export const Info = S.Literal(Severity.enums.info)
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+export const is = S.is(Severity)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(Severity)
+export const decodeSync = S.decodeSync(Severity)
+export const encode = S.encode(Severity)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(Severity)
+
+// ============================================================================
+// Ordering
+// ============================================================================
+
+/**
+ * Order for severity levels.
+ * error > warning > info
+ */
+export const order: Order.Order<Severity> = Order.mapInput(
+  Order.number,
+  (severity: Severity) => {
+    switch (severity) {
+      case Severity.enums.error:
+        return 3
+      case Severity.enums.warning:
+        return 2
+      case Severity.enums.info:
+        return 1
+    }
+  },
+)
+
+// ============================================================================
+// Utilities
+// ============================================================================
+
+/**
+ * Returns the highest severity from an array of severities.
+ * Returns 'info' if array is empty.
+ */
+export const highest = (severities: Severity[]): Severity => {
+  if (severities.length === 0) return Severity.enums.info
+  return severities.reduce(Order.max(order))
+}
+
+/**
+ * Returns the lowest severity from an array of severities.
+ * Returns 'error' if array is empty (most conservative).
+ */
+export const lowest = (severities: Severity[]): Severity => {
+  if (severities.length === 0) return Severity.enums.error
+  return severities.reduce(Order.min(order))
+}

package/src/lib/directed-filter/$$.ts

@@ -0,0 +1 @@
+export * from './directed-filter.js'

package/src/lib/directed-filter/$.test.ts

@@ -0,0 +1,169 @@
+import { S } from '#lib/kit-temp/effect'
+import { describe, expect, test } from 'vitest'
+import { DirectedFilter } from './$.js'
+
+describe('create', () => {
+  test('returns Union and member schemas', () => {
+    const F = DirectedFilter.create(S.String)
+    expect(F).toHaveProperty('Union')
+    expect(F).toHaveProperty('Allow')
+    expect(F).toHaveProperty('Deny')
+    expect(F.Allow.make({ items: ['a'] })._tag).toBe('DirectedFilterAllow')
+    expect(F.Deny.make({ items: ['b'] })._tag).toBe('DirectedFilterDeny')
+  })
+})
+
+describe('constructor functions', () => {
+  test('allow creates DirectedFilterAllow', () => {
+    const filter = DirectedFilter.allow(['a', 'b'])
+    expect(filter._tag).toBe('DirectedFilterAllow')
+    expect(filter.items).toEqual(['a', 'b'])
+  })
+
+  test('deny creates DirectedFilterDeny', () => {
+    const filter = DirectedFilter.deny(['c', 'd'])
+    expect(filter._tag).toBe('DirectedFilterDeny')
+    expect(filter.items).toEqual(['c', 'd'])
+  })
+
+  test('AllowAll is DirectedFilterAllowAll', () => {
+    expect(DirectedFilter.AllowAll._tag).toBe('DirectedFilterAllowAll')
+  })
+
+  test('denyAll is DirectedFilterDenyAll', () => {
+    expect(DirectedFilter.DenyAll._tag).toBe('DirectedFilterDenyAll')
+  })
+})
+
+describe('fromOnlyExclude', () => {
+  test.for([
+    { only: ['a', 'b'], exclude: undefined, expected: { _tag: 'DirectedFilterAllow', items: ['a', 'b'] } },
+    { only: undefined, exclude: ['c', 'd'], expected: { _tag: 'DirectedFilterDeny', items: ['c', 'd'] } },
+    { only: ['a'], exclude: ['b'], expected: { _tag: 'DirectedFilterAllow', items: ['a'] } }, // only wins
+    { only: undefined, exclude: undefined, expected: { _tag: 'DirectedFilterAllowAll' } },
+    { only: [], exclude: [], expected: { _tag: 'DirectedFilterAllowAll' } },
+    { only: [], exclude: undefined, expected: { _tag: 'DirectedFilterAllowAll' } },
+  ])('$only/$exclude -> $expected', ({ only, exclude, expected }) => {
+    expect(DirectedFilter.fromOnlyExclude(only, exclude)).toEqual(expected)
+  })
+})
+
+describe('filter', () => {
+  const items = ['a', 'b', 'c', 'd']
+
+  test.for([
+    { filter: { _tag: 'DirectedFilterAllow', items: ['a', 'c'] }, expected: ['a', 'c'] },
+    { filter: { _tag: 'DirectedFilterDeny', items: ['b', 'd'] }, expected: ['a', 'c'] },
+    { filter: { _tag: 'DirectedFilterAllow', items: ['a', 'z'] }, expected: ['a'] }, // non-existent
+    { filter: { _tag: 'DirectedFilterDeny', items: ['x', 'y'] }, expected: items }, // non-existent
+    { filter: { _tag: 'DirectedFilterAllow', items: [] }, expected: [] },
+    { filter: { _tag: 'DirectedFilterDeny', items: [] }, expected: items },
+    { filter: { _tag: 'DirectedFilterAllowAll' }, expected: items },
+    { filter: { _tag: 'DirectedFilterDenyAll' }, expected: [] },
+  ])('$filter._tag with items $filter.items -> $expected', ({ filter, expected }) => {
+    expect(DirectedFilter.filter(filter as any)(items)).toEqual(expected)
+  })
+})
+
+describe('filterBy', () => {
+  const people = [
+    { id: 1, name: 'Alice', age: 30 },
+    { id: 2, name: 'Bob', age: 25 },
+    { id: 3, name: 'Charlie', age: 30 },
+  ]
+
+  test.for([
+    {
+      filter: { _tag: 'DirectedFilterAllow', items: [30] },
+      getter: (p: any) => p.age,
+      expected: [people[0], people[2]],
+    },
+    {
+      filter: { _tag: 'DirectedFilterDeny', items: ['Bob'] },
+      getter: (p: any) => p.name,
+      expected: [people[0], people[2]],
+    },
+    {
+      filter: { _tag: 'DirectedFilterAllowAll' },
+      getter: (p: any) => p.age,
+      expected: people,
+    },
+    {
+      filter: { _tag: 'DirectedFilterDenyAll' },
+      getter: (p: any) => p.name,
+      expected: [],
+    },
+  ])('filters by custom getter', ({ filter, getter, expected }) => {
+    expect(DirectedFilter.filterBy(filter as any)(getter)(people)).toEqual(expected)
+  })
+
+  test('supports partial application', () => {
+    const filter = { _tag: 'DirectedFilterAllow' as const, items: [1, 3] }
+    const filterById = DirectedFilter.filterBy(filter)((p: any) => p.id)
+    expect(filterById(people).map(p => p.id)).toEqual([1, 3])
+    expect(filterById([{ id: 5 }])).toEqual([])
+  })
+})
+
+describe('filterByProperty', () => {
+  const products = [
+    { id: 'p1', category: 'Electronics', price: 1000 },
+    { id: 'p2', category: 'Media', price: 20 },
+    { id: 'p3', category: 'Electronics', price: 800 },
+  ]
+
+  test.for([
+    {
+      filter: { _tag: 'DirectedFilterAllow', items: ['Electronics'] },
+      prop: 'category',
+      expected: [products[0], products[2]],
+    },
+    {
+      filter: { _tag: 'DirectedFilterDeny', items: ['p2'] },
+      prop: 'id',
+      expected: [products[0], products[2]],
+    },
+    {
+      filter: { _tag: 'DirectedFilterAllow', items: [20, 800] },
+      prop: 'price',
+      expected: [products[1], products[2]],
+    },
+  ])('filters by property $prop', ({ filter, prop, expected }) => {
+    expect(DirectedFilter.filterByProperty(filter as any)(prop as any)(products)).toEqual(expected)
+  })
+})
+
+describe('type guards', () => {
+  const allow = { _tag: 'DirectedFilterAllow' as const, items: ['a'] }
+  const deny = { _tag: 'DirectedFilterDeny' as const, items: ['b'] }
+  const allowAll = { _tag: 'DirectedFilterAllowAll' as const }
+  const denyAll = { _tag: 'DirectedFilterDenyAll' as const }
+
+  test('isAllow', () => {
+    expect(DirectedFilter.isAllow(allow)).toBe(true)
+    expect(DirectedFilter.isAllow(deny)).toBe(false)
+    expect(DirectedFilter.isAllow(allowAll)).toBe(false)
+    expect(DirectedFilter.isAllow(denyAll)).toBe(false)
+  })
+
+  test('isDeny', () => {
+    expect(DirectedFilter.isDeny(allow)).toBe(false)
+    expect(DirectedFilter.isDeny(deny)).toBe(true)
+    expect(DirectedFilter.isDeny(allowAll)).toBe(false)
+    expect(DirectedFilter.isDeny(denyAll)).toBe(false)
+  })
+
+  test('isAllowAll', () => {
+    expect(DirectedFilter.isAllowAll(allow)).toBe(false)
+    expect(DirectedFilter.isAllowAll(deny)).toBe(false)
+    expect(DirectedFilter.isAllowAll(allowAll)).toBe(true)
+    expect(DirectedFilter.isAllowAll(denyAll)).toBe(false)
+  })
+
+  test('isDenyAll', () => {
+    expect(DirectedFilter.isDenyAll(allow)).toBe(false)
+    expect(DirectedFilter.isDenyAll(deny)).toBe(false)
+    expect(DirectedFilter.isDenyAll(allowAll)).toBe(false)
+    expect(DirectedFilter.isDenyAll(denyAll)).toBe(true)
+  })
+})

package/src/lib/directed-filter/$.ts

@@ -0,0 +1 @@
+export * as DirectedFilter from './$$.js'

package/src/lib/directed-filter/directed-filter.ts

@@ -0,0 +1,241 @@
+import { S } from '#lib/kit-temp/effect'
+import { Match } from 'effect'
+
+// ============================================================================
+// Factory
+// ============================================================================
+
+/**
+ * Creates a DirectedFilter schema for a given item schema.
+ * Returns an object containing the Union schema and its member schemas.
+ *
+ * @param itemSchema - The schema for items in the filter
+ * @returns Object with Union, Allow, Deny, AllowAll, and DenyAll schemas
+ */
+export const create = <ItemSchema extends S.Schema.Any>(itemSchema: ItemSchema) => {
+  const Allow = S.TaggedStruct('DirectedFilterAllow', {
+    items: S.Array(itemSchema),
+  }).annotations({
+    identifier: 'DirectedFilterAllow',
+    description: 'Filter that allows only specified items',
+  })
+
+  const Deny = S.TaggedStruct('DirectedFilterDeny', {
+    items: S.Array(itemSchema),
+  }).annotations({
+    identifier: 'DirectedFilterDeny',
+    description: 'Filter that denies specified items',
+  })
+
+  const AllowAll = S.TaggedStruct('DirectedFilterAllowAll', {}).annotations({
+    identifier: 'DirectedFilterAllowAll',
+    description: 'Filter that allows all items (no-op)',
+  })
+
+  const DenyAll = S.TaggedStruct('DirectedFilterDenyAll', {}).annotations({
+    identifier: 'DirectedFilterDenyAll',
+    description: 'Filter that denies all items',
+  })
+
+  const Union = S.Union(Allow, Deny, AllowAll, DenyAll).annotations({
+    identifier: 'DirectedFilter',
+    description: 'A filter that controls item inclusion/exclusion',
+  })
+
+  return {
+    Union,
+    Allow,
+    Deny,
+    AllowAll,
+    DenyAll,
+  } as const
+}
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type DirectedFilterAllow<T> = {
+  readonly _tag: 'DirectedFilterAllow'
+  readonly items: readonly T[]
+}
+
+export type DirectedFilterDeny<T> = {
+  readonly _tag: 'DirectedFilterDeny'
+  readonly items: readonly T[]
+}
+
+export type DirectedFilterAllowAll = {
+  readonly _tag: 'DirectedFilterAllowAll'
+}
+
+export type DirectedFilterDenyAll = {
+  readonly _tag: 'DirectedFilterDenyAll'
+}
+
+export type DirectedFilter<T> =
+  | DirectedFilterAllow<T>
+  | DirectedFilterDeny<T>
+  | DirectedFilterAllowAll
+  | DirectedFilterDenyAll
+
+// ============================================================================
+// Filtering Functions
+// ============================================================================
+
+/**
+ * Filters a collection based on a DirectedFilter using a custom value getter.
+ * Returns a curried function for partial application.
+ * Short-circuits for AllowAll/DenyAll for performance.
+ *
+ * TODO: Use equivalence trait from schema if available instead of === for comparison
+ *
+ * @param filter - The DirectedFilter to apply
+ * @returns Curried function that takes a value getter and then a collection
+ */
+export const filterBy = <FilterItem>(
+  filter: DirectedFilter<FilterItem>,
+) =>
+<Item>(
+  getValue: (item: Item) => FilterItem,
+) =>
+(
+  collection: readonly Item[],
+): Item[] => {
+  return Match.value(filter).pipe(
+    Match.tagsExhaustive({
+      DirectedFilterAllowAll: () => [...collection], // Return copy for immutability
+      DirectedFilterDenyAll: () => [],
+      DirectedFilterAllow: (f) => {
+        const allowSet = new Set(f.items)
+        return collection.filter(item => allowSet.has(getValue(item)))
+      },
+      DirectedFilterDeny: (f) => {
+        const denySet = new Set(f.items)
+        return collection.filter(item => !denySet.has(getValue(item)))
+      },
+    }),
+  )
+}
+
+/**
+ * Filters a collection based on a DirectedFilter using a property name.
+ * Convenience function that extracts values by property key.
+ *
+ * @param filter - The DirectedFilter to apply
+ * @returns Curried function that takes a property name and then a collection
+ */
+export function filterByProperty<FilterItem>(
+  filter: DirectedFilter<FilterItem>,
+): <K extends PropertyKey>(
+  propertyName: K,
+) => <Item extends Record<K, any>>(
+  collection: readonly Item[],
+) => Item[]
+export function filterByProperty<FilterItem>(
+  filter: DirectedFilter<FilterItem>,
+) {
+  return <K extends PropertyKey>(propertyName: K) =>
+  <Item extends Record<K, any>>(collection: readonly Item[]): Item[] => {
+    return filterBy(filter)((item: Item) => item[propertyName] as FilterItem)(collection)
+  }
+}
+
+/**
+ * Filters a collection based on a DirectedFilter using identity.
+ * Used when the items themselves are the filter values.
+ *
+ * @param filter - The DirectedFilter to apply
+ * @returns Function that filters a collection
+ */
+export const filter = <Item>(
+  filter: DirectedFilter<Item>,
+) =>
+(
+  collection: readonly Item[],
+): Item[] => {
+  return filterBy(filter)((item: Item) => item)(collection)
+}
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+/**
+ * Const instance for allowing all items.
+ */
+export const AllowAll: DirectedFilterAllowAll = { _tag: 'DirectedFilterAllowAll' }
+
+/**
+ * Const instance for denying all items.
+ */
+export const DenyAll: DirectedFilterDenyAll = { _tag: 'DirectedFilterDenyAll' }
+
+/**
+ * Creates an Allow filter with the specified items.
+ */
+export const allow = <T>(items: readonly T[]): DirectedFilterAllow<T> => ({
+  _tag: 'DirectedFilterAllow',
+  items,
+})
+
+/**
+ * Creates a Deny filter with the specified items.
+ */
+export const deny = <T>(items: readonly T[]): DirectedFilterDeny<T> => ({
+  _tag: 'DirectedFilterDeny',
+  items,
+})
+
+/**
+ * Creates a DirectedFilter from only/exclude pattern commonly used in configuration.
+ * Returns AllowAll if neither only nor exclude has items.
+ *
+ * @param only - Items to allow (takes precedence over exclude)
+ * @param exclude - Items to deny
+ * @returns DirectedFilter (never null)
+ */
+export const fromOnlyExclude = <T>(
+  only: readonly T[] | undefined,
+  exclude: readonly T[] | undefined,
+  /**
+   * @default allowAll
+   */
+  fallback?: DirectedFilterDenyAll | DirectedFilterAllowAll,
+): DirectedFilter<T> => {
+  if (only && only.length > 0) {
+    return allow(only)
+  }
+  if (exclude && exclude.length > 0) {
+    return deny(exclude)
+  }
+  return fallback ?? AllowAll
+}
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+/**
+ * Type guard for DirectedFilterAllow
+ */
+export const isAllow = <T>(filter: DirectedFilter<T>): filter is DirectedFilterAllow<T> =>
+  filter._tag === 'DirectedFilterAllow'
+
+/**
+ * Type guard for DirectedFilterDeny
+ */
+export const isDeny = <T>(filter: DirectedFilter<T>): filter is DirectedFilterDeny<T> =>
+  filter._tag === 'DirectedFilterDeny'
+
+/**
+ * Type guard for DirectedFilterAllowAll
+ */
+export const isAllowAll = <T>(filter: DirectedFilter<T>): filter is DirectedFilterAllowAll =>
+  filter._tag === 'DirectedFilterAllowAll'
+
+/**
+ * Type guard for DirectedFilterDenyAll
+ */
+export const isDenyAll = <T>(filter: DirectedFilter<T>): filter is DirectedFilterDenyAll =>
+  filter._tag === 'DirectedFilterDenyAll'

package/src/lib/document/$$.ts

@@ -0,0 +1,3 @@
+export * from './document.js'
+export * as Unversioned from './unversioned.js'
+export * as Versioned from './versioned.js'

package/src/lib/document/$.ts

@@ -0,0 +1 @@
+export * as Document from './$$.js'