polen 0.10.0-next.13 → 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,10 +12,8 @@
 //
 //
 
-import { Arr, Err, Fs, Http, Path, type Ts, Undefined } from '@wollybeard/kit'
-import { never } from '@wollybeard/kit/language'
+import { Fs, Http, Path, Undefined } from '@wollybeard/kit'
 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
@@ -62,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 (key in obj) {
-        // @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>(
@@ -188,35 +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

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'

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')
+  })
+})

package/src/lib/tree/tree.ts

@@ -0,0 +1,183 @@
+/**
+ * Generic tree data structure and utilities
+ */
+
+export interface TreeNode<T> {
+  value: T
+  children: TreeNode<T>[]
+}
+
+export type TreeVisitor<T, R = void> = (node: TreeNode<T>, depth: number, path: T[]) => R
+
+export type TreeMapper<T, U> = (value: T, depth: number, path: T[]) => U
+
+export type TreePredicate<T> = (value: T, depth: number, path: T[]) => boolean
+
+/**
+ * Create a new tree node
+ */
+export const node = <T>(value: T, children: TreeNode<T>[] = []): TreeNode<T> => ({
+  value,
+  children,
+})
+
+/**
+ * Map over a tree, transforming each node's value
+ */
+export const map = <T, U>(
+  tree: TreeNode<T>,
+  mapper: TreeMapper<T, U>,
+  depth = 0,
+  path: T[] = [],
+): TreeNode<U> => {
+  const newPath = [...path, tree.value]
+  return {
+    value: mapper(tree.value, depth, path),
+    children: tree.children.map(child => map(child, mapper, depth + 1, newPath)),
+  }
+}
+
+/**
+ * Visit each node in the tree (depth-first)
+ */
+export const visit = <T>(
+  tree: TreeNode<T>,
+  visitor: TreeVisitor<T>,
+  depth = 0,
+  path: T[] = [],
+): void => {
+  visitor(tree, depth, path)
+  const newPath = [...path, tree.value]
+  tree.children.forEach(child => visit(child, visitor, depth + 1, newPath))
+}
+
+/**
+ * Find a node in the tree
+ */
+export const find = <T>(
+  tree: TreeNode<T>,
+  predicate: TreePredicate<T>,
+  depth = 0,
+  path: T[] = [],
+): TreeNode<T> | undefined => {
+  if (predicate(tree.value, depth, path)) {
+    return tree
+  }
+  const newPath = [...path, tree.value]
+  for (const child of tree.children) {
+    const found = find(child, predicate, depth + 1, newPath)
+    if (found) return found
+  }
+  return undefined
+}
+
+/**
+ * Filter tree nodes (keeps structure, removes non-matching nodes)
+ */
+export const filter = <T>(
+  tree: TreeNode<T>,
+  predicate: TreePredicate<T>,
+  depth = 0,
+  path: T[] = [],
+): TreeNode<T> | undefined => {
+  const newPath = [...path, tree.value]
+  const filteredChildren = tree.children
+    .map(child => filter(child, predicate, depth + 1, newPath))
+    .filter((child): child is TreeNode<T> => child !== undefined)
+
+  // Keep node if it matches or has matching children
+  if (predicate(tree.value, depth, path) || filteredChildren.length > 0) {
+    return {
+      value: tree.value,
+      children: filteredChildren,
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Sort a tree's children at each level
+ */
+export const sort = <T>(
+  tree: TreeNode<T>,
+  compareFn: (a: T, b: T) => number,
+): TreeNode<T> => ({
+  value: tree.value,
+  children: tree.children
+    .map(child => sort(child, compareFn))
+    .sort((a, b) => compareFn(a.value, b.value)),
+})
+
+/**
+ * Flatten a tree into an array (depth-first)
+ */
+export const flatten = <T>(tree: TreeNode<T>): T[] => {
+  const result: T[] = [tree.value]
+  tree.children.forEach(child => {
+    result.push(...flatten(child))
+  })
+  return result
+}
+
+/**
+ * Get the depth of the tree
+ */
+export const depth = <T>(tree: TreeNode<T>): number => {
+  if (tree.children.length === 0) return 0
+  return 1 + Math.max(...tree.children.map(depth))
+}
+
+/**
+ * Count total nodes in the tree
+ */
+export const count = <T>(tree: TreeNode<T>): number => {
+  return 1 + tree.children.reduce((sum, child) => sum + count(child), 0)
+}
+
+/**
+ * Check if a node is a leaf (has no children)
+ */
+export const isLeaf = <T>(node: TreeNode<T>): boolean => {
+  return node.children.length === 0
+}
+
+/**
+ * Get all leaf nodes
+ */
+export const leaves = <T>(tree: TreeNode<T>): TreeNode<T>[] => {
+  if (isLeaf(tree)) return [tree]
+  return tree.children.flatMap(leaves)
+}
+
+/**
+ * Build a tree from a flat list with parent references
+ */
+export const fromList = <T extends { id: string; parentId?: string }>(
+  items: T[],
+  rootId?: string,
+): TreeNode<T>[] => {
+  const itemMap = new Map(items.map(item => [item.id, item]))
+  const roots: TreeNode<T>[] = []
+  const nodeMap = new Map<string, TreeNode<T>>()
+
+  // Create all nodes
+  items.forEach(item => {
+    nodeMap.set(item.id, node(item))
+  })
+
+  // Build hierarchy
+  items.forEach(item => {
+    const itemNode = nodeMap.get(item.id)!
+    if (item.parentId === rootId) {
+      roots.push(itemNode)
+    } else if (item.parentId) {
+      const parent = nodeMap.get(item.parentId)
+      if (parent) {
+        parent.children.push(itemNode)
+      }
+    }
+  })
+
+  return roots
+}

package/src/singletons/debug.ts

@@ -1,3 +1,3 @@
 import { Debug } from '@wollybeard/kit'
 
-export const debugPolen = Debug.create(`polen`)
+export const debug = Debug.create(`polen`)

package/src/template/components/ArgumentAnnotation.tsx

@@ -1,7 +1,7 @@
 import { Box, Flex, Text } from '@radix-ui/themes'
 import type { GraphQLArgument } from 'graphql'
 import type { FC } from 'react'
-import { TypeAnnotation } from './TypeAnnotation.js'
+import { TypeAnnotation } from './TypeAnnotation.jsx'
 
 export interface Props {
   data: GraphQLArgument

package/src/template/components/ArgumentList.tsx

@@ -1,7 +1,7 @@
 import { Box, Flex, Heading, Text } from '@radix-ui/themes'
 import type { GraphQLArgument } from 'graphql'
 import type { FC } from 'react'
-import { TypeAnnotation } from './TypeAnnotation.tsx'
+import { TypeAnnotation } from './TypeAnnotation.jsx'
 
 export interface Props {
   args: readonly GraphQLArgument[]

package/src/template/components/ArgumentListAnnotation.tsx

@@ -2,8 +2,8 @@ import { GrafaidOld } from '#lib/grafaid-old/index'
 import { Box, Text } from '@radix-ui/themes'
 import type { GraphQLField } from 'graphql'
 import type { FC } from 'react'
-import { ArgumentAnnotation } from './ArgumentAnnotation.tsx'
-import { FieldList } from './FieldList.tsx'
+import { ArgumentAnnotation } from './ArgumentAnnotation.jsx'
+import { FieldList } from './FieldList.jsx'
 
 export interface Props {
   field: GraphQLField<any, any>

package/src/template/components/DeprecationReason.tsx

@@ -1,7 +1,7 @@
 import type { GrafaidOld } from '#lib/grafaid-old/index'
 import { Text } from '@radix-ui/themes'
 import type { FC } from 'react'
-import { Markdown } from './Markdown.tsx'
+import { Markdown } from './Markdown.jsx'
 
 export const DeprecationReason: FC<{ data: GrafaidOld.GraphQLField }> = ({ data }) => {
   if (!data.deprecationReason) return null

package/src/template/components/Description.tsx

@@ -1,6 +1,6 @@
 import { Text } from '@radix-ui/themes'
 import type { FC } from 'react'
-import { Markdown } from './Markdown.tsx'
+import { Markdown } from './Markdown.jsx'
 // import type { Grafaid } from '#lib/grafaid'
 import type { GrafaidOld } from '#lib/grafaid-old/index'
 import type { GraphQLNamedType } from 'graphql'