polen 0.8.0-next.9 → 0.8.0

package/src/lib/kit-temp.ts

@@ -13,6 +13,7 @@
 //
 
 import { Fs, Path, Undefined } from '@wollybeard/kit'
+import type { ResolveHookContext } from 'node:module'
 
 export const arrayEquals = (a: any[], b: any[]) => {
   if (a.length !== b.length) return false
@@ -49,3 +50,12 @@ export const pickFirstPathExisting = async (paths: string[]): Promise<string | u
   const checks = await Promise.all(paths.map(path => Fs.exists(path).then(exists => exists ? path : undefined)))
   return checks.find(maybePath => maybePath !== undefined)
 }
+
+export const isSpecifierFromPackage = (specifier: string, packageName: string): boolean => {
+  return specifier === packageName || specifier.startsWith(packageName + `/`)
+}
+
+export interface ImportEvent {
+  specifier: string
+  context: ResolveHookContext
+}

package/src/lib/react-router-aid/get-paths-patterns.ts

@@ -1,4 +1,4 @@
-import type { ReactRouter } from '#dep/react-router/index.js'
+import type { ReactRouter } from '#dep/react-router/index'
 
 const sep = `/`
 

package/src/lib/react-router-aid/index.ts

@@ -1 +1 @@
-export * as ReactRouterAid from './react-router-aid.js'
+export * as ReactRouterAid from './react-router-aid.ts'

package/src/lib/react-router-aid/react-router-aid.ts

@@ -1,7 +1,7 @@
-import type { ReactRouter } from '#dep/react-router/index.js'
+import type { ReactRouter } from '#dep/react-router/index'
 import type { Http } from '@wollybeard/kit'
 
-export * from './get-paths-patterns.js'
+export * from './get-paths-patterns.ts'
 
 export type RouteObject = RouteObjectIndex | RouteObjectNonIndex
 

package/src/lib/react-router-loader/react-router-loader.ts

@@ -1,6 +1,6 @@
 import type { Fn } from '@wollybeard/kit'
 import { useLoaderData as useLoaderDataRR, useRouteLoaderData as useRouteLoaderDataRR } from 'react-router'
-import { superjson } from '../../singletons/superjson.js'
+import { superjson } from '../../singletons/superjson.ts'
 
 type Loader = Fn.AnyAny
 

package/src/lib/stack-processor/index.ts

@@ -1 +1 @@
-export * as StackProcessor from './stack-processor.js'
+export * as StackProcessor from './stack-processor.ts'

package/src/lib/superjson-codec/codec.ts

@@ -1,4 +1,4 @@
-import type { Superjson } from '#dep/superjson/index.js'
+import type { Superjson } from '#dep/superjson/index'
 import type { Json } from '@wollybeard/kit'
 
 export interface Codec<I, O extends Json.Value> {

package/src/lib/superjson-codec/codecs/graphql-schema.ts

@@ -1,5 +1,5 @@
-import { Grafaid } from '#lib/grafaid/index.js'
-import { create } from '../codec.js'
+import { Grafaid } from '#lib/grafaid/index'
+import { create } from '../codec.ts'
 
 export const GraphQLSchema = create({
   name: `GraphQLSchema`,

package/src/lib/superjson-codec/exports.ts

@@ -1,2 +1,2 @@
-export * from './codec.js'
-export * from './codecs/graphql-schema.js'
+export * from './codec.ts'
+export * from './codecs/graphql-schema.ts'

package/src/lib/superjson-codec/index.ts

@@ -1 +1 @@
-export * as SuperjsonCodecs from './exports.js'
+export * as SuperjsonCodecs from './exports.ts'

package/src/lib/tree/index.ts

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

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

@@ -0,0 +1,117 @@
+import { describe, expect, test } from 'vitest'
+import * as Tree from './tree.js'
+
+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/lib/vite-plugin-config/vite-plugin-config.ts

@@ -1,4 +1,4 @@
-import type { Vite } from '#dep/vite/index.js'
+import type { Vite } from '#dep/vite/index'
 
 export const ViteConfig = (config: Vite.UserConfig): Vite.Plugin => {
   return {

package/src/lib/vite-plugin-mdx/index.ts

@@ -1,2 +1 @@
-// export { VitePluginMdx as mdxRolldown } from './vite-plugin-mdx.js'
-// export type { Options as MdxOptions } from './vite-plugin-mdx.js'
+export * from './vite-plugin-mdx.ts'

package/src/lib/vite-plugin-mdx/vite-plugin-mdx.ts

@@ -1,81 +1,91 @@
 // TODO: use this or similar once transform hook can change module type and have result re-processed
 // @see  https://github.com/rolldown/rolldown/issues/4004
+// Note: This is adapted from `@mdx-js/mdx`
 
-// import type { CompileOptions } from '@mdx-js/mdx'
-// import {
-//   createFormatAwareProcessors,
-//   type FormatAwareProcessors,
-// } from '@mdx-js/mdx/internal-create-format-aware-processors'
-// import { createFilter, type FilterPattern } from '@rollup/pluginutils'
-// import type { SourceDescription } from 'rolldown'
-// import { SourceMapGenerator } from 'source-map'
-// import { VFile } from 'vfile'
-// import type { Plugin } from 'vite'
+import type { CompileOptions } from '@mdx-js/mdx'
+import {
+  createFormatAwareProcessors,
+  type FormatAwareProcessors,
+} from '@mdx-js/mdx/internal-create-format-aware-processors'
+import { createFilter, type FilterPattern } from '@rollup/pluginutils'
+import type { SourceDescription } from 'rolldown'
+import { SourceMapGenerator } from 'source-map'
+import { VFile } from 'vfile'
+import type { Plugin } from 'vite'
 
-// type ApplicableOptions = Omit<CompileOptions, `SourceMapGenerator`>
+type ApplicableOptions = Omit<CompileOptions, `SourceMapGenerator`>
 
-// interface ExtraOptions {
-//   /**
-//    * Picomatch patterns to exclude (optional).
-//    */
-//   exclude?: FilterPattern | null | undefined
-//   /**
-//    * Picomatch patterns to include (optional).
-//    */
-//   include?: FilterPattern | null | undefined
-// }
+interface ExtraOptions {
+  /**
+   * Picomatch patterns to exclude (optional).
+   */
+  exclude?: FilterPattern | null | undefined
+  /**
+   * Picomatch patterns to include (optional).
+   */
+  include?: FilterPattern | null | undefined
+}
 
-// export type Options = ApplicableOptions & ExtraOptions
+export type Options = ApplicableOptions & ExtraOptions
 
-// /**
-//  * Plugin to compile MDX w/ rolldown.
-//  */
-// export function VitePluginMdx(options?: Readonly<Options> | null): Plugin {
-//   const {
-//     exclude,
-//     include = /\.mdx?$/, // Default to .md and .mdx files
-//     ...rest
-//   } = options ?? {}
-//   let formatAwareProcessors: FormatAwareProcessors
-//   const filter = createFilter(include, exclude)
+// eslint-disable-next-line
+export const createConfig = (options?: Readonly<Options> | null | undefined): Options => {
+  const {
+    exclude,
+    include = /\.mdx?$/, // Default to .md and .mdx files
+    ...rest
+  } = options ?? {}
 
-//   return {
-//     name: `@mdx-js/rolldown`,
-//     enforce: `pre`, // Run before other transforms
-//     config(config, env) {
-//       // Initialize processors with Vite environment info
-//       formatAwareProcessors = createFormatAwareProcessors({
-//         SourceMapGenerator,
-//         development: env.mode === `development`,
-//         ...rest,
-//       })
-//     },
-//     async transform(value: string, id: string): Promise<SourceDescription | undefined> {
-//       // Ensure processors are initialized
-//       // if (!formatAwareProcessors) {
-//       //   formatAwareProcessors = createFormatAwareProcessors({
-//       //     SourceMapGenerator,
-//       //     ...rest,
-//       //   })
-//       // }
+  return {
+    exclude,
+    include,
+    ...rest,
+  }
+}
 
-//       const file = new VFile({ path: id, value })
+/**
+ * Plugin to compile MDX.
+ *
+ * Uses Rolldown.
+ */
+export function VitePluginMdx(options?: Readonly<Options> | null): Plugin {
+  const config = createConfig(options)
 
-//       if (
-//         file.extname
-//         && filter(file.path)
-//         && formatAwareProcessors.extnames.includes(file.extname)
-//       ) {
-//         const compiled = await formatAwareProcessors.process(file)
-//         const code = String(compiled.value)
-//         const result: SourceDescription = {
-//           code,
-//           // When MDX compiles to JS (not JSX), we don't need to set moduleType
-//           map: compiled.map,
-//         }
+  const filter = createFilter(config.include, config.exclude)
+  let formatAwareProcessors: FormatAwareProcessors
 
-//         return result
-//       }
-//     },
-//   }
-// }
+  return {
+    name: `mdx`,
+    // TODO: should not be needed?
+    // enforce: `pre`, // Run before other transforms
+    config(__config, env) {
+      // Initialize processors with Vite environment info
+      formatAwareProcessors = createFormatAwareProcessors({
+        SourceMapGenerator,
+        jsx: true, // emit JSX, not JS
+        development: env.mode === `development`,
+        ...config,
+      })
+    },
+    async transform(value: string, id: string): Promise<SourceDescription | undefined> {
+      const file = new VFile({ path: id, value })
+
+      if (
+        file.extname
+        && filter(file.path)
+        && formatAwareProcessors.extnames.includes(file.extname)
+      ) {
+        const compiled = await formatAwareProcessors.process(file)
+        const code = String(compiled.value)
+        const sourceDescription: SourceDescription = {
+          code,
+          moduleType: `jsx`,
+          // When MDX compiles to JS (not JSX), we don't need to set moduleType
+          map: compiled.map,
+        }
+
+        return sourceDescription
+      }
+    },
+  }
+}

package/src/lib/vite-plugins/index.ts

@@ -1,4 +1,4 @@
 /**
  * Export unified VitePlugins namespace
  */
-export * as VitePlugins from './vite-plugins.js'
+export * as VitePlugins from './vite-plugins.ts'

package/src/lib/vite-plugins/vite-plugins.ts

@@ -1 +1 @@
-export * from './build-logger.js'
+export * from './build-logger.ts'

package/src/lib/vite-virtual/debug.ts

@@ -0,0 +1,3 @@
+import { Debug } from '#lib/debug/index'
+
+export const debug = Debug.create(`vite-virtual`)

package/src/lib/vite-virtual/hooks.ts

@@ -1,4 +1,4 @@
-import type { Vite } from '#dep/vite/index.js'
+import type { Vite } from '#dep/vite/index'
 
 export type HookLoad = Vite.HookLoadFnPure
 

package/src/lib/vite-virtual/identified-loader.ts

@@ -1,8 +1,8 @@
-import type { Vite } from '#dep/vite/index.js'
-import { debug } from '../debug/debug.js'
-import { StackProcessor } from '../stack-processor/index.js'
-import type { HookLoad, HookResolveId } from './hooks.js'
-import type { Identifier } from './identifier.js'
+import type { Vite } from '#dep/vite/index'
+import { StackProcessor } from '../stack-processor/index.ts'
+import { debug } from './debug.ts'
+import type { HookLoad, HookResolveId } from './hooks.ts'
+import type { Identifier } from './identifier.ts'
 
 export interface IdentifiedLoader {
   identifier: Identifier

package/src/lib/vite-virtual/identifier.ts

@@ -1,4 +1,4 @@
-import { createId, markNoPlugins, normalizeId } from './id.js'
+import { createId, markNoPlugins, normalizeId } from './id.ts'
 
 export interface Options {
   /**

package/src/lib/vite-virtual/index.ts

@@ -1 +1 @@
-export * as ViteVirtual from './vite-virtual.js'
+export * as ViteVirtual from './vite-virtual.ts'

package/src/lib/vite-virtual/vite-virtual.ts

@@ -1,3 +1,3 @@
-export * as Id from './id.js'
-export * as IdentifiedLoader from './identified-loader.js'
-export * as Identifier from './identifier.js'
+export * as Id from './id.ts'
+export * as IdentifiedLoader from './identified-loader.ts'
+export * as Identifier from './identifier.ts'

package/src/package-paths.ts

@@ -1,7 +1,14 @@
 import { Path } from '@wollybeard/kit'
 
 export interface PackagePaths {
+  name: string
+  isRunningFromSource: boolean
+  static: {
+    source: string
+    build: string
+  }
   rootDir: string
+  sourceExtension: `.js` | `.ts`
   sourceDir: string
   template: {
     rootDir: string
@@ -15,14 +22,28 @@ export interface PackagePaths {
   }
 }
 
+const sourceDirRelativeExp = `src`
+const buildDirRelativeExp = `build`
+
 /**
- * Usually ./build but if running with tsx then ./src
+ * Usually ./build but if running source then ./src
  */
 const sourceDir = import.meta.dirname
 const templateDir = Path.join(sourceDir, `template`)
 const rootDir = Path.join(sourceDir, `..`)
 
+const isRunningFromSource = sourceDir.endsWith(sourceDirRelativeExp)
+
+const sourceKind = isRunningFromSource ? `.ts` : `.js`
+
 export const packagePaths: PackagePaths = {
+  name: `polen`,
+  isRunningFromSource,
+  static: {
+    source: sourceDir,
+    build: buildDirRelativeExp,
+  },
+  sourceExtension: sourceKind,
   rootDir: rootDir,
   sourceDir,
   template: {