polen 0.10.0-next.13 → 0.10.0-next.15

package/src/api/schema/data-sources/schema-file/schema-file.ts

@@ -2,13 +2,32 @@ import { Grafaid } from '#lib/grafaid/index'
 import { GraphqlChange } from '#lib/graphql-change/index'
 import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 import { Path } from '@wollybeard/kit'
-import type { Schema } from '../../schema.ts'
+import type { Schema } from '../../schema.js'
 
 const defaultPaths = {
   schemaFile: `./schema.graphql`,
 }
 
+/**
+ * Configuration for loading schema from a single SDL file.
+ */
 export interface ConfigInput {
+  /**
+   * Path to the GraphQL SDL file.
+   *
+   * Can be absolute or relative to the project root.
+   *
+   * @default './schema.graphql'
+   *
+   * @example
+   * ```ts
+   * // Default location
+   * path: './schema.graphql'
+   *
+   * // Custom location
+   * path: './src/graphql/schema.sdl'
+   * ```
+   */
   path?: string
   projectRoot?: string
 }

package/src/api/schema/index.ts

@@ -1 +1 @@
-export * as Schema from './schema.ts'
+export * as Schema from './schema.js'

package/src/api/schema/read.ts

@@ -1,19 +1,60 @@
 import { Arr } from '@wollybeard/kit'
-import * as DataSources from './data-sources/data-sources.ts'
-import type { Schema } from './schema.ts'
+import * as DataSources from './data-sources/data-sources.js'
+import type { Schema } from './schema.js'
 
 export type DataSourceType = `file` | `directory` | `memory` | `data`
 
+/**
+ * Schema configuration for Polen.
+ */
 export interface Config {
   /**
+   * Whether to enable schema loading.
+   *
+   * Set to `false` to disable schema features entirely.
+   *
    * @default `true`
    */
   enabled?: boolean
+  /**
+   * Which data sources to use for loading schemas.
+   *
+   * - `file` - Load from a single SDL file
+   * - `directory` - Load multiple SDL files from a directory
+   * - `memory` - Use schemas defined in configuration
+   * - `data` - Use a pre-built schema object
+   *
+   * If not specified, Polen will try all sources in order until one succeeds.
+   *
+   * @example
+   * ```ts
+   * // Use only file source
+   * useDataSources: 'file'
+   *
+   * // Try multiple sources
+   * useDataSources: ['directory', 'file']
+   * ```
+   */
   useDataSources?: Arr.Maybe<DataSourceType>
+  /**
+   * Configuration for each data source type.
+   */
   dataSources?: {
+    /**
+     * Configuration for loading schema from a single SDL file.
+     */
     file?: DataSources.SchemaFile.ConfigInput
+    /**
+     * Configuration for loading multiple schema versions from a directory.
+     */
     directory?: DataSources.SchemaDirectory.ConfigInput
+    /**
+     * Configuration for defining schemas programmatically.
+     */
     memory?: DataSources.Memory.ConfigInput
+    /**
+     * Pre-built schema object to use directly.
+     */
     data?: Schema
   }
   projectRoot: string

package/src/api/schema/schema.ts

@@ -1,8 +1,8 @@
 import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 
-export * as DataSources from './data-sources/data-sources.ts'
+export * as DataSources from './data-sources/data-sources.js'
 
-export * from './read.ts'
+export * from './read.js'
 
 export interface Schema {
   versions: [GraphqlChangeset.ChangeSet, ...GraphqlChangeset.ChangeSet[]]

package/src/api/schema-augmentation/augmentations/description.ts

@@ -1,7 +1,7 @@
 import type { GrafaidOld } from '#lib/grafaid-old/index'
 import { neverCase } from '@wollybeard/kit/language'
-import type { Target } from '../target.ts'
-import { locateTargetField, locateTargetType } from '../target.ts'
+import type { Target } from '../target.js'
+import { locateTargetField, locateTargetType } from '../target.js'
 
 export const Placement = {
   Before: `before`,

package/src/api/schema-augmentation/index.ts

@@ -1 +1 @@
-export * as SchemaAugmentation from './schema-augmentation.ts'
+export * as SchemaAugmentation from './schema-augmentation.js'

package/src/api/schema-augmentation/schema-augmentation.ts

@@ -1,6 +1,6 @@
 import type { GrafaidOld } from '#lib/grafaid-old/index'
 import { neverCase } from '@wollybeard/kit/language'
-import * as AugmentationDescription from './augmentations/description.ts'
+import * as AugmentationDescription from './augmentations/description.js'
 
 export { AugmentationDescription }
 
@@ -12,7 +12,6 @@ export const apply = (
 ): GrafaidOld.Schema.Schema => {
   for (const augmentation of augmentations) {
     switch (augmentation.type) {
-      // eslint-disable-next-line
       case `description`: {
         AugmentationDescription.apply(schema, augmentation)
         break

package/src/api/server/report-error.ts

@@ -19,7 +19,7 @@ export const reportError = async (value: unknown): Promise<void> => {
   const snippets = createSnippets(parsedError)
 
   if (snippets) {
-    console.log('\n\n\n\n' + snippets)
+    console.log(`\n\n\n\n` + snippets)
   }
 }
 
@@ -27,15 +27,15 @@ const createSnippets = (parsedError: ParsedError) => {
   const snippets = parsedError.frames.map((frame) => {
     let snippet = createSnippet(frame)
 
-    snippet = frame.fileName + '\n' + frame.lineNumber + '\n\n' + snippet
+    snippet = frame.fileName + `\n` + frame.lineNumber + `\n\n` + snippet
     return snippet
-  }).join('\n\n----------------------------------------------------------------------------------\n\n')
+  }).join(`\n\n----------------------------------------------------------------------------------\n\n`)
   return snippets
 }
 
 const createSnippet = (stackFrame: StackFrame) => {
   const snippet = stackFrame.source?.map(line => {
-    return line.lineNumber.toString().padStart(4, ' ') + `: ` + line.chunk
+    return line.lineNumber.toString().padStart(4, ` `) + `: ` + line.chunk
   }).join(`\n`)
 
   return snippet
@@ -45,7 +45,9 @@ const createSnippet = (stackFrame: StackFrame) => {
 // pathFilter: Fn.compose(Str.isMatchWith(excludePattern), Bool.negate)
 const cleanStackRecursive = (value: unknown, excludePattern: RegExp) => {
   if (value instanceof AggregateError) {
-    value.errors.forEach((error) => cleanStackRecursive(error, excludePattern))
+    value.errors.forEach((error) => {
+      cleanStackRecursive(error, excludePattern)
+    })
   }
   // console.log(`Filtering path: ${path}`, isInclude ? 'Included' : 'Excluded')
   if (value instanceof Error) {

package/src/api/singletons/markdown/index.ts

@@ -1 +1 @@
-export * as Markdown from './markdown.ts'
+export * as Markdown from './markdown.js'

package/src/api/singletons/markdown/markdown.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from 'vitest'
-import { parse } from './markdown.ts'
+import { parse } from './markdown.js'
 
-describe(`markdown parser with syntax highlighting`, () => {
-  test(`parse highlights code blocks`, async () => {
+describe('markdown parser', () => {
+  test('parse converts code blocks', async () => {
     const markdown = `
 # Hello
 
@@ -13,17 +13,14 @@ console.log(x)
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`<h1>Hello</h1>`)
-    expect(result).toContain(`<pre`)
-    expect(result).toContain(`shiki`)
-    expect(result).toContain(`console`)
-    expect(result).toContain(`42`)
+    expect(result).toContain('<h1>Hello</h1>')
+    expect(result).toContain('<pre')
+    expect(result).toContain('<code class="language-javascript">')
+    expect(result).toContain('console')
+    expect(result).toContain('42')
   })
 
-  // Note: parseSync cannot be used with async rehype plugins like Shiki
-  // This is a known limitation - syntax highlighting requires async processing
-
-  test(`parse supports GraphQL syntax`, async () => {
+  test('parse supports GraphQL syntax', async () => {
     const markdown = `
 \`\`\`graphql
 type Query {
@@ -33,21 +30,20 @@ type Query {
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`type`)
-    expect(result).toContain(`Query`)
-    // Check that both ID and ! are present (they may be in separate spans)
-    expect(result).toContain(`> ID<`)
-    expect(result).toContain(`>!</`)
+    expect(result).toContain('<code class="language-graphql">')
+    expect(result).toContain('type Query')
+    expect(result).toContain('ID!')
+    expect(result).toContain('User')
   })
 
-  test(`parse handles inline code`, async () => {
-    const markdown = `This is \`inline code\` in a sentence.`
+  test('parse handles inline code', async () => {
+    const markdown = 'This is `inline code` in a sentence.'
     const result = await parse(markdown)
 
-    expect(result).toContain(`<code>inline code</code>`)
+    expect(result).toContain('<code>inline code</code>')
   })
 
-  test(`parse supports GitHub Flavored Markdown`, async () => {
+  test('parse supports GitHub Flavored Markdown', async () => {
     const markdown = `
 | Column 1 | Column 2 |
 |----------|----------|
@@ -58,12 +54,12 @@ type Query {
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`<table>`)
-    expect(result).toContain(`<input`)
-    expect(result).toContain(`checked`)
+    expect(result).toContain('<table>')
+    expect(result).toContain('<input')
+    expect(result).toContain('checked')
   })
 
-  test(`parse handles code blocks without language`, async () => {
+  test('parse handles code blocks without language', async () => {
     const markdown = `
 \`\`\`
 plain text without language
@@ -71,11 +67,11 @@ plain text without language
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`<pre`)
-    expect(result).toContain(`plain text without language`)
+    expect(result).toContain('<pre')
+    expect(result).toContain('plain text without language')
   })
 
-  test(`parse preserves theme CSS variables`, async () => {
+  test('parse converts code blocks without syntax highlighting', async () => {
     const markdown = `
 \`\`\`javascript
 const theme = "light"
@@ -83,7 +79,8 @@ const theme = "light"
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`--shiki-light`)
-    expect(result).toContain(`--shiki-dark`)
+    expect(result).toContain('<pre>')
+    expect(result).toContain('<code class="language-javascript">')
+    expect(result).toContain('const theme = "light"')
   })
 })

package/src/api/singletons/markdown/markdown.ts

@@ -1,29 +1,11 @@
-import rehypeShiki from '@shikijs/rehype'
 import rehypeStringify from 'rehype-stringify'
 import remarkGfm from 'remark-gfm'
 import remarkParse from 'remark-parse'
 import remarkRehype from 'remark-rehype'
 import { unified } from 'unified'
 
-// Create a processor with Shiki for syntax highlighting (async only)
-const createProcessorWithShiki = () => {
-  return unified()
-    .use(remarkParse)
-    .use(remarkGfm)
-    .use(remarkRehype)
-    .use(rehypeShiki, {
-      themes: {
-        light: `github-light`,
-        dark: `tokyo-night`,
-      },
-      defaultColor: false,
-      cssVariablePrefix: `--shiki-`,
-    })
-    .use(rehypeStringify)
-}
-
-// Create a processor without syntax highlighting for sync processing
-const createProcessorSync = () => {
+// Create a processor without syntax highlighting
+const createProcessor = () => {
   return unified()
     .use(remarkParse)
     .use(remarkGfm)
@@ -32,12 +14,11 @@ const createProcessorSync = () => {
 }
 
 export const parse = async (content: string): Promise<string> => {
-  const result = await createProcessorWithShiki().process(content)
+  const result = await createProcessor().process(content)
   return String(result)
 }
 
 export const parseSync = (content: string): string => {
-  // Note: Syntax highlighting is not available in sync mode due to @shikijs/rehype being async-only
-  const result = createProcessorSync().processSync(content)
+  const result = createProcessor().processSync(content)
   return String(result)
 }

package/src/api/static/index.ts

@@ -1 +1 @@
-export * as Static from './static.ts'
+export * as Static from './static.js'

package/src/api/static/manifest.test.ts

@@ -1,6 +1,6 @@
 import { Err, Fs, Path } from '@wollybeard/kit'
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { buildManifest, type PolenBuildManifest } from './manifest.ts'
+import { buildManifest, type PolenBuildManifest } from './manifest.js'
 
 describe('validate-build', () => {
   let testDir: string

package/src/api/static/manifest.ts

@@ -2,7 +2,7 @@ import { Codec, Resource } from '@wollybeard/kit'
 import { z } from 'zod/v4'
 
 export const PolenBuildManifestSchema = z.object({
-  type: z.enum(['ssg', 'ssr']),
+  type: z.enum([`ssg`, `ssr`]),
   version: z.string(),
   basePath: z.string(),
 }).loose()
@@ -10,7 +10,7 @@ export const PolenBuildManifestSchema = z.object({
 export type PolenBuildManifest = z.infer<typeof PolenBuildManifestSchema>
 
 export const buildManifest = Resource.create({
-  name: 'polen-build-manifest',
-  path: '.polen/build.json',
+  name: `polen-build-manifest`,
+  path: `.polen/build.json`,
   codec: Codec.fromZod(PolenBuildManifestSchema),
 })

package/src/api/static/rebase.test.ts

@@ -1,10 +1,10 @@
 import { Fs, Path } from '@wollybeard/kit'
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { rebase, type RebasePlan } from './rebase.ts'
+import { rebase, type RebasePlan } from './rebase.js'
 
 const testDir = 'temp/rebase-test'
 
-const createTestBuild = async (dir: string, basePath: string = '/') => {
+const createTestBuild = async (dir: string, basePath = '/') => {
   await Fs.makeDirectory(dir)
 
   // Create Polen build manifest

package/src/api/static/rebase.ts

@@ -1,18 +1,18 @@
 import { TinyGlobby } from '#dep/tiny-globby/index'
 import { Fs, Path } from '@wollybeard/kit'
 import { Err } from '@wollybeard/kit'
-import { buildManifest, type PolenBuildManifest } from './manifest.ts'
+import { buildManifest, type PolenBuildManifest } from './manifest.js'
 
 export type RebasePlan = RebaseOverwritePlan | RebaseCopyPlan
 
 export interface RebaseOverwritePlan {
-  changeMode: 'mutate'
+  changeMode: `mutate`
   newBasePath: string
   sourcePath: string
 }
 
 export interface RebaseCopyPlan {
-  changeMode: 'copy'
+  changeMode: `copy`
   newBasePath: string
   sourcePath: string
   targetPath: string
@@ -22,7 +22,7 @@ export const rebase = async (plan: RebasePlan): Promise<void> => {
   // 1. Validate source is a Polen build
   const manifestResult = await buildManifest.read(plan.sourcePath)
   if (Err.is(manifestResult)) {
-    throw new Error(`Polen build manifest not found at: ${Path.join(plan.sourcePath, '.polen', 'build.json')}`)
+    throw new Error(`Polen build manifest not found at: ${Path.join(plan.sourcePath, `.polen`, `build.json`)}`)
   }
   const manifest = manifestResult
 
@@ -33,7 +33,7 @@ export const rebase = async (plan: RebasePlan): Promise<void> => {
 
   // 3. Handle copy vs mutate
   let workingPath: string
-  if (plan.changeMode === 'copy') {
+  if (plan.changeMode === `copy`) {
     if (await Fs.exists(plan.targetPath)) {
       const isEmpty = await Fs.isEmptyDir(plan.targetPath)
       if (!isEmpty) {
@@ -64,8 +64,8 @@ export const rebase = async (plan: RebasePlan): Promise<void> => {
 // TODO: this is very generic, factor out to kit-temp
 const isValidUrlPath = (path: string): boolean => {
   // URL path should start with / and not contain invalid characters
-  if (!path.startsWith('/')) return false
-  if (!path.endsWith('/')) return false
+  if (!path.startsWith(`/`)) return false
+  if (!path.endsWith(`/`)) return false
 
   // Basic validation - no spaces, proper URL characters
   const urlPathRegex = /^\/[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=%]*\/$/
@@ -82,7 +82,7 @@ const updateHtmlFiles = async (buildPath: string, oldBasePath: string, newBasePa
 }
 
 const findHtmlFiles = async (dir: string): Promise<string[]> => {
-  return await TinyGlobby.glob('**/*.html', {
+  return await TinyGlobby.glob(`**/*.html`, {
     absolute: true,
     cwd: dir,
     onlyFiles: true,
@@ -108,10 +108,10 @@ const updateHtmlFile = async (filePath: string, oldBasePath: string, newBasePath
   } else {
     // Insert new base tag in head
     const headRegex = /<head[^>]*>/i
-    const headMatch = content.match(headRegex)
+    const headMatch = headRegex.exec(content)
 
     if (headMatch) {
-      const insertPosition = headMatch.index! + headMatch[0].length
+      const insertPosition = headMatch.index + headMatch[0].length
       updatedContent = content.slice(0, insertPosition)
         + `\n  <base href="${newBasePath}">`
         + content.slice(insertPosition)
@@ -124,7 +124,7 @@ const updateHtmlFile = async (filePath: string, oldBasePath: string, newBasePath
 }
 
 const updateManifest = async (buildPath: string, updates: Partial<PolenBuildManifest>): Promise<void> => {
-  const manifestPath = Path.join(buildPath, '.polen', 'build.json')
+  const manifestPath = Path.join(buildPath, `.polen`, `build.json`)
   const manifestResult = await buildManifest.read(buildPath)
   if (Err.is(manifestResult)) {
     throw new Error(`Polen build manifest not found at: ${manifestPath}`)

package/src/api/static/static.ts

@@ -1,2 +1,2 @@
-export * from './manifest.ts'
-export * from './rebase.ts'
+export * from './manifest.js'
+export * from './rebase.js'

package/src/api/utils/asset-url/asset-url.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest'
-import { assetUrl, faviconUrl, joinPaths, pageUrl } from './asset-url.ts'
+import { assetUrl, faviconUrl, joinPaths, pageUrl } from './asset-url.js'
 
 describe('asset-url helpers', () => {
   describe('joinPaths', () => {

package/src/api/utils/asset-url/index.ts

@@ -1 +1 @@
-export * from './asset-url.ts'
+export * from './asset-url.js'

package/src/api/vite/logger.ts

@@ -10,12 +10,12 @@ export const createLogger = (config: Config.Config): Vite.Logger => {
     ...baseLogger,
     info(msg, options) {
       // Filter out optimization-related messages
-      const msgString = typeof msg === 'string' ? msg : String(msg)
+      const msgString = typeof msg === `string` ? msg : String(msg)
       if (
-        msgString.includes('new dependencies optimized')
-        || msgString.includes('optimized dependencies changed')
-        || msgString.includes('Re-optimizing dependencies')
-        || msgString.includes('Forced re-optimization')
+        msgString.includes(`new dependencies optimized`)
+        || msgString.includes(`optimized dependencies changed`)
+        || msgString.includes(`Re-optimizing dependencies`)
+        || msgString.includes(`Forced re-optimization`)
       ) {
         return
       }

package/src/api/vite/plugins/{branding/index.ts → branding.ts}

@@ -6,7 +6,7 @@ import { debugPolen } from '#singletons/debug'
 import { Fs } from '@wollybeard/kit'
 import type { Plugin } from 'vite'
 
-const viLogo = polenVirtual(['project', 'assets', 'logo.svg'])
+const viLogo = polenVirtual([`project`, `assets`, `logo.svg`])
 
 const generateDefaultLogo = async () => {
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128" width="128" height="128">
@@ -15,12 +15,12 @@ const generateDefaultLogo = async () => {
 }
 
 export function Branding(config: Config.Config): Plugin {
-  const debug = debugPolen.sub('vite-plugin:branding')
-  debug('initialized')
+  const debug = debugPolen.sub(`vite-plugin:branding`)
+  debug(`initialized`)
 
   return {
-    name: 'polen:branding',
-    enforce: 'pre',
+    name: `polen:branding`,
+    enforce: `pre`,
 
     async buildStart() {
       this.addWatchFile(config.paths.project.absolute.public.logo)
@@ -46,7 +46,7 @@ export function Branding(config: Config.Config): Plugin {
       if (id === viLogo.resolved) {
         const logoFileContent = await Fs.read(config.paths.project.absolute.public.logo)
         const content = logoFileContent ? logoFileContent : await generateDefaultLogo()
-        const dataUrl = `data:image/svg+xml;base64,${Buffer.from(content).toString('base64')}`
+        const dataUrl = `data:image/svg+xml;base64,${Buffer.from(content).toString(`base64`)}`
         return `export default ${JSON.stringify(dataUrl)}`
       }
     },
@@ -63,7 +63,7 @@ interface HandleWatchedFileChangeParams {
 
 const handleWatchedFileChange = async (
   params: HandleWatchedFileChangeParams,
-): Promise<Array<Vite.ModuleNode> | void> => {
+): Promise<Vite.ModuleNode[] | void> => {
   const { watchedFile, changedFile, moduleId, server, debug } = params
 
   // Check if change is for watched file
@@ -93,8 +93,8 @@ const handleWatchedFileChange = async (
     case MutationType.Create:
       // Full reload needed - module never existed
       server.ws.send({
-        type: 'full-reload',
-        path: '*',
+        type: `full-reload`,
+        path: `*`,
       })
       break