polen 0.10.0-next.14 → 0.10.0-next.3

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/helpers.ts

@@ -1,4 +1,4 @@
-import { Err, Manifest } from '@wollybeard/kit'
+import { Manifest } from '@wollybeard/kit'
 
 /**
  * Check if a project has a package installed by examining its package.json
@@ -9,9 +9,8 @@ export async function checkIsProjectHasPackageInstalled(
 ): Promise<boolean> {
   const packageJson = await Manifest.resource.read(projectRoot)
 
-  if (Err.is(packageJson)) {
-    if (packageJson._tag === 'ResourceErrorNotFound') return false
-    throw packageJson
+  if (!packageJson) {
+    return false
   }
 
   // Check if React is in dependencies or devDependencies

package/src/lib/kit-temp.ts

@@ -12,7 +12,7 @@
 //
 //
 
-import { Arr, Err, Fs, Http, Path, Undefined } from '@wollybeard/kit'
+import { Fs, Http, Path, Undefined } from '@wollybeard/kit'
 import type { ResolveHookContext } from 'node:module'
 
 export const arrayEquals = (a: any[], b: any[]) => {
@@ -60,103 +60,23 @@ export interface ImportEvent {
   context: ResolveHookContext
 }
 
-// dprint-ignore
-export type ObjPolicyFilter<
-  $Object extends object,
-  $Key extends Keyof<$Object>,
-  Mode extends 'allow' | 'deny',
-> = Mode extends 'allow'
-      ? Pick<$Object, Extract<$Key, keyof $Object>>
-      : Omit<$Object, Extract<$Key, keyof $Object>>
-
-/**
- * Like keyof but returns PropertyKey for object
- */
-type Keyof<$Object extends object> = object extends $Object ? PropertyKey : (keyof $Object)
-
-/**
- * Filter object properties based on a policy mode and set of keys
- *
- * @param mode - 'allow' to keep only specified keys, 'deny' to remove specified keys
- * @param obj - The object to filter
- * @param keys - The keys to process
- * @returns A filtered object with proper type inference
- *
- * @example
- * ```ts
- * const obj = { a: 1, b: 2, c: 3 }
- *
- * // Allow mode: keep only 'a' and 'c'
- * objPolicyFilter('allow', obj, ['a', 'c']) // { a: 1, c: 3 }
- *
- * // Deny mode: remove 'a' and 'c'
- * objPolicyFilter('deny', obj, ['a', 'c']) // { b: 2 }
- * ```
- */
-export const objPolicyFilter = <
-  obj extends object,
-  keyUnion extends Keyof<obj>,
-  mode extends 'allow' | 'deny',
->(
-  mode: mode,
-  obj: obj,
-  keys: readonly keyUnion[],
-): ObjPolicyFilter<obj, keyUnion, mode> => {
-  const result: any = mode === 'deny' ? { ...obj } : {}
-
-  if (mode === 'allow') {
-    // For allow mode, only add specified keys
-    for (const key of keys) {
-      if (Object.prototype.hasOwnProperty.call(obj, key)) {
-        // @ts-expect-error
-        result[key] = obj[key]
-      }
-    }
-  } else {
-    // For deny mode, remove specified keys
-    for (const key of keys) {
-      delete result[key]
-    }
-  }
-
-  return result
-}
-
-/**
- * Filter an object using a predicate function
- *
- * @param obj - The object to filter
- * @param predicate - Function that returns true to keep a key/value pair
- * @returns A new object with only the key/value pairs where predicate returned true
- *
- * @example
- * ```ts
- * const obj = { a: 1, b: 2, c: 3 }
- * objFilter(obj, (k, v) => v > 1) // { b: 2, c: 3 }
- * objFilter(obj, k => k !== 'b') // { a: 1, c: 3 }
- * ```
- */
-export const objFilter = <T extends object>(
-  obj: T,
-  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)[]) {
-    if (predicate(key, obj[key], obj)) {
-      result[key] = obj[key]
-    }
-  }
-  return result
-}
-
 export const ObjPick = <T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K> => {
-  return objPolicyFilter('allow', obj, keys) as any
+  return keys.reduce((acc, key) => {
+    if (key in obj) {
+      acc[key] = obj[key]
+    }
+    return acc
+  }, {} as Pick<T, K>)
 }
 
 export const ObjOmit = <T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K> => {
-  return objPolicyFilter('deny', obj, keys) as any
+  return keys.reduce((acc, key) => {
+    if (key in acc) {
+      // @ts-expect-error omitted already at type level
+      delete acc[key]
+    }
+    return acc
+  }, { ...obj } as Omit<T, K>)
 }
 
 export const ObjPartition = <T extends object, K extends keyof T>(
@@ -186,337 +106,3 @@ export const ResponseInternalServerError = () =>
     status: Http.Status.InternalServerError.code,
     statusText: Http.Status.InternalServerError.description,
   })
-
-/**
- * Execute an operation on multiple items, continuing even if some fail
- */
-export async function tryCatchMany<item, result>(
-  items: item[],
-  operation: (item: item) => Promise<result>,
-): Promise<[result[], (Error & { context: { item: item } })[]]> {
-  const partitionedResults = await Promise.all(items.map(async (item) => {
-    const result = await Err.tryCatch(() => operation(item))
-    if (Err.is(result)) {
-      const error = result as Error & { context: { item: item } }
-      error.context = { item }
-      return error
-    }
-    return result
-  })).then(Arr.partitionErrors)
-  return partitionedResults as any
-}
-
-/**
- * Type-level helper to check if two types are exactly the same (invariant).
- */
-export type IsExact<T, U> = T extends U ? U extends T ? true : false : false
-
-// dprint-ignore
-export type ExtendsExact<$Input, $Constraint> =
-  $Input extends $Constraint
-    ? $Constraint extends $Input
-      ? $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/shiki/shiki.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'vitest'
-import { getHighlighter, highlightCode } from './shiki.ts'
+import { getHighlighter, highlightCode } from './shiki.js'
 
 test(`getHighlighter returns singleton instance`, async () => {
   const highlighter1 = await getHighlighter()

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'