polen 0.8.0-next.8 → 0.8.0

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

@@ -0,0 +1,205 @@
+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.js'
+import type { Route, RouteFile } from './route.js'
+
+//
+// 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/scan.ts

@@ -1,7 +1,9 @@
-import { TinyGlobby } from '#dep/tiny-globby/index.js'
+import { TinyGlobby } from '#dep/tiny-globby/index'
+import { Tree } from '#lib/tree/index'
 import { Path, Str } from '@wollybeard/kit'
-import { type Diagnostic, lint } from './linter.js'
-import type { Route, RouteFile, RouteLogical } from './route.js'
+import { type Diagnostic, lint } from './linter.ts'
+import { type Route, type RouteFile, type RouteLogical, routeToPathExpression } from './route.ts'
+import { scanTree } from './scan-tree.ts'
 
 //
 //
@@ -15,6 +17,9 @@ const conventions = {
   index: {
     name: `index`,
   },
+  numberedPrefix: {
+    pattern: Str.pattern<{ groups: ['order', 'name'] }>(/^(?<order>\d+)[_-](?<name>.+)$/),
+  },
 }
 
 //
@@ -42,18 +47,21 @@ export const scan = async (parameters: {
   dir: string
   glob?: string
 }): Promise<ScanResult> => {
-  const { dir, glob = `**/*` } = parameters
+  // Use tree-based scanner
+  const treeResult = await scanTree(parameters)
 
-  const filePathStrings = await TinyGlobby.glob(glob, {
-    absolute: true,
-    cwd: dir,
-    onlyFiles: true,
+  // Flatten tree to get routes
+  const routes: Route[] = []
+  Tree.visit(treeResult.routeTree, (node) => {
+    if (node.value.type === 'file' && node.value.route) {
+      routes.push(node.value.route)
+    }
   })
 
-  const routes: Route[] = filePathStrings.map(filePath => filePathToRoute(filePath, dir))
-
+  // Apply linting
   const lintResult = lint(routes)
 
+  // Routes are already sorted by the tree structure
   return lintResult
 }
 
@@ -75,15 +83,22 @@ export const filePathToRoute = (filePathExpression: string, rootDir: string): Ro
 export const filePathToRouteLogical = (filePath: Path.Parsed): RouteLogical => {
   const dirPath = Str.split(Str.removeSurrounding(filePath.dir, Path.sep), Path.sep)
 
-  if (Str.isMatch(filePath.name, conventions.index.name)) {
+  // Parse numbered prefix from filename
+  const prefixMatch = Str.match(filePath.name, conventions.numberedPrefix.pattern)
+  const order = prefixMatch ? parseInt(prefixMatch.groups.order, 10) : undefined
+  const nameWithoutPrefix = prefixMatch?.groups.name ?? filePath.name
+
+  if (nameWithoutPrefix === conventions.index.name) {
     const path = dirPath
     return {
       path,
+      order,
     }
   }
 
-  const path = dirPath.concat(filePath.name)
+  const path = dirPath.concat(nameWithoutPrefix)
   return {
     path,
+    order,
   }
 }

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

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

@@ -0,0 +1,123 @@
+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',
+        isNavToo: false,
+      })
+      expect(section!.navs).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',
+        isNavToo: true, // Should be true because of index file
+      })
+      expect(section!.navs).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!.navs).toHaveLength(3) // intro + 2 from advanced subdirectory
+
+      const navTitles = guideSection!.navs.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

@@ -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, RouteTreeNodeValue } 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 navs: ItemLink[] = []
+  const sections: ItemSection[] = []
+
+  // Process only the children of the root node
+  for (const child of routeTree.children) {
+    processNode(child, basePath, [], navs, sections)
+  }
+
+  const items = [...navs, ...sections]
+
+  return {
+    items,
+  }
+}
+
+const processNode = (
+  node: RouteTreeNode,
+  basePath: FileRouter.Path,
+  parentPath: string[],
+  navs: 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,
+      isNavToo: false,
+      navs: [],
+    }
+
+    // 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.isNavToo = true
+    }
+
+    // Process all non-index children as navs 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.navs.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.navs)
+      }
+    }
+
+    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') {
+      navs.push(routeToItemLink(node.value.route, basePath))
+    }
+  }
+}
+
+const collectFilesFromDirectory = (
+  node: RouteTreeNode,
+  basePath: FileRouter.Path,
+  navs: 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)
+      navs.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
+  isNavToo: boolean
+  navs: ItemLink[]
+}

package/src/lib/grafaid/_Nodes.ts

@@ -1 +1 @@
-export * as Nodes from './document.js'
+export * as Nodes from './document.ts'

package/src/lib/grafaid/document/OperationTypeNode.ts

@@ -5,4 +5,4 @@
 import type { OperationTypeNode as GraphQLOperationTypeNode } from 'graphql'
 
 export type OperationTypeNode = GraphQLOperationTypeNode
-export * as OperationTypeNode from './OperationTypeNodes.js'
+export * as OperationTypeNode from './OperationTypeNodes.ts'

package/src/lib/grafaid/document/kind.ts

@@ -4,6 +4,6 @@
 
 import type { Kind as GraphQLKind } from 'graphql'
 
-export * as Kind from './kinds.js'
+export * as Kind from './kinds.ts'
 
 export type Kind = GraphQLKind

package/src/lib/grafaid/document.ts

@@ -24,10 +24,10 @@ import {
   type VariableNode,
 } from 'graphql'
 import type { HasRequiredKeys } from 'type-fest'
-import { Kind } from './document/kind.js'
-import { OperationTypeNode } from './document/OperationTypeNode.js'
-// import type { RequestDocumentNodeInput } from './request.js'
-export { OperationType } from './schema/OperationType/__.js'
+import { Kind } from './document/kind.ts'
+import { OperationTypeNode } from './document/OperationTypeNode.ts'
+// import type { RequestDocumentNodeInput } from './request.ts'
+export { OperationType } from './schema/OperationType/__.ts'
 
 export type {
   ArgumentNode,
@@ -55,9 +55,9 @@ export type {
   VariableNode,
 } from 'graphql'
 
-export { OperationTypeNode } from './document/OperationTypeNode.js'
+export { OperationTypeNode } from './document/OperationTypeNode.ts'
 
-export { Kind } from './document/kind.js'
+export { Kind } from './document/kind.ts'
 
 export type $Any =
   | DirectiveNode

package/src/lib/grafaid/grafaid.ts

@@ -1,4 +1,4 @@
-export * as Document from './document.js'
-export * from './graphql.js'
-export * as HTTP from './http/http.js'
-export * as Schema from './schema/schema.js'
+export * as Document from './document.ts'
+export * from './graphql.ts'
+export * as HTTP from './http/http.ts'
+export * as Schema from './schema/schema.ts'

package/src/lib/grafaid/graphql.ts

@@ -1,8 +1,8 @@
 import { neverCase } from '@wollybeard/kit/language'
 import type { GraphQLNamedType, GraphQLScalarType } from 'graphql'
 import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, isScalarType, isUnionType } from 'graphql'
-import type { KindMap } from './schema/schema.js'
-import { isScalarTypeCustom } from './schema/schema.js'
+import type { KindMap } from './schema/schema.ts'
+import { isScalarTypeCustom } from './schema/schema.ts'
 
 export {
   type ExecutionResult,
@@ -11,7 +11,7 @@ export {
   type GraphQLFormattedError as FormattedExecutionResultError,
 } from 'graphql'
 
-export * from './_Nodes.js'
+export * from './_Nodes.ts'
 
 export const StandardScalarTypeNames = {
   String: `String`,

package/src/lib/grafaid/http/__.ts

@@ -1 +1 @@
-export * as GraphQLHTTP from './http.js'
+export * as GraphQLHTTP from './http.ts'

package/src/lib/grafaid/http/http.ts

@@ -1,5 +1,5 @@
 import type { FormattedExecutionResult, GraphQLFormattedError } from 'graphql'
-// import { CONTENT_TYPE_GQL, CONTENT_TYPE_JSON } from '../../http.js'
+// import { CONTENT_TYPE_GQL, CONTENT_TYPE_JSON } from '../../http.ts'
 import { Rec } from '@wollybeard/kit'
 
 export interface RequestConfig {

package/src/lib/grafaid/index.ts

@@ -1 +1 @@
-export * as Grafaid from './grafaid.js'
+export * as Grafaid from './grafaid.ts'

package/src/lib/grafaid/schema/KindMap/_.ts

@@ -1,10 +1,10 @@
 import type { GraphQLInterfaceType } from 'graphql'
-import { getRootTypeMap } from '../RootTypeMap.js'
-import type { Schema } from '../schema.js'
-import * as Type from '../type.js'
-import { isRoot } from '../type.js'
-import { isScalarTypeCustom } from '../typeGuards.js'
-import type { KindMap } from './__.js'
+import { getRootTypeMap } from '../RootTypeMap.ts'
+import type { Schema } from '../schema.ts'
+import * as Type from '../type.ts'
+import { isRoot } from '../type.ts'
+import { isScalarTypeCustom } from '../typeGuards.ts'
+import type { KindMap } from './__.ts'
 
 export const Name = {
   Root: `Root`,

package/src/lib/grafaid/schema/KindMap/__.ts

@@ -6,9 +6,9 @@ import type {
   GraphQLScalarType,
   GraphQLUnionType,
 } from 'graphql'
-import type { RootTypeMap } from '../RootTypeMap.js'
+import type { RootTypeMap } from '../RootTypeMap.ts'
 
-export * as KindMap from './_.js'
+export * as KindMap from './_.ts'
 
 export interface KindMap {
   root: RootTypeMap

package/src/lib/grafaid/schema/OperationType/__.ts

@@ -1,4 +1,4 @@
-import type { OperationTypeMutation, OperationTypeQuery, OperationTypeSubscription } from './_.js'
+import type { OperationTypeMutation, OperationTypeQuery, OperationTypeSubscription } from './_.ts'
 
-export * as OperationType from './_.js'
+export * as OperationType from './_.ts'
 export type OperationType = OperationTypeQuery | OperationTypeMutation | OperationTypeSubscription