polen 0.9.1-next.1 → 0.10.0-next.10

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

@@ -1,205 +0,0 @@
-import { TinyGlobby } from '#dep/tiny-globby/index'
-import { Tree, type TreeNode } from '#lib/tree/index'
-import { Path, Str } from '@wollybeard/kit'
-import type { Diagnostic } from './linter.ts'
-import type { Route, RouteFile } from './route.ts'
-
-//
-// Types
-//
-
-export type RouteTreeNodeType = 'directory' | 'file'
-
-export interface RouteTreeNodeValue {
-  name: string
-  order?: number
-  type: RouteTreeNodeType
-  route?: Route // Only present for file nodes
-}
-
-export type RouteTreeNode = TreeNode<RouteTreeNodeValue>
-
-export interface ScanTreeResult {
-  routeTree: RouteTreeNode
-  diagnostics: Diagnostic[]
-}
-
-//
-// Constants
-//
-
-const conventions = {
-  index: {
-    name: `index`,
-  },
-  numberedPrefix: {
-    pattern: Str.pattern<{ groups: ['order', 'name'] }>(/^(?<order>\d+)[_-](?<name>.+)$/),
-  },
-}
-
-//
-// Helpers
-//
-
-const parseSegment = (segment: string): { name: string; order?: number } => {
-  const match = Str.match(segment, conventions.numberedPrefix.pattern)
-  if (match) {
-    return {
-      name: match.groups.name,
-      order: parseInt(match.groups.order, 10),
-    }
-  }
-  return { name: segment }
-}
-
-const buildRouteTreeFromPaths = async (paths: string[], rootDir: string): Promise<RouteTreeNode> => {
-  // Root node (represents the pages directory itself)
-  const root = Tree.node<RouteTreeNodeValue>({
-    name: 'root',
-    type: 'directory',
-  })
-
-  // Process each file path
-  for (const filePath of paths) {
-    const relativePath = Path.relative(rootDir, filePath)
-
-    // Split the path into segments
-    const segments = relativePath.split(Path.sep).filter(s => s.length > 0)
-    if (segments.length === 0) continue // Skip root directory
-
-    // Navigate/create path in tree
-    let currentNode = root
-
-    for (let i = 0; i < segments.length; i++) {
-      const segment = segments[i]!
-      const isLast = i === segments.length - 1
-
-      // Parse segment for ordering
-      let segmentName = segment
-      // Strip extension for files
-      if (isLast && (segment.endsWith('.md') || segment.endsWith('.mdx'))) {
-        segmentName = segment.replace(/\.(md|mdx)$/, '')
-      }
-      const parsed = parseSegment(segmentName)
-
-      // Find existing child
-      const existingChildIndex = currentNode.children.findIndex(child => child.value.name === parsed.name)
-      let childNode = existingChildIndex >= 0 ? currentNode.children[existingChildIndex] : undefined
-
-      if (!childNode) {
-        // Create new node
-        if (isLast) {
-          // This is a file
-          const route = filePathToRoute(filePath, rootDir)
-          childNode = Tree.node<RouteTreeNodeValue>({
-            name: parsed.name,
-            order: parsed.order,
-            type: 'file',
-            route,
-          })
-        } else {
-          // This is a directory (implicit from file path)
-          childNode = Tree.node<RouteTreeNodeValue>({
-            name: parsed.name,
-            order: parsed.order,
-            type: 'directory',
-          })
-        }
-        currentNode.children.push(childNode)
-      } else if (isLast && childNode.value.type === 'file') {
-        // Handle collision for files with same name
-        // If new file has higher or equal order, replace the existing one (last wins for ties)
-        if (
-          parsed.order !== undefined
-          && (childNode.value.order === undefined || parsed.order >= childNode.value.order)
-        ) {
-          const route = filePathToRoute(filePath, rootDir)
-          const newNode = Tree.node<RouteTreeNodeValue>({
-            name: parsed.name,
-            order: parsed.order,
-            type: 'file',
-            route,
-          })
-          currentNode.children[existingChildIndex] = newNode
-          childNode = newNode
-        }
-        // Otherwise keep the existing node (when existing has higher order)
-      }
-
-      currentNode = childNode
-    }
-  }
-
-  // Sort the tree
-  return sortRouteTree(root)
-}
-
-const sortRouteTree = (tree: RouteTreeNode): RouteTreeNode => {
-  return Tree.sort(tree, (a, b) => {
-    // If both have orders, sort by order
-    if (a.order !== undefined && b.order !== undefined) {
-      return a.order - b.order
-    }
-    // If only one has order, it comes first
-    if (a.order !== undefined) return -1
-    if (b.order !== undefined) return 1
-    // Otherwise sort alphabetically
-    return a.name.localeCompare(b.name)
-  })
-}
-
-//
-// Main scan function
-//
-
-export const scanTree = async (parameters: {
-  dir: string
-  glob?: string
-}): Promise<ScanTreeResult> => {
-  const { dir, glob = `**/*` } = parameters
-
-  // Get all files
-  const filePaths = await TinyGlobby.glob(glob, {
-    absolute: true,
-    cwd: dir,
-    onlyFiles: true,
-  })
-
-  // Build tree structure (directories will be created implicitly)
-  const routeTree = await buildRouteTreeFromPaths(filePaths, dir)
-
-  // TODO: Implement tree-based linting
-  const diagnostics: Diagnostic[] = []
-
-  return {
-    routeTree,
-    diagnostics,
-  }
-}
-
-// Reuse existing route creation logic
-const filePathToRoute = (filePathExpression: string, rootDir: string): Route => {
-  const file: RouteFile = {
-    path: {
-      absolute: Path.parse(filePathExpression),
-      relative: Path.parse(Path.relative(rootDir, filePathExpression)),
-    },
-  }
-
-  const dirPath = Str.split(Str.removeSurrounding(file.path.relative.dir, Path.sep), Path.sep)
-
-  // Parse numbered prefix from filename
-  const prefixMatch = file.path.relative.name.match(conventions.numberedPrefix.pattern)
-  const order = prefixMatch?.groups?.[`order`] ? parseInt(prefixMatch.groups[`order`], 10) : undefined
-  const nameWithoutPrefix = prefixMatch?.groups?.[`name`] ?? file.path.relative.name
-
-  const logical = {
-    path: nameWithoutPrefix === conventions.index.name ? dirPath : dirPath.concat(nameWithoutPrefix),
-    order,
-  }
-
-  return {
-    logical,
-    file,
-  }
-}

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

@@ -1,3 +0,0 @@
-export * as SidebarTree from './sidebar-tree.ts'
-// Re-export SidebarTree as Sidebar for backward compatibility
-export * as Sidebar from './sidebar-tree.ts'

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

@@ -1,123 +0,0 @@
-import { Tree } from '#lib/tree/index'
-import { describe, expect, test } from 'vitest'
-import type { RouteTreeNode, RouteTreeNodeValue } from '../scan-tree.ts'
-import { buildFromTree } from './sidebar-tree.ts'
-
-// Helper to create mock routes
-const mockRoute = (path: string[]) => ({
-  logical: { path },
-  file: {
-    path: {
-      absolute: { root: '/', dir: '/', base: 'file.md', ext: '.md', name: 'file' },
-      relative: { root: '', dir: '', base: 'file.md', ext: '.md', name: 'file' },
-    },
-  },
-})
-
-// Helper to create file node
-const fileNode = (name: string, route: any): RouteTreeNode =>
-  Tree.node<RouteTreeNodeValue>({ name, type: 'file', route })
-
-// Helper to create directory node
-const dirNode = (name: string, children: RouteTreeNode[] = []): RouteTreeNode =>
-  Tree.node<RouteTreeNodeValue>({ name, type: 'directory' }, children)
-
-describe('sidebar-tree', () => {
-  test('builds sidebar from simple tree', () => {
-    const tree = dirNode('root', [
-      fileNode('getting-started', mockRoute(['getting-started'])),
-      dirNode('guide', [
-        fileNode('introduction', mockRoute(['guide', 'introduction'])),
-        fileNode('basics', mockRoute(['guide', 'basics'])),
-      ]),
-    ])
-
-    const sidebar = buildFromTree(tree, [])
-
-    expect(sidebar.items).toHaveLength(2)
-    expect(sidebar.items[0]).toMatchObject({
-      type: 'ItemLink',
-      pathExp: 'getting-started',
-      title: 'Getting Started',
-    })
-    const section = sidebar.items[1]
-    expect(section).toBeDefined()
-    expect(section!.type).toBe('ItemSection')
-    if (section!.type === 'ItemSection') {
-      expect(section).toMatchObject({
-        type: 'ItemSection',
-        title: 'Guide',
-        pathExp: 'guide',
-        isLinkToo: false,
-      })
-      expect(section!.links).toHaveLength(2)
-    }
-  })
-
-  test('handles index files correctly', () => {
-    const tree = dirNode('root', [
-      dirNode('guide', [
-        fileNode('index', mockRoute(['guide'])),
-        fileNode('introduction', mockRoute(['guide', 'introduction'])),
-      ]),
-    ])
-
-    const sidebar = buildFromTree(tree, [])
-
-    expect(sidebar.items).toHaveLength(1)
-    const section = sidebar.items[0]
-    expect(section).toBeDefined()
-    expect(section!.type).toBe('ItemSection')
-    if (section!.type === 'ItemSection') {
-      expect(section).toMatchObject({
-        type: 'ItemSection',
-        title: 'Guide',
-        pathExp: 'guide',
-        isLinkToo: true, // Should be true because of index file
-      })
-      expect(section!.links).toHaveLength(1) // Only introduction, not index
-    }
-  })
-
-  test('respects node ordering from tree', () => {
-    const tree = dirNode('root', [
-      Tree.node<RouteTreeNodeValue>({ name: 'quickstart', order: 5, type: 'file', route: mockRoute(['quickstart']) }),
-      Tree.node<RouteTreeNodeValue>({ name: 'guide', order: 10, type: 'file', route: mockRoute(['guide']) }),
-      fileNode('api', mockRoute(['api'])),
-      fileNode('troubleshooting', mockRoute(['troubleshooting'])),
-    ])
-
-    const sidebar = buildFromTree(tree, [])
-
-    // Tree should already be sorted, so sidebar should maintain that order
-    const titles = sidebar.items.map(item => item.title)
-    expect(titles).toEqual(['Quickstart', 'Guide', 'Api', 'Troubleshooting'])
-  })
-
-  test('handles nested directories', () => {
-    const tree = dirNode('root', [
-      dirNode('guide', [
-        fileNode('intro', mockRoute(['guide', 'intro'])),
-        dirNode('advanced', [
-          fileNode('performance', mockRoute(['guide', 'advanced', 'performance'])),
-          fileNode('optimization', mockRoute(['guide', 'advanced', 'optimization'])),
-        ]),
-      ]),
-    ])
-
-    const sidebar = buildFromTree(tree, [])
-
-    expect(sidebar.items).toHaveLength(1)
-    const guideSection = sidebar.items[0]
-    expect(guideSection).toBeDefined()
-    expect(guideSection!.type).toBe('ItemSection')
-    if (guideSection!.type === 'ItemSection') {
-      expect(guideSection!.links).toHaveLength(3) // intro + 2 from advanced subdirectory
-
-      const navTitles = guideSection!.links.map(nav => nav.title)
-      expect(navTitles).toContain('Intro')
-      expect(navTitles).toContain('Performance')
-      expect(navTitles).toContain('Optimization')
-    }
-  })
-})

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