polen 0.10.0-next.4 → 0.10.0-next.5

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

@@ -1,110 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/tree/index.ts

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

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

@@ -1,117 +0,0 @@
-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

@@ -1,183 +0,0 @@
-/**
- * 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
-}