polen 0.10.0-next.13 → 0.10.0-next.3

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

@@ -1,106 +0,0 @@
-import { Err, Fs, Path } from '@wollybeard/kit'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { buildManifest, type PolenBuildManifest } from './manifest.ts'
-
-describe('validate-build', () => {
-  let testDir: string
-  let manifestPath: string
-
-  beforeEach(async () => {
-    testDir = await Fs.makeTemporaryDirectory()
-    manifestPath = Path.join(testDir, '.polen', 'build.json')
-  })
-
-  afterEach(async () => {
-    if (testDir && await Fs.exists(testDir)) {
-      await Fs.remove(testDir)
-    }
-  })
-
-  describe('readBuildManifest', () => {
-    test('reads valid manifest', async () => {
-      const manifest: PolenBuildManifest = {
-        type: 'ssr',
-        version: '2.1.0',
-        basePath: '/docs/',
-      }
-      await Fs.write({
-        path: manifestPath,
-        content: JSON.stringify(manifest, null, 2),
-      })
-
-      const result = await buildManifest.read(testDir)
-      expect(Err.is(result)).toBe(false)
-      expect(result).toEqual(manifest)
-    })
-
-    test('returns error when manifest does not exist', async () => {
-      // Verify the file doesn't exist
-      const manifestExists = await Fs.exists(manifestPath)
-      expect(manifestExists).toBe(false)
-
-      const result = await buildManifest.read(testDir)
-      expect(Err.is(result)).toBe(true)
-    })
-
-    test('returns error for invalid manifest structure', async () => {
-      await Fs.write({
-        path: manifestPath,
-        content: JSON.stringify({ invalid: 'data' }, null, 2),
-      })
-      const result = await buildManifest.read(testDir)
-      expect(Err.is(result)).toBe(true)
-    })
-
-    test('returns error for invalid build type', async () => {
-      await Fs.write({
-        path: manifestPath,
-        content: JSON.stringify(
-          {
-            type: 'invalid',
-            version: '1.0.0',
-            basePath: '/',
-          },
-          null,
-          2,
-        ),
-      })
-      const result = await buildManifest.read(testDir)
-      expect(Err.is(result)).toBe(true)
-    })
-
-    test('returns error when version is not a string', async () => {
-      await Fs.write({
-        path: manifestPath,
-        content: JSON.stringify(
-          {
-            type: 'ssg',
-            version: 123,
-            basePath: '/',
-          },
-          null,
-          2,
-        ),
-      })
-      const result = await buildManifest.read(testDir)
-      expect(Err.is(result)).toBe(true)
-    })
-
-    test('returns error when basePath is not a string', async () => {
-      await Fs.write({
-        path: manifestPath,
-        content: JSON.stringify(
-          {
-            type: 'ssg',
-            version: '1.0.0',
-            basePath: null,
-          },
-          null,
-          2,
-        ),
-      })
-      const result = await buildManifest.read(testDir)
-      expect(Err.is(result)).toBe(true)
-    })
-  })
-})

package/src/api/static/manifest.ts

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

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

@@ -1,229 +0,0 @@
-import { Fs, Path } from '@wollybeard/kit'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { rebase, type RebasePlan } from './rebase.ts'
-
-const testDir = 'temp/rebase-test'
-
-const createTestBuild = async (dir: string, basePath: string = '/') => {
-  await Fs.makeDirectory(dir)
-
-  // Create Polen build manifest
-  const polenDir = Path.join(dir, '.polen')
-  await Fs.makeDirectory(polenDir)
-
-  const manifest = {
-    type: 'ssg' as const,
-    version: '1.0.0',
-    basePath,
-  }
-
-  await Fs.write({
-    path: Path.join(polenDir, 'build.json'),
-    content: JSON.stringify(manifest, null, 2),
-  })
-
-  // Create some HTML files
-  await Fs.write({
-    path: Path.join(dir, 'index.html'),
-    content: `<!DOCTYPE html>
-<html>
-<head>
-  <base href="${basePath}">
-  <title>Test</title>
-</head>
-<body>
-  <h1>Test Page</h1>
-</body>
-</html>`,
-  })
-
-  // Create nested HTML file
-  const nestedDir = Path.join(dir, 'docs')
-  await Fs.makeDirectory(nestedDir)
-
-  await Fs.write({
-    path: Path.join(nestedDir, 'page.html'),
-    content: `<!DOCTYPE html>
-<html>
-<head>
-  <title>Nested</title>
-</head>
-<body>
-  <h1>Nested Page</h1>
-</body>
-</html>`,
-  })
-}
-
-describe('rebase', () => {
-  beforeEach(async () => {
-    await Fs.remove(testDir)
-  })
-
-  afterEach(async () => {
-    await Fs.remove(testDir)
-  })
-
-  test('mutate mode updates base paths in place', async () => {
-    const buildDir = Path.join(testDir, 'build')
-    await createTestBuild(buildDir, '/old/')
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      newBasePath: '/new/',
-      changeMode: 'mutate',
-    }
-
-    await rebase(plan)
-
-    // Check updated manifest
-    const manifest = await Fs.readJson(Path.join(buildDir, '.polen', 'build.json'))
-    expect(manifest).toMatchObject({
-      type: 'ssg',
-      version: '1.0.0',
-      basePath: '/new/',
-    })
-
-    // Check updated HTML file
-    const indexContent = await Fs.read(Path.join(buildDir, 'index.html'))
-    expect(indexContent).toContain('<base href="/new/">')
-
-    // Check nested HTML file (should have base tag inserted)
-    const nestedContent = await Fs.read(Path.join(buildDir, 'docs', 'page.html'))
-    expect(nestedContent).toContain('<base href="/new/">')
-  })
-
-  test('copy mode creates new build with updated base paths', async () => {
-    const buildDir = Path.join(testDir, 'build')
-    const copyDir = Path.join(testDir, 'copy')
-
-    await createTestBuild(buildDir, '/old/')
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      targetPath: copyDir,
-      newBasePath: '/new/',
-      changeMode: 'copy',
-    }
-
-    await rebase(plan)
-
-    // Original should be unchanged
-    const originalManifest = await Fs.readJson(Path.join(buildDir, '.polen', 'build.json'))
-    expect(originalManifest).toMatchObject({
-      basePath: '/old/',
-    })
-
-    // Copy should be updated
-    const copyManifest = await Fs.readJson(Path.join(copyDir, '.polen', 'build.json'))
-    expect(copyManifest).toMatchObject({
-      basePath: '/new/',
-    })
-
-    const copyIndexContent = await Fs.read(Path.join(copyDir, 'index.html'))
-    expect(copyIndexContent).toContain('<base href="/new/">')
-  })
-
-  test('throws error for invalid base path', async () => {
-    const buildDir = Path.join(testDir, 'build')
-    await createTestBuild(buildDir)
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      newBasePath: 'invalid-path',
-      changeMode: 'mutate',
-    }
-
-    await expect(rebase(plan)).rejects.toThrow('Invalid base path: invalid-path')
-  })
-
-  test('throws error when source is not a Polen build', async () => {
-    const buildDir = Path.join(testDir, 'not-polen')
-    await Fs.makeDirectory(buildDir)
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      newBasePath: '/new/',
-      changeMode: 'mutate',
-    }
-
-    await expect(rebase(plan)).rejects.toThrow('Polen build manifest not found')
-  })
-
-  test('throws error when copy target exists and is not empty', async () => {
-    const buildDir = Path.join(testDir, 'build')
-    const copyDir = Path.join(testDir, 'copy')
-
-    await createTestBuild(buildDir)
-
-    // Create non-empty target
-    await Fs.makeDirectory(copyDir)
-    await Fs.write({
-      path: Path.join(copyDir, 'existing.txt'),
-      content: 'existing file',
-    })
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      targetPath: copyDir,
-      newBasePath: '/new/',
-      changeMode: 'copy',
-    }
-
-    await expect(rebase(plan)).rejects.toThrow('Target path already exists and is not empty')
-  })
-
-  test('handles HTML file without existing base tag', async () => {
-    const buildDir = Path.join(testDir, 'build')
-    await createTestBuild(buildDir)
-
-    // Create HTML without base tag
-    await Fs.write({
-      path: Path.join(buildDir, 'no-base.html'),
-      content: `<!DOCTYPE html>
-<html>
-<head>
-  <title>No Base</title>
-</head>
-<body>
-  <h1>No Base Tag</h1>
-</body>
-</html>`,
-    })
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      newBasePath: '/new/',
-      changeMode: 'mutate',
-    }
-
-    await rebase(plan)
-
-    const content = await Fs.read(Path.join(buildDir, 'no-base.html'))
-    expect(content).toContain('<base href="/new/">')
-  })
-
-  test('throws error for HTML file without head tag', async () => {
-    const buildDir = Path.join(testDir, 'build')
-    await createTestBuild(buildDir)
-
-    // Create invalid HTML without head
-    await Fs.write({
-      path: Path.join(buildDir, 'invalid.html'),
-      content: `<!DOCTYPE html>
-<html>
-<body>
-  <h1>Invalid HTML</h1>
-</body>
-</html>`,
-    })
-
-    const plan: RebasePlan = {
-      sourcePath: buildDir,
-      newBasePath: '/new/',
-      changeMode: 'mutate',
-    }
-
-    await expect(rebase(plan)).rejects.toThrow('Could not find <head> tag in HTML file')
-  })
-})

package/src/api/static/rebase.ts

@@ -1,140 +0,0 @@
-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'
-
-export type RebasePlan = RebaseOverwritePlan | RebaseCopyPlan
-
-export interface RebaseOverwritePlan {
-  changeMode: 'mutate'
-  newBasePath: string
-  sourcePath: string
-}
-
-export interface RebaseCopyPlan {
-  changeMode: 'copy'
-  newBasePath: string
-  sourcePath: string
-  targetPath: string
-}
-
-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')}`)
-  }
-  const manifest = manifestResult
-
-  // 2. Validate newBasePath is valid URL path
-  if (!isValidUrlPath(plan.newBasePath)) {
-    throw new Error(`Invalid base path: ${plan.newBasePath}`)
-  }
-
-  // 3. Handle copy vs mutate
-  let workingPath: string
-  if (plan.changeMode === 'copy') {
-    if (await Fs.exists(plan.targetPath)) {
-      const isEmpty = await Fs.isEmptyDir(plan.targetPath)
-      if (!isEmpty) {
-        throw new Error(`Target path already exists and is not empty: ${plan.targetPath}`)
-      }
-    }
-    await Fs.copyDir({ from: plan.sourcePath, to: plan.targetPath })
-    workingPath = plan.targetPath
-  } else {
-    workingPath = plan.sourcePath
-  }
-
-  // 4. Update HTML files with new base path
-  await updateHtmlFiles(workingPath, manifest.basePath, plan.newBasePath)
-
-  // 5. Update manifest
-  await updateManifest(workingPath, { basePath: plan.newBasePath })
-}
-
-//
-//
-//
-//
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ • Local Helpers
-//
-//
-
-// 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
-
-  // Basic validation - no spaces, proper URL characters
-  const urlPathRegex = /^\/[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=%]*\/$/
-  return urlPathRegex.test(path)
-}
-
-const updateHtmlFiles = async (buildPath: string, oldBasePath: string, newBasePath: string): Promise<void> => {
-  // Find all HTML files recursively
-  const htmlFiles = await findHtmlFiles(buildPath)
-
-  for (const htmlFile of htmlFiles) {
-    await updateHtmlFile(htmlFile, oldBasePath, newBasePath)
-  }
-}
-
-const findHtmlFiles = async (dir: string): Promise<string[]> => {
-  return await TinyGlobby.glob('**/*.html', {
-    absolute: true,
-    cwd: dir,
-    onlyFiles: true,
-  })
-}
-
-const updateHtmlFile = async (filePath: string, oldBasePath: string, newBasePath: string): Promise<void> => {
-  const content = await Fs.read(filePath)
-
-  if (content === null) {
-    throw new Error(`Could not read HTML file: ${filePath}`)
-  }
-
-  // Simple regex-based approach to update base tag
-  // Look for existing base tag first
-  const baseTagRegex = /<base\s+href\s*=\s*["']([^"']*)["'][^>]*>/i
-
-  let updatedContent: string
-
-  if (baseTagRegex.test(content)) {
-    // Update existing base tag
-    updatedContent = content.replace(baseTagRegex, `<base href="${newBasePath}">`)
-  } else {
-    // Insert new base tag in head
-    const headRegex = /<head[^>]*>/i
-    const headMatch = content.match(headRegex)
-
-    if (headMatch) {
-      const insertPosition = headMatch.index! + headMatch[0].length
-      updatedContent = content.slice(0, insertPosition)
-        + `\n  <base href="${newBasePath}">`
-        + content.slice(insertPosition)
-    } else {
-      throw new Error(`Could not find <head> tag in HTML file: ${filePath}`)
-    }
-  }
-
-  await Fs.write({ path: filePath, content: updatedContent })
-}
-
-const updateManifest = async (buildPath: string, updates: Partial<PolenBuildManifest>): Promise<void> => {
-  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}`)
-  }
-  const currentManifest = manifestResult
-
-  const updatedManifest = { ...currentManifest, ...updates }
-
-  await Fs.write({
-    path: manifestPath,
-    content: JSON.stringify(updatedManifest, null, 2),
-  })
-}

package/src/api/static/static.ts

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

package/src/cli/commands/static/$default.ts

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-
-import { Arr, Cli, Path, Str } from '@wollybeard/kit'
-import $ from 'ansis'
-import console from 'console'
-
-const commandsDir = import.meta.dirname
-const thisModuleName = Path.parse(import.meta.filename).name
-const cliName = `polen static`
-
-const h2 = (str: string) => {
-  return $.bold.black.bgWhiteBright(` ${str.toUpperCase()} `)
-}
-
-const code = (str: string) => {
-  if (!$.isSupported()) return `\`${str}\``
-  return $.magenta(str)
-}
-
-const s = Str.Builder()
-const allCommands = await Cli.discoverCommandPointers(commandsDir)
-const commands = allCommands.filter(_ => _.name !== thisModuleName)
-
-s``
-s`${$.bold.redBright`POLEN 🌺`} ${$.dim(`static commands`)}`
-s`Manage static builds and deployments.`
-s``
-s``
-s`${h2(`commands`)}`
-s``
-
-if (Arr.isEmpty(commands)) {
-  s`No commands available yet.`
-} else {
-  commands.forEach(command => {
-    s`${$.dim`$ ${cliName}`} ${$.cyanBright(command.name)}`
-  })
-}
-s``
-s`${$.dim`Get help for a command with ${code(`polen static <command> --help`)}`}`
-s``
-
-console.log(Str.indent(String(s)))

package/src/cli/commands/static/rebase.ts

@@ -1,37 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-import { Api } from '#api/index'
-import { Task } from '#lib/task'
-import { Command } from '@molt/command'
-import { Err, Path } from '@wollybeard/kit'
-import { z } from 'zod'
-
-const args = Command.create()
-  .parameter(
-    `source`,
-    z.string().describe('Path to the Polen build directory to rebase'),
-  )
-  .parameter(
-    `newBasePath`,
-    z.string().describe('New base path for the build (e.g., /new-path/)'),
-  )
-  .parameter(
-    `--target -t`,
-    z.string().optional().describe('Target directory for copy mode (if not provided, mutate in place)'),
-  )
-  .parse()
-
-const plan: Api.Static.RebasePlan = args.target
-  ? {
-    changeMode: 'copy',
-    sourcePath: args.source,
-    targetPath: args.target,
-    newBasePath: args.newBasePath,
-  }
-  : {
-    changeMode: 'mutate',
-    sourcePath: args.source,
-    newBasePath: args.newBasePath,
-  }
-
-await Task.runAndExit(Api.Static.rebase, plan)

package/src/cli/commands/static.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-
-import { Cli, Path } from '@wollybeard/kit'
-
-const commandsDir = Path.join(import.meta.dirname, 'static')
-await Cli.dispatch(commandsDir)

package/src/exports/components.ts

@@ -1,4 +0,0 @@
-export { Callout, Tabs } from '@radix-ui/themes'
-export { GraphQLDocumentWithSchema } from '../template/components/content/GraphQLDocumentWrapper.tsx'
-export { mdxComponents } from '../template/components/MDXComponents.tsx'
-export { TestComponent } from '../template/components/TestComponent.tsx'