polen 0.10.0-next.14 → 0.10.0-next.4

package/src/lib/file-router/sidebar/sidebar-tree.ts

@@ -0,0 +1,110 @@
+import { Tree } from '#lib/tree/index'
+import { Str } from '@wollybeard/kit'
+import * as FileRouter from '../file-router.ts'
+import type { RouteTreeNode } from '../scan-tree.ts'
+import type { ItemLink, ItemSection, Sidebar } from './types.ts'
+
+export * from './types.ts'
+
+/**
+ * Build sidebar from tree structure
+ */
+export const buildFromTree = (routeTree: RouteTreeNode, basePath: FileRouter.Path): Sidebar => {
+  const links: ItemLink[] = []
+  const sections: ItemSection[] = []
+
+  // Process only the children of the root node
+  for (const child of routeTree.children) {
+    processNode(child, basePath, [], links, sections)
+  }
+
+  const items = [...links, ...sections]
+
+  return {
+    items,
+  }
+}
+
+const processNode = (
+  node: RouteTreeNode,
+  basePath: FileRouter.Path,
+  parentPath: string[],
+  links: ItemLink[],
+  sections: ItemSection[],
+): void => {
+  const currentPath = [...parentPath, node.value.name]
+
+  if (node.value.type === 'directory') {
+    // This is a directory - create a section
+    const sectionPath = [...basePath, ...currentPath]
+    const sectionPathExp = FileRouter.pathToExpression(sectionPath)
+    const sectionTitle = Str.titlizeSlug(node.value.name)
+
+    const section: ItemSection = {
+      type: `ItemSection`,
+      title: sectionTitle,
+      pathExp: sectionPathExp.startsWith('/') ? sectionPathExp.slice(1) : sectionPathExp,
+      isLinkToo: false,
+      links: [],
+    }
+
+    // Check if this directory has an index file
+    const indexChild = node.children.find(child => child.value.type === 'file' && child.value.name === 'index')
+    if (indexChild) {
+      section.isLinkToo = true
+    }
+
+    // Process all non-index children as links for this section
+    for (const child of node.children) {
+      if (child.value.type === 'file' && child.value.name !== 'index' && child.value.route) {
+        // Pass the parent path of the route, not the section path
+        const routeParentPath = child.value.route.logical.path.slice(0, -1)
+        section.links.push(routeToItemLink(child.value.route, routeParentPath))
+      } else if (child.value.type === 'directory') {
+        // Recursively process subdirectories
+        // Note: This creates nested sections which the original implementation doesn't support
+        // For now, we'll just add the files from subdirectories to the parent section
+        collectFilesFromDirectory(child, child.value.route?.logical.path || [], section.links)
+      }
+    }
+
+    sections.push(section)
+  } else if (node.value.type === 'file' && node.value.route) {
+    // This is a top-level file - add as nav
+    if (node.value.name !== 'index') {
+      links.push(routeToItemLink(node.value.route, basePath))
+    }
+  }
+}
+
+const collectFilesFromDirectory = (
+  node: RouteTreeNode,
+  basePath: FileRouter.Path,
+  links: ItemLink[],
+): void => {
+  Tree.visit(node, (n) => {
+    if (n.value.type === 'file' && n.value.route && n.value.name !== 'index') {
+      // Use the route's parent path for relative title generation
+      const routeParentPath = n.value.route.logical.path.slice(0, -1)
+      links.push(routeToItemLink(n.value.route, routeParentPath))
+    }
+  })
+}
+
+const routeToItemLink = (route: FileRouter.Route, basePath: FileRouter.Path): ItemLink => {
+  const pagePathExp = FileRouter.routeToPathExpression(route)
+  const pageRelative = FileRouter.makeRelativeUnsafe(route, basePath)
+  const pageRelativePathExp = FileRouter.routeToPathExpression(pageRelative)
+
+  // Remove leading slash for title generation
+  const titlePath = pageRelativePathExp.startsWith('/') ? pageRelativePathExp.slice(1) : pageRelativePathExp
+
+  // Use only the last segment for the title
+  const titleSegment = pageRelative.logical.path[pageRelative.logical.path.length - 1] || titlePath
+
+  return {
+    type: `ItemLink`,
+    pathExp: pagePathExp.startsWith('/') ? pagePathExp.slice(1) : pagePathExp,
+    title: Str.titlizeSlug(titleSegment),
+  }
+}

package/src/lib/file-router/sidebar/types.ts

@@ -0,0 +1,19 @@
+export interface Sidebar {
+  items: Item[]
+}
+
+export type Item = ItemLink | ItemSection
+
+export interface ItemLink {
+  type: `ItemLink`
+  title: string
+  pathExp: string
+}
+
+export interface ItemSection {
+  type: `ItemSection`
+  title: string
+  pathExp: string
+  isLinkToo: boolean
+  links: ItemLink[]
+}

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

@@ -61,7 +61,7 @@ describe('property-based tests', () => {
   test('objPolicyFilter allow/deny are complementary', () => {
     fc.assert(
       fc.property(
-        fc.object(),
+        fc.dictionary(fc.string(), fc.anything()),
         fc.array(fc.string()),
         (obj, keys) => {
           const allowed = objPolicyFilter('allow', obj, keys)
@@ -74,13 +74,8 @@ describe('property-based tests', () => {
             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)
+          // Combined they reconstruct the original object
+          expect({ ...allowed, ...denied }).toEqual(obj)
         },
       ),
     )
@@ -89,17 +84,10 @@ describe('property-based tests', () => {
   test('objFilter preserves values unchanged', () => {
     fc.assert(
       fc.property(
-        fc.object(),
+        fc.dictionary(fc.string(), fc.anything()),
         (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)
+          expect(filtered).toEqual(obj)
 
           // Values are the same reference
           Object.keys(filtered).forEach(key => {
@@ -113,7 +101,7 @@ describe('property-based tests', () => {
   test('objPolicyFilter is immutable', () => {
     fc.assert(
       fc.property(
-        fc.object(),
+        fc.dictionary(fc.string(), fc.anything()),
         fc.array(fc.string()),
         fc.oneof(fc.constant('allow' as const), fc.constant('deny' as const)),
         (obj, keys, mode) => {
@@ -128,7 +116,7 @@ describe('property-based tests', () => {
   test('empty keys behavior', () => {
     fc.assert(
       fc.property(
-        fc.object(),
+        fc.dictionary(fc.string(), fc.anything()),
         (obj) => {
           expect(objPolicyFilter('allow', obj, [])).toEqual({})
           expect(objPolicyFilter('deny', obj, [])).toEqual(obj)

package/src/lib/kit-temp.ts

@@ -12,8 +12,10 @@
 //
 //
 
-import { Arr, Err, Fs, Http, Path, Undefined } from '@wollybeard/kit'
+import { Arr, Err, Fs, Http, Path, type Ts, Undefined } from '@wollybeard/kit'
+import { never } from '@wollybeard/kit/language'
 import type { ResolveHookContext } from 'node:module'
+import type { IsNever } from 'type-fest'
 
 export const arrayEquals = (a: any[], b: any[]) => {
   if (a.length !== b.length) return false
@@ -107,7 +109,7 @@ export const objPolicyFilter = <
   if (mode === 'allow') {
     // For allow mode, only add specified keys
     for (const key of keys) {
-      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      if (key in obj) {
         // @ts-expect-error
         result[key] = obj[key]
       }
@@ -141,9 +143,7 @@ export const objFilter = <T extends object>(
   predicate: (key: keyof T, value: T[keyof T], obj: T) => boolean,
 ): Partial<T> => {
   const result = {} as Partial<T>
-  // Use Object.keys to get all enumerable own properties
-  // This matches the behavior of for...in but only for own properties
-  for (const key of Object.keys(obj) as (keyof T)[]) {
+  for (const key in obj) {
     if (predicate(key, obj[key], obj)) {
       result[key] = obj[key]
     }
@@ -218,305 +218,3 @@ export type ExtendsExact<$Input, $Constraint> =
       ? $Input
       : never
   : never
-
-/**
- * Split an array into chunks of specified size
- *
- * @param array - The array to chunk
- * @param size - The size of each chunk
- * @returns Array of chunks
- *
- * @example
- * ```ts
- * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
- * chunk(['a', 'b', 'c'], 3) // [['a', 'b', 'c']]
- * ```
- */
-export const chunk = <T>(array: readonly T[], size: number): T[][] => {
-  if (size <= 0) throw new Error('Chunk size must be greater than 0')
-  if (array.length === 0) return []
-
-  const chunks: T[][] = []
-  for (let i = 0; i < array.length; i += size) {
-    chunks.push(array.slice(i, i + size))
-  }
-  return chunks
-}
-
-export interface AsyncParallelOptions {
-  /**
-   * Maximum number of items to process concurrently
-   * @default 10
-   */
-  concurrency?: number
-
-  /**
-   * If true, stops processing on first error
-   * If false, continues processing all items even if some fail
-   * @default false
-   */
-  failFast?: boolean
-
-  /**
-   * Size of batches to process items in
-   * If not specified, all items are processed with the specified concurrency
-   */
-  batchSize?: number
-}
-
-export interface AsyncParallelResult<T, R> {
-  /** Successfully processed results */
-  results: R[]
-  /** Errors that occurred during processing */
-  errors: (Error & { item: T })[]
-  /** Whether all items were processed successfully */
-  success: boolean
-}
-
-/**
- * Process items in parallel with configurable options
- *
- * @param items - Items to process
- * @param operation - Async function to apply to each item (with optional index)
- * @param options - Configuration options
- * @returns Results and errors from processing
- *
- * @example
- * ```ts
- * const items = [1, 2, 3, 4, 5]
- * const result = await asyncParallel(items, async (n, index) => n * 2, {
- *   concurrency: 2,
- *   batchSize: 3,
- *   failFast: false
- * })
- * // result.results: [2, 4, 6, 8, 10]
- * // result.errors: []
- * // result.success: true
- * ```
- */
-export const asyncParallel = async <T, R>(
-  items: readonly T[],
-  operation: (item: T, index: number) => Promise<R>,
-  options: AsyncParallelOptions = {},
-): Promise<AsyncParallelResult<T, R>> => {
-  const { concurrency = 10, failFast = false, batchSize } = options
-
-  if (items.length === 0) {
-    return { results: [], errors: [], success: true }
-  }
-
-  const allResults: R[] = []
-  const allErrors: (Error & { item: T })[] = []
-
-  // If batchSize is specified, process in batches
-  if (batchSize !== undefined) {
-    const batches = chunk(items, batchSize)
-    let globalIndex = 0
-
-    for (const batch of batches) {
-      const batchResult = await processBatch(batch, operation, concurrency, failFast, globalIndex)
-      allResults.push(...batchResult.results)
-      allErrors.push(...batchResult.errors)
-      globalIndex += batch.length
-
-      if (failFast && batchResult.errors.length > 0) {
-        break
-      }
-    }
-  } else {
-    // Process all items with specified concurrency
-    const result = await processBatch(items, operation, concurrency, failFast, 0)
-    allResults.push(...result.results)
-    allErrors.push(...result.errors)
-  }
-
-  return {
-    results: allResults,
-    errors: allErrors,
-    success: allErrors.length === 0,
-  }
-}
-
-/**
- * Process a batch of items with limited concurrency
- */
-const processBatch = async <T, R>(
-  items: readonly T[],
-  operation: (item: T, index: number) => Promise<R>,
-  concurrency: number,
-  failFast: boolean,
-  startIndex: number = 0,
-): Promise<AsyncParallelResult<T, R>> => {
-  const results: R[] = []
-  const errors: (Error & { item: T })[] = []
-
-  // Process items in chunks based on concurrency limit
-  const chunks = chunk(items, concurrency)
-  let currentIndex = startIndex
-
-  for (const chunkItems of chunks) {
-    const promises = chunkItems.map(async (item, chunkIndex) => {
-      const globalIndex = currentIndex + chunkIndex
-      try {
-        const result = await operation(item, globalIndex)
-        return { success: true, result, item }
-      } catch (error) {
-        const enhancedError = error instanceof Error ? error : new Error(String(error))
-        Object.assign(enhancedError, { item })
-        return { success: false, error: enhancedError as Error & { item: T }, item }
-      }
-    })
-
-    currentIndex += chunkItems.length
-
-    const chunkResults = await Promise.allSettled(promises)
-
-    for (const promiseResult of chunkResults) {
-      if (promiseResult.status === 'fulfilled') {
-        const { success, result, error, item } = promiseResult.value
-        if (success) {
-          results.push(result!)
-        } else {
-          errors.push(error!)
-          if (failFast) {
-            return { results, errors, success: false }
-          }
-        }
-      } else {
-        // This shouldn't happen since we're catching errors above
-        // But handle it just in case
-        const error = new Error('Unexpected promise rejection') as Error & { item: any }
-        errors.push(error)
-        if (failFast) {
-          return { results, errors, success: false }
-        }
-      }
-    }
-  }
-
-  return { results, errors, success: errors.length === 0 }
-}
-
-// /**
-//  * Reduce an array asynchronously, processing each item in sequence
-//  *
-//  * @param items - Array of items to process
-//  * @param reducer - Async function that takes accumulator and current item
-//  * @param initial - Initial value for the accumulator
-//  * @returns Final accumulated value
-//  *
-//  * @example
-//  * ```ts
-//  * const numbers = [1, 2, 3, 4]
-//  * const sum = await asyncReduce(numbers, async (acc, n) => acc + n, 0)
-//  * // sum: 10
-//  *
-//  * const transforms = [addHeader, addFooter, minify]
-//  * const html = await asyncReduce(transforms, async (html, transform) => transform(html), initialHtml)
-//  * ```
-//  */
-// export const asyncReduce = async <T, R>(
-//   items: readonly T[],
-//   reducer: (accumulator: R, current: T, index: number) => Promise<R> | R,
-//   initial: R,
-// ): Promise<R> => {
-//   let result = initial
-//   for (let i = 0; i < items.length; i++) {
-//     const item = items[i]!
-//     result = await reducer(result, item, i)
-//   }
-//   return result
-// }
-
-// /**
-//  * Curried version of asyncReduce for functions that transform a value
-//  *
-//  * @param transformers - Array of transformer functions
-//  * @returns A function that takes an initial value and applies all transformers
-//  *
-//  * @example
-//  * ```ts
-//  * const transformers = [addHeader, addFooter, minify]
-//  * const applyTransforms = asyncReduceWith(transformers)
-//  * const finalHtml = await applyTransforms(initialHtml)
-//  *
-//  * // For simple pipelines where each function transforms the same type
-//  * const htmlPipeline = asyncReduceWith([
-//  *   (html) => html.replace('foo', 'bar'),
-//  *   async (html) => await prettify(html),
-//  *   (html) => html.trim()
-//  * ])
-//  * ```
-//  */
-// export const asyncReduceWith = <T>(
-//   transformers: readonly ((value: T) => Promise<T> | T)[],
-// ) => {
-//   return async (initial: T): Promise<T> => {
-//     return asyncReduce(transformers, (value, transform) => transform(value), initial)
-//   }
-// }
-
-/**
- * Reduce an array asynchronously with context, processing each item in sequence
- *
- * @param items - Array of items to process
- * @param reducer - Async function that takes accumulator, current item, and context
- * @param initial - Initial value for the accumulator
- * @param context - Context object passed to each reducer call
- * @returns Final accumulated value
- *
- * @example
- * ```ts
- * const transformers = [transformer1, transformer2]
- * const ctx = { request: req, response: res }
- * const result = await asyncReduceWithContext(
- *   transformers,
- *   async (html, transformer) => transformer(html, ctx),
- *   initialHtml,
- *   ctx
- * )
- * ```
- */
-export const asyncReduce = async <T, R, C>(
-  items: readonly T[],
-  reducer: (accumulator: R, current: T, context: C, index: number) => Promise<R> | R,
-  initial: R,
-  context: C,
-): Promise<R> => {
-  let result = initial
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i]!
-    result = await reducer(result, item, context, i)
-  }
-  return result
-}
-
-/**
- * Curried version of asyncReduceWithContext for functions that transform a value with context
- *
- * @param transformers - Array of transformer functions that take value and context
- * @returns A function that takes an initial value and context, and applies all transformers
- *
- * @example
- * ```ts
- * const transformers = [
- *   (html, ctx) => html.replace('{{url}}', ctx.req.url),
- *   async (html, ctx) => await ctx.minify(html),
- * ]
- * const applyTransforms = asyncReduceWithContextWith(transformers)
- * const finalHtml = await applyTransforms(initialHtml, ctx)
- * ```
- */
-export const asyncReduceWith = <T, C>(
-  transformers: readonly ((value: T, context: C) => Promise<T> | T)[],
-  context: C,
-) => {
-  return async (initial: T): Promise<T> => {
-    return asyncReduce(
-      transformers,
-      (value, transform, ctx) => transform(value, ctx),
-      initial,
-      context,
-    )
-  }
-}

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

@@ -137,10 +137,10 @@ describe('runAndExit', () => {
     const double = async (x: number) => x * 2
 
     await expect(() => Task.runAndExit(double, 5, { name: 'double' })).rejects.toThrow('process.exit called')
-
+    
     expect(mockExit).toHaveBeenCalledWith(0)
     expect(mockLog).toHaveBeenCalled()
-
+    
     // Verify the logged output contains expected content
     const loggedOutput = mockLog.mock.calls[0]?.[0]
     expect(loggedOutput).toContain('double')
@@ -161,7 +161,7 @@ describe('runAndExit', () => {
     }
 
     await expect(() => Task.runAndExit(failing, null, { name: 'failing' })).rejects.toThrow('process.exit called')
-
+    
     expect(mockExit).toHaveBeenCalledWith(1)
     expect(mockLog).toHaveBeenCalled()
 

package/src/lib/tree/index.ts

@@ -0,0 +1,2 @@
+export * as Tree from './tree.ts'
+export type { TreeMapper, TreeNode, TreePredicate, TreeVisitor } from './tree.ts'

package/src/lib/tree/tree.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from 'vitest'
+import * as Tree from './tree.ts'
+
+describe('Tree', () => {
+  const sampleTree = Tree.node('root', [
+    Tree.node('a', [
+      Tree.node('a1'),
+      Tree.node('a2'),
+    ]),
+    Tree.node('b', [
+      Tree.node('b1'),
+    ]),
+    Tree.node('c'),
+  ])
+
+  test('node creates a tree node', () => {
+    const leaf = Tree.node('leaf')
+    expect(leaf).toEqual({ value: 'leaf', children: [] })
+
+    const parent = Tree.node('parent', [leaf])
+    expect(parent).toEqual({ value: 'parent', children: [leaf] })
+  })
+
+  test('map transforms node values', () => {
+    const upperTree = Tree.map(sampleTree, value => value.toUpperCase())
+
+    expect(upperTree.value).toBe('ROOT')
+    expect(upperTree.children[0]!.value).toBe('A')
+    expect(upperTree.children[0]!.children[0]!.value).toBe('A1')
+  })
+
+  test('map provides depth and path', () => {
+    const depths: number[] = []
+    const paths: string[][] = []
+
+    Tree.map(sampleTree, (value, depth, path) => {
+      depths.push(depth)
+      paths.push(path)
+      return value
+    })
+
+    expect(depths).toEqual([0, 1, 2, 2, 1, 2, 1])
+    expect(paths[0]).toEqual([])
+    expect(paths[1]).toEqual(['root'])
+    expect(paths[2]).toEqual(['root', 'a'])
+  })
+
+  test('visit traverses all nodes', () => {
+    const visited: string[] = []
+    Tree.visit(sampleTree, node => visited.push(node.value))
+
+    expect(visited).toEqual(['root', 'a', 'a1', 'a2', 'b', 'b1', 'c'])
+  })
+
+  test('find locates node', () => {
+    const found = Tree.find(sampleTree, value => value === 'b1')
+    expect(found?.value).toBe('b1')
+
+    const notFound = Tree.find(sampleTree, value => value === 'x')
+    expect(notFound).toBeUndefined()
+  })
+
+  test('filter removes non-matching nodes', () => {
+    const filtered = Tree.filter(sampleTree, value => !value.includes('2'))
+
+    expect(filtered).toBeDefined()
+    expect(Tree.flatten(filtered!)).toEqual(['root', 'a', 'a1', 'b', 'b1', 'c'])
+  })
+
+  test('sort orders children', () => {
+    const sorted = Tree.sort(sampleTree, (a, b) => b.localeCompare(a))
+
+    expect(sorted.children.map(c => c.value)).toEqual(['c', 'b', 'a'])
+    expect(sorted.children[2]!.children.map(c => c.value)).toEqual(['a2', 'a1'])
+  })
+
+  test('flatten returns all values', () => {
+    const flat = Tree.flatten(sampleTree)
+    expect(flat).toEqual(['root', 'a', 'a1', 'a2', 'b', 'b1', 'c'])
+  })
+
+  test('depth calculates tree depth', () => {
+    expect(Tree.depth(Tree.node('single'))).toBe(0)
+    expect(Tree.depth(sampleTree)).toBe(2)
+  })
+
+  test('count counts all nodes', () => {
+    expect(Tree.count(Tree.node('single'))).toBe(1)
+    expect(Tree.count(sampleTree)).toBe(7)
+  })
+
+  test('isLeaf identifies leaf nodes', () => {
+    expect(Tree.isLeaf(sampleTree)).toBe(false)
+    expect(Tree.isLeaf(sampleTree.children[0]!)).toBe(false)
+    expect(Tree.isLeaf(sampleTree.children[0]!.children[0]!)).toBe(true)
+  })
+
+  test('leaves gets all leaf nodes', () => {
+    const leafNodes = Tree.leaves(sampleTree)
+    expect(leafNodes.map(n => n.value)).toEqual(['a1', 'a2', 'b1', 'c'])
+  })
+
+  test('fromList builds tree from flat list', () => {
+    const items = [
+      { id: '1', name: 'root' },
+      { id: '2', parentId: '1', name: 'child1' },
+      { id: '3', parentId: '1', name: 'child2' },
+      { id: '4', parentId: '2', name: 'grandchild' },
+    ]
+
+    const trees = Tree.fromList(items, undefined)
+    expect(trees).toHaveLength(1)
+    expect(trees[0]!.value.name).toBe('root')
+    expect(trees[0]!.children).toHaveLength(2)
+    expect(trees[0]!.children[0]!.children[0]!.value.name).toBe('grandchild')
+  })
+})