polen 0.8.0-next.9 → 0.8.0

package/src/api/vite/plugins/pages-tree.ts

@@ -0,0 +1,186 @@
+import type { Config } from '#api/config/index'
+import { polenVirtual } from '#api/vite/vi'
+import type { Vite } from '#dep/vite/index'
+import { reportDiagnostics } from '#lib/file-router/diagnostic-reporter'
+import { FileRouter } from '#lib/file-router/index'
+import { ViteVirtual } from '#lib/vite-virtual/index'
+import { debug } from '#singletons/debug'
+import mdx from '@mdx-js/rollup'
+import { Path, Str } from '@wollybeard/kit'
+import remarkGfm from 'remark-gfm'
+
+const _debug = debug.sub(`vite-plugin-pages-tree`)
+
+export const viProjectPages = polenVirtual([`project`, `pages.jsx`], { allowPluginProcessing: true })
+
+export interface PagesTreePluginOptions {
+  config: Config.Config
+  onPagesChange?: (pages: FileRouter.ScanResult) => void
+  onTreeChange?: (tree: FileRouter.RouteTreeNode) => void
+}
+
+/**
+ * Pages plugin with tree support
+ */
+export const createPagesTreePlugin = (
+  { config, onPagesChange, onTreeChange }: PagesTreePluginOptions,
+): Vite.Plugin[] => {
+  // State management
+  let pagesCache: FileRouter.ScanResult | null = null
+  let treeCache: FileRouter.RouteTreeNode | null = null
+
+  // Helper functions
+  const scanPages = async () => {
+    if (!pagesCache) {
+      _debug(`Scanning pages - cache is null, loading fresh data`)
+      pagesCache = await FileRouter.scan({
+        dir: config.paths.project.absolute.pages,
+        glob: `**/*.{md,mdx}`,
+      })
+      _debug(`Found ${String(pagesCache.routes.length)} pages`)
+    } else {
+      _debug(`Using cached pages`)
+    }
+    return pagesCache
+  }
+
+  const scanTree = async () => {
+    if (!treeCache) {
+      _debug(`Scanning tree - cache is null, loading fresh data`)
+      const result = await FileRouter.scanTree({
+        dir: config.paths.project.absolute.pages,
+        glob: `**/*.{md,mdx}`,
+      })
+      treeCache = result.routeTree
+      _debug(`Built route tree`)
+    } else {
+      _debug(`Using cached tree`)
+    }
+    return treeCache
+  }
+
+  const clearCache = () => {
+    _debug(`Clearing pages and tree cache`)
+    pagesCache = null
+    treeCache = null
+  }
+
+  const isPageFile = (file: string) => {
+    return (file.endsWith(`.md`) || file.endsWith(`.mdx`))
+      && file.includes(config.paths.project.absolute.pages)
+  }
+
+  const generatePagesModule = (pagesScanResult: FileRouter.ScanResult): string => {
+    const $ = {
+      pages: `pages`,
+    }
+
+    const s = Str.Builder()
+    s`export const ${$.pages} = []`
+
+    // Generate imports and route objects
+    for (const route of pagesScanResult.routes) {
+      const filePathExp = Path.format(route.file.path.absolute)
+      const pathExp = FileRouter.routeToPathExpression(route)
+      const ident = Str.Case.camel(`page ` + Str.titlizeSlug(pathExp))
+
+      s`
+        import ${ident} from '${filePathExp}'
+
+        ${$.pages}.push({
+          path: '${pathExp}',
+          Component: ${ident}
+        })
+      `
+    }
+
+    return s.render()
+  }
+
+  return [
+    // Plugin 1: MDX Processing
+    {
+      enforce: `pre` as const,
+      ...mdx({
+        jsxImportSource: `polen/react`,
+        remarkPlugins: [remarkGfm],
+      }),
+    },
+
+    // Plugin 2: Pages Management
+    {
+      name: `polen:pages-tree`,
+
+      // Dev server configuration
+      configureServer(server) {
+        // Add pages directory to watcher
+        _debug(`Adding pages directory to watcher:`, config.paths.project.absolute.pages)
+        server.watcher.add(config.paths.project.absolute.pages)
+      },
+
+      // Hot update handling
+      async handleHotUpdate({ file, server }) {
+        if (!isPageFile(file)) return
+
+        _debug(`Page file changed:`, file)
+
+        // Clear cache
+        clearCache()
+
+        // Invalidate virtual module
+        const mod = server.moduleGraph.getModuleById(viProjectPages.resolved)
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod)
+          _debug(`Invalidated pages virtual module`)
+        }
+
+        // Notify about pages change (for other plugins that depend on pages)
+        if (onPagesChange) {
+          const pages = await scanPages()
+          // Report any diagnostics
+          reportDiagnostics(pages.diagnostics)
+          onPagesChange(pages)
+        }
+
+        // Notify about tree change
+        if (onTreeChange) {
+          const tree = await scanTree()
+          onTreeChange(tree)
+        }
+
+        // Trigger full reload
+        server.ws.send({ type: `full-reload` })
+
+        return []
+      },
+
+      // Virtual module handling
+      ...ViteVirtual.IdentifiedLoader.toHooks({
+        identifier: viProjectPages,
+        async loader() {
+          _debug(`Loading viProjectPages virtual module`)
+          const pagesScanResult = await scanPages()
+          const tree = await scanTree()
+
+          // Report any diagnostics
+          reportDiagnostics(pagesScanResult.diagnostics)
+
+          // Notify about pages (useful for initial load)
+          onPagesChange?.(pagesScanResult)
+          onTreeChange?.(tree)
+
+          return generatePagesModule(pagesScanResult)
+        },
+      }),
+    },
+  ]
+}
+
+// Helper to get tree
+export const getRouteTree = async (config: Config.Config): Promise<FileRouter.RouteTreeNode> => {
+  const result = await FileRouter.scanTree({
+    dir: config.paths.project.absolute.pages,
+    glob: `**/*.{md,mdx}`,
+  })
+  return result.routeTree
+}

package/src/api/vite/plugins/serve.ts

@@ -1,28 +1,60 @@
-import type { Config } from '#api/config/index.js'
-import type { Hono } from '#dep/hono/index.js'
-import type { Vite } from '#dep/vite/index.js'
+import type { Config } from '#api/config/index'
+import type { Hono } from '#dep/hono/index'
+import type { Vite } from '#dep/vite/index'
+import { debug } from '#singletons/debug'
 import * as HonoNodeServer from '@hono/node-server'
+import { Err } from '@wollybeard/kit'
+
+type App = Hono.Hono
+
+interface AppServerModule {
+  app: App
+}
 
 export const Serve = (
   config: Config.Config,
 ): Vite.PluginOption => {
-  return {
-    name: `polen:serve`,
-    apply: `serve`,
-    async configureServer(server) {
-      let honoApp: Hono.Hono
+  let appPromise: Promise<App>
 
-      try {
-        const module = await server.ssrLoadModule(config.paths.framework.template.server.app) as { app: Hono.Hono }
-        honoApp = module.app
-      } catch (cause) {
-        if (cause instanceof Error) {
+  const reloadApp = async ({ server }: { server: Vite.ViteDevServer }): Promise<App> => {
+    debug('reloadApp')
+    return await server.ssrLoadModule(config.paths.framework.template.server.app)
+      .then(module => module as AppServerModule)
+      .then(module => module.app)
+      .catch(cause => {
+        if (Err.is(cause)) {
           server.ssrFixStacktrace(cause)
         }
         throw cause
-      }
+      })
+  }
 
-      // Add middleware that runs our entry server
+  return {
+    name: `polen:serve`,
+    apply: `serve`,
+    config() {
+      return {
+        server: {
+          port: 3000,
+          watch: {
+            disableGlobbing: false,
+          },
+          fs: {
+            strict: false, // bring back true, with the allow below might already work now
+            allow: [
+              config.paths.project.rootDir,
+            ],
+          },
+        },
+      }
+    },
+    handleHotUpdate({ server }) {
+      // Reload app server immediately in the background
+      appPromise = reloadApp({ server })
+    },
+    async configureServer(server) {
+      // Initial load
+      appPromise = reloadApp({ server })
 
       return () => {
         // Remove index.html serving middleware.
@@ -31,26 +63,17 @@ export const Serve = (
           server.middlewares.stack.findIndex(m => m.handle.name === `viteHtmlFallbackMiddleware`),
           1,
         )
+
+        // Add middleware that runs our entry server
         server.middlewares.use((req, res, ___next) => {
           void HonoNodeServer.getRequestListener(async request => {
-            // request.viteDevServer = server
-            const response = await honoApp.fetch(request, { viteDevServer: server })
+            // Always await the current app promise
+            const app = await appPromise
+            const response = await app.fetch(request, { viteDevServer: server })
             return response
           })(req, res)
         })
       }
     },
-    config() {
-      return {
-        server: {
-          fs: {
-            strict: false,
-            allow: [
-              // todo allow from polen
-            ],
-          },
-        },
-      }
-    },
   }
 }

package/src/api/vite/vi.ts

@@ -1,5 +1,5 @@
-import { ViteVirtual } from '#lib/vite-virtual/index.js'
+import { ViteVirtual } from '#lib/vite-virtual/index'
 
-export const vi = ViteVirtual.Identifier.createFactory({
+export const polenVirtual = ViteVirtual.Identifier.createFactory({
   namespace: `polen`,
 })

package/src/cli/_/self-contained-mode.ts

@@ -0,0 +1,85 @@
+import type { Vite } from '#dep/vite/index'
+import { type ImportEvent, isSpecifierFromPackage } from '#lib/kit-temp'
+import { packagePaths } from '#package-paths'
+import { debug } from '#singletons/debug'
+import type * as Module from 'node:module'
+import { fileURLToPath } from 'node:url'
+
+export interface SelfContainedModeHooksData {
+  projectDirPathExp: string
+}
+
+let data_: SelfContainedModeHooksData | undefined = undefined
+
+export function initialize(data: SelfContainedModeHooksData) {
+  data_ = data
+}
+
+export const resolve: Module.ResolveHook = async (specifier, context, nextResolve) => {
+  if (!data_) throw new Error(`Self-contained mode not initialized`)
+
+  const _debug = debug.sub(`node-module-hooks`)
+
+  const from: ImportEvent = {
+    specifier,
+    context,
+  }
+
+  if (
+    from.context.parentURL && checkIsSelfImportFromProject({
+      projectDirPathExp: data_.projectDirPathExp,
+      specifier,
+      importerPathExpOrFileUrlExp: from.context.parentURL,
+    })
+  ) {
+    _debug(`resolve check`, { specifier, context })
+
+    const to: ImportEvent = {
+      specifier: from.specifier,
+      context: {
+        conditions: [...from.context.conditions, `source`],
+        parentURL: import.meta.url,
+        importAttributes: from.context.importAttributes,
+      },
+    }
+
+    _debug(`resolve`, { from, to })
+
+    await nextResolve(to.specifier, to.context)
+  }
+
+  return nextResolve(specifier, context)
+}
+
+export const checkIsSelfImportFromProject = (input: {
+  specifier: string
+  importerPathExpOrFileUrlExp: string
+  projectDirPathExp: string
+}): boolean => {
+  // Not clear it would ever not be the case but we're being careful here.
+  // ...would be intersted to know if this is ever false.
+  const isImporterTheProject = input.importerPathExpOrFileUrlExp.includes(input.projectDirPathExp)
+
+  const isImportMe = isSpecifierFromPackage(input.specifier, packagePaths.name)
+
+  return isImporterTheProject && isImportMe
+}
+
+export const VitePluginSelfContainedMode = ({ projectDirPathExp }: { projectDirPathExp: string }): Vite.Plugin => {
+  const d = debug.sub(`vite-plugin:self-contained-import`)
+
+  return {
+    name: `polen:self-contained-import`,
+    resolveId(id, importer) {
+      const isSelfContainedImport = importer
+        && checkIsSelfImportFromProject({ projectDirPathExp, specifier: id, importerPathExpOrFileUrlExp: importer })
+      if (!isSelfContainedImport) return
+
+      const to = fileURLToPath(import.meta.resolve(id))
+
+      d(`did resolve`, { from: id, to })
+
+      return to
+    },
+  }
+}

package/src/cli/commands/build.ts

@@ -1,7 +1,7 @@
 /* eslint-disable */
 // @ts-nocheck
-import { Api } from '#api/index.js'
-import { Vite } from '#dep/vite/index.js'
+import { Api } from '#api/index'
+import { Vite } from '#dep/vite/index'
 import { Command } from '@molt/command'
 import { z } from 'zod'
 

package/src/cli/commands/dev.ts

@@ -1,12 +1,11 @@
 /* eslint-disable */
 // @ts-nocheck
-import { Api } from '#api/index.js'
-import { Vite } from '#dep/vite/index.js'
-import { ensureOptionalAbsolute, ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp.js'
+import { Api } from '#api/index'
+import { Vite } from '#dep/vite/index'
+import { ensureOptionalAbsolute, ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
 import { Command } from '@molt/command'
 import { Err, Path } from '@wollybeard/kit'
 import { z } from 'zod'
-// import { loadConfig } from '../../api/load-config.js'
 
 const args = Command.create()
   .parameter(

package/src/cli/commands/open.ts

@@ -8,10 +8,10 @@
  * polen open --sdl https://docs.github.com/public/fpt/schema.docs.graphql
  */
 
-import { Api } from '#api/index.js'
-import { Vite } from '#dep/vite/index.js'
-import { Grafaid } from '#lib/grafaid/index.js'
-import { GraphqlSchemaLoader } from '#lib/graphql-schema-loader/index.js'
+import { Api } from '#api/index'
+import { Vite } from '#dep/vite/index'
+import { Grafaid } from '#lib/grafaid/index'
+import { GraphqlSchemaLoader } from '#lib/graphql-schema-loader/index'
 import { Command } from '@molt/command'
 import type { Fn } from '@wollybeard/kit'
 import { Err, Fs, Json, Path, Rec } from '@wollybeard/kit'

package/src/dep/graphql-inspector/index.ts

@@ -1 +1 @@
-export * as GraphqlInspector from './graphql-inspector.js'
+export * as GraphqlInspector from './graphql-inspector.ts'

package/src/dep/hono/hono.ts

@@ -1,2 +1,2 @@
 export * from 'hono'
-export * from './ssg.js'
+export * from './ssg.ts'

package/src/dep/hono/index.ts

@@ -1 +1 @@
-export * as Hono from './hono.js'
+export * as Hono from './hono.ts'

package/src/dep/superjson/index.ts

@@ -1 +1 @@
-export * as Superjson from './superjson.js'
+export * as Superjson from './superjson.ts'

package/src/dep/tiny-globby/index.ts

@@ -1 +1 @@
-export * as TinyGlobby from './tiny-globby.js'
+export * as TinyGlobby from './tiny-globby.ts'

package/src/dep/vite/index.ts

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

package/src/exports/index.ts

@@ -1 +1 @@
-export * as Polen from './polen.js'
+export * as Polen from './polen.ts'

package/src/exports/polen.ts

@@ -1,3 +1,3 @@
-export { defineConfig } from '#api/config/config.js'
-export { type ConfigInput } from '#api/config/configurator.js'
-export { Main as VitePlugin } from '#api/vite/plugins/main.js'
+export { defineConfig } from '#api/config/config'
+export { type ConfigInput } from '#api/config/configurator'
+export { Main as VitePlugin } from '#api/vite/plugins/main'

package/src/lib/apple-touch-icon/index.ts

@@ -1 +1 @@
-export * as AppleTouchIcon from './apple-touch-icon.js'
+export * as AppleTouchIcon from './apple-touch-icon.ts'

package/src/lib/debug/debug.ts

@@ -1,21 +1,52 @@
+import { Arr, Str } from '@wollybeard/kit'
 import { colorize } from 'consola/utils'
-import { snakeCase } from 'es-toolkit'
 import { inspect } from 'node:util'
-import { calcIsEnabledFromEnv } from './environment-variable.js'
+import { calcIsEnabledFromEnv } from './environment-variable.ts'
 
 type DebugParameters = [event: string, payload?: unknown]
 
 export interface Debug {
   (...args: DebugParameters): void
   toggle: (isEnabled: boolean) => void
-  sub: (subNamespace: string) => Debug
+  sub: (subNamespace: string | string[]) => Debug
 }
 
 interface State {
   isEnabled: boolean
 }
 
-export const create = (namespace?: string, initialState?: State): Debug => {
+// todo:
+// const Option = {
+//   else:
+//     <alternative>(alternative: alternative) => <value>(value: value): value extends undefined ? alternative : value => {
+//       if (value === undefined || value === null) {
+//         return alternative as any
+//       }
+//       return value as any
+//     },
+// }
+
+// const namespaceToString = (namespace: string[] = []): string => {
+//   return formatNamespaceSegment(namespace.join(`_`))
+//   // todo:
+//   // const x = Option.else([] as string[])
+//   // const y = x(namespace)
+//   // const z = Fn.pipe(
+//   //   namespace,
+//   //   x,
+//   //   // Option.else([]),
+//   //   // (_) => Array.is(_) ? _ : [],
+//   //   // Str.joinWith(`_`),
+//   //   // Str.Case.upper,
+//   // )
+// }
+
+const formatNamespaceSegment = (segment: string): string => {
+  return Str.Case.snake(segment).toUpperCase()
+}
+
+export const create = (namespaceInput?: string | string[], initialState?: State): Debug => {
+  const namespace = Arr.sure(namespaceInput ?? [])
   const isDebugEnabledFromEnv = calcIsEnabledFromEnv(process.env, namespace)
 
   const state: State = initialState ?? {
@@ -43,20 +74,16 @@ export const create = (namespace?: string, initialState?: State): Debug => {
         })
         : ``
 
-      const namespaceRendered = namespace
-        ? colorize(
-          `bold`,
-          colorize(
-            `bgYellowBright`,
-            ` ` + snakeCase(namespace).toUpperCase() + ` `,
-          ),
-        )
-        : ``
+      const formatNamespaceSegmentAnsi = (segment: string): string => {
+        return colorize(`bold`, colorize(`bgYellowBright`, ` ` + formatNamespaceSegment(segment) + ` `))
+      }
+
+      const namespaceRendered = namespace.map(formatNamespaceSegmentAnsi).join(` `)
       const eventRendered = colorize(
         `bold`,
         colorize(
           `bgMagentaBright`,
-          ` ` + snakeCase(event).toUpperCase() + ` `,
+          ` ` + formatNamespaceSegment(event) + ` `,
         ),
       )
       const prefixRendered = `${namespaceRendered} ${eventRendered}`
@@ -69,10 +96,10 @@ export const create = (namespace?: string, initialState?: State): Debug => {
     state.isEnabled = isEnabled
   }
 
-  debug.sub = (subNamespace: string) => {
+  debug.sub = (subNamespace: string | string[]) => {
+    const s = Arr.sure(subNamespace)
     const stateCopy = structuredClone(state)
-    const fullNamespace = namespace ? `${namespace}:${subNamespace}` : subNamespace
-    return create(fullNamespace, stateCopy)
+    return create([...namespace, ...s], stateCopy)
   }
 
   return debug
@@ -90,4 +117,4 @@ const parseNumberOr = (str: string | undefined, defaultValue: number): number =>
 
 // initialize root debug
 
-export const debug = create()
+export const debugGlobal = create()

package/src/lib/debug/environment-variable.ts

@@ -1,18 +1,39 @@
+import { Arr, Language } from '@wollybeard/kit'
+
 export const enVarName = `DEBUG`
 
-export const enVarEnabledValuesStatic = [`true`, `*`, `1`]
+export const wildcard = `*`
+export const enVarEnabledValuesStatic = [`true`, wildcard, `1`]
 
 export const calcIsEnabledFromEnv = (
   enVars: Record<string, unknown>,
-  namespace?: string,
+  namespace?: string[],
 ): boolean => {
-  const enVar = typeof enVars[enVarName] === `string` ? enVars[enVarName].trim() : undefined
+  const namespace_ = namespace?.map(_ => _.toLowerCase())
+  const pattern = typeof enVars[enVarName] === `string`
+    ? enVars[enVarName]
+      .trim()
+      .toLowerCase()
+      .split(`:`)
+      .map(_ => _.trim())
+    : undefined
+
+  if (!pattern) return false
+
+  if (pattern.length === 1 && enVarEnabledValuesStatic.includes(pattern[0]!)) return true
 
-  if (!enVar) return false
+  if (!namespace_) return false
 
-  if (enVarEnabledValuesStatic.includes(enVar)) return true
+  if (Arr.getLast(pattern) !== wildcard) {
+    return pattern.join() === namespace_.join()
+  }
 
-  if (namespace) return enVar.startsWith(namespace)
+  let i = 0
+  for (const segment of pattern) {
+    if (segment === wildcard) return true
+    if (segment !== namespace_[i]) return false
+    i++
+  }
 
-  return false
+  Language.never()
 }

package/src/lib/debug/index.ts

@@ -1 +1 @@
-export * as Debug from './debug.js'
+export * as Debug from './debug.ts'

package/src/lib/errors/ContextualAggregateError.ts

@@ -1,5 +1,5 @@
 import { Arr } from '@wollybeard/kit'
-import { ContextualError } from './ContextualError.js'
+import { ContextualError } from './ContextualError.ts'
 
 /**
  * Aggregation Error enhanced with a context object and types members.

package/src/lib/errors/ContextualError.ts

@@ -1,4 +1,4 @@
-import type { Cause, Context } from './types.js'
+import type { Cause, Context } from './types.ts'
 
 /**
  * Error enhanced with a context object.

package/src/lib/errors/ErrorInternal.ts

@@ -1,5 +1,5 @@
-import { ContextualError } from './ContextualError.js'
-import type { Cause, Context } from './types.js'
+import { ContextualError } from './ContextualError.ts'
+import type { Cause, Context } from './types.ts'
 
 export class ErrorInternal<
   $Name extends string = `ErrorInternal`,

package/src/lib/errors/errors.ts

@@ -1,4 +1,4 @@
-export * from './ContextualAggregateError.js'
-export * from './ContextualError.js'
-export * from './ErrorInternal.js'
-export * from './types.js'
+export * from './ContextualAggregateError.ts'
+export * from './ContextualError.ts'
+export * from './ErrorInternal.ts'
+export * from './types.ts'

package/src/lib/errors/index.ts

@@ -1 +1 @@
-export * as Errors from './errors.js'
+export * as Errors from './errors.ts'

package/src/lib/errors/types.ts

@@ -1,4 +1,4 @@
-import type { ContextualError } from './ContextualError.js'
+import type { ContextualError } from './ContextualError.ts'
 
 export type Cause = Error | ContextualError
 export type Context = object