polen 0.10.0-next.9 → 0.11.0-next.1

package/src/lib/demos/ui/data-collector.ts

@@ -1,246 +0,0 @@
-/**
- * Data collection for demo landing pages
- */
-
-import { Str } from '@wollybeard/kit'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { getDemoConfig, getDemoExamples } from '../index.ts'
-
-export interface DemoMetadata {
-  title: string
-  description: string
-  enabled: boolean
-  reason?: string
-}
-
-export interface TrunkDeployment {
-  sha: string
-  shortSha: string
-  tag: string | null
-}
-
-export interface TrunkDeploymentsData {
-  latest: TrunkDeployment | null
-  previous: TrunkDeployment[]
-}
-
-export interface PrDeployment {
-  number: number
-  sha?: string
-  ref?: string
-  previousDeployments?: string[]
-}
-
-export interface DistTagsData {
-  [key: string]: string
-}
-
-export interface LandingPageData {
-  demoMetadata: Record<string, DemoMetadata>
-  demoExamples: string[]
-  trunkDeployments?: TrunkDeploymentsData
-  prDeployments?: PrDeployment[]
-  distTags?: DistTagsData
-  config: {
-    basePath: string
-    mode: 'production' | 'development'
-    prNumber?: string
-    currentSha?: string
-  }
-}
-
-/**
- * Collects all data needed for generating demo landing pages
- */
-export class DemoDataCollector {
-  constructor(private workingDir: string = process.cwd()) {}
-
-  /**
-   * Collect all data for landing page generation
-   */
-  async collectLandingPageData(options: {
-    mode?: 'production' | 'development'
-    basePath?: string
-    prNumber?: string
-    currentSha?: string
-    trunkDeployments?: string | TrunkDeploymentsData
-    prDeployments?: string | PrDeployment[]
-    distTags?: string | DistTagsData
-  }): Promise<LandingPageData> {
-    try {
-      const {
-        mode = 'production',
-        basePath = '/',
-        prNumber,
-        currentSha,
-        trunkDeployments,
-        prDeployments,
-        distTags,
-      } = options
-
-      // Get demo examples
-      const demoExamples = await this.getDemoExamples()
-
-      // Load demo metadata
-      const demoMetadata = await this.loadDemoMetadata(demoExamples)
-
-      // Parse deployment data based on mode
-      const parsedTrunkDeployments = mode === 'development'
-        ? this.getMockTrunkDeployments()
-        : this.parseTrunkDeployments(trunkDeployments)
-
-      const parsedPrDeployments = this.parsePrDeployments(prDeployments)
-
-      const parsedDistTags = mode === 'development'
-        ? this.getMockDistTags()
-        : this.parseDistTags(distTags)
-
-      return {
-        demoMetadata,
-        demoExamples,
-        trunkDeployments: parsedTrunkDeployments,
-        prDeployments: parsedPrDeployments,
-        distTags: parsedDistTags,
-        config: {
-          mode,
-          basePath,
-          prNumber,
-          currentSha,
-        },
-      }
-    } catch (error) {
-      throw new Error(`Failed to collect landing page data: ${error instanceof Error ? error.message : String(error)}`)
-    }
-  }
-
-  /**
-   * Get demo examples using existing utility
-   */
-  private async getDemoExamples(): Promise<string[]> {
-    try {
-      return await getDemoExamples()
-    } catch (error) {
-      throw new Error(`Failed to get demo examples: ${error instanceof Error ? error.message : String(error)}`)
-    }
-  }
-
-  /**
-   * Load metadata for all demos (enabled and disabled)
-   */
-  private async loadDemoMetadata(demoExamples: string[]): Promise<Record<string, DemoMetadata>> {
-    const metadata: Record<string, DemoMetadata> = {}
-    const config = getDemoConfig().fullConfig
-
-    // Load metadata from package.json files for enabled examples
-    for (const example of demoExamples) {
-      try {
-        const packageJsonPath = join(this.workingDir, 'examples', example, 'package.json')
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
-
-        metadata[example] = {
-          title: packageJson.displayName || Str.Case.title(packageJson.name || example),
-          description: packageJson.description
-            || `Explore the ${example} GraphQL API with comprehensive documentation.`,
-          enabled: true,
-        }
-      } catch {
-        // Fallback if package.json is missing or invalid
-        metadata[example] = {
-          title: Str.Case.title(example),
-          description: `Explore the ${example} GraphQL API with comprehensive documentation.`,
-          enabled: true,
-        }
-      }
-    }
-
-    // Add disabled demos from configuration
-    const disabledDemos = getDemoConfig().getDisabledDemos()
-    for (const [name, disabledDemo] of Object.entries(disabledDemos)) {
-      metadata[name] = {
-        title: disabledDemo.title,
-        description: disabledDemo.description,
-        enabled: false,
-        reason: disabledDemo.reason,
-      }
-    }
-
-    return metadata
-  }
-
-  /**
-   * Parse trunk deployments from JSON string or object
-   */
-  private parseTrunkDeployments(trunkDeployments?: string | TrunkDeploymentsData): TrunkDeploymentsData | undefined {
-    if (!trunkDeployments) return undefined
-
-    if (typeof trunkDeployments === 'string') {
-      try {
-        return JSON.parse(trunkDeployments) as TrunkDeploymentsData
-      } catch {
-        return undefined
-      }
-    }
-
-    return trunkDeployments
-  }
-
-  /**
-   * Parse PR deployments from JSON string or array
-   */
-  private parsePrDeployments(prDeployments?: string | PrDeployment[]): PrDeployment[] | undefined {
-    if (!prDeployments) return undefined
-
-    if (typeof prDeployments === 'string') {
-      try {
-        return JSON.parse(prDeployments) as PrDeployment[]
-      } catch {
-        return undefined
-      }
-    }
-
-    return prDeployments
-  }
-
-  /**
-   * Parse dist-tags from JSON string or object
-   */
-  private parseDistTags(distTags?: string | DistTagsData): DistTagsData | undefined {
-    if (!distTags) return undefined
-
-    if (typeof distTags === 'string') {
-      try {
-        return JSON.parse(distTags) as DistTagsData
-      } catch {
-        return undefined
-      }
-    }
-
-    return distTags
-  }
-
-  /**
-   * Get mock data for development mode
-   */
-  private getMockTrunkDeployments(): TrunkDeploymentsData {
-    return {
-      latest: { sha: '1.2.0', shortSha: '1.2.0', tag: '1.2.0' },
-      previous: [
-        { sha: '1.1.0', shortSha: '1.1.0', tag: '1.1.0' },
-        { sha: '1.0.0', shortSha: '1.0.0', tag: '1.0.0' },
-        { sha: '0.9.1', shortSha: '0.9.1', tag: '0.9.1' },
-        { sha: '0.9.0', shortSha: '0.9.0', tag: '0.9.0' },
-      ],
-    }
-  }
-
-  /**
-   * Get mock dist-tags for development mode
-   */
-  private getMockDistTags(): DistTagsData {
-    return {
-      latest: '1.2.0',
-      next: '1.3.0-beta.2',
-    }
-  }
-}

package/src/lib/demos/ui/landing-page-cli.ts

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from '@molt/command'
-import { z } from 'zod'
-import { buildDemosHome } from './landing-page.ts'
-
-/**
- * CLI entry point
- */
-const command = Command.create()
-  .parameter('basePath', z.string().optional().describe('Base path for demo links'))
-  .parameter('prNumber', z.string().optional().describe('PR number for preview mode'))
-  .parameter('currentSha', z.string().optional().describe('Current commit SHA'))
-  .parameter('mode', z.enum(['production', 'development']).optional().describe('Page mode'))
-  .parameter('prDeployments', z.string().optional().describe('JSON string of PR deployments'))
-  .parameter('trunkDeployments', z.string().optional().describe('JSON string of trunk deployments'))
-  .parameter('distTags', z.string().optional().describe('JSON string of dist-tags'))
-  .parameter('serve', z.boolean().optional().describe('Start development server'))
-  .parameter('outputDir', z.string().optional().describe('Output directory'))
-  .parameter('outputPath', z.string().optional().describe('Output file path (overrides outputDir)'))
-
-const args = await command.parse()
-await buildDemosHome(args)

package/src/lib/demos/ui/landing-page.ts

@@ -1,126 +0,0 @@
-/**
- * Main entry point for demo landing page generation
- */
-import type { VersionCatalog } from '#lib/version-history/index'
-import { promises as fs } from 'node:fs'
-import { dirname, extname, join } from 'node:path'
-import { DemoDataCollector } from './data-collector.ts'
-import { DemoPageRenderer } from './page-renderer.ts'
-
-// Define the interface for the build options
-export interface Options {
-  basePath?: string
-  prNumber?: string
-  currentSha?: string
-  mode?: 'production' | 'development'
-  prDeployments?: string | any[]
-  trunkDeployments?: string | any
-  distTags?: string | Record<string, string>
-  outputDir?: string
-  outputPath?: string
-}
-
-// Options when using a version catalog
-export interface CatalogOptions {
-  basePath?: string
-  prNumber?: string
-  currentSha?: string
-  mode?: 'production' | 'development'
-  prDeployments?: string | any[]
-  catalog: VersionCatalog
-  outputDir?: string
-  outputPath?: string
-}
-
-/**
- * Build demos home page with a version catalog
- */
-export async function buildDemosHomeWithCatalog(options: CatalogOptions): Promise<void> {
-  const { catalog, ...otherOptions } = options
-
-  // Transform catalog data inline
-  const latestStable = catalog.distTags.latest || catalog.stable[0] || null
-  const trunkDeployments = {
-    latest: latestStable
-      ? {
-        sha: latestStable.git.sha,
-        shortSha: latestStable.git.sha.substring(0, 7),
-        tag: latestStable.git.tag,
-      }
-      : null,
-    previous: catalog.versions
-      .filter(v => v.git.tag !== latestStable?.git.tag)
-      .slice(0, 10)
-      .map(v => ({
-        sha: v.git.sha,
-        shortSha: v.git.sha.substring(0, 7),
-        tag: v.git.tag,
-      })),
-  }
-
-  const distTags: Record<string, string> = {}
-  for (const [name, version] of Object.entries(catalog.distTags)) {
-    if (version) {
-      distTags[name] = version.git.tag
-    }
-  }
-
-  // Use the existing function with transformed data
-  return buildDemosHome({
-    ...otherOptions,
-    trunkDeployments,
-    distTags,
-  })
-}
-
-// Function overloads
-export async function buildDemosHome(options: CatalogOptions): Promise<void>
-export async function buildDemosHome(options?: Options): Promise<void>
-
-/**
- * Main function that builds the demos home page
- */
-export async function buildDemosHome(options: CatalogOptions | Options = {}): Promise<void> {
-  // Check if catalog is provided
-  if ('catalog' in options && options.catalog) {
-    return buildDemosHomeWithCatalog(options as CatalogOptions)
-  }
-  const config = {
-    basePath: '/',
-    mode: 'production' as const,
-    outputDir: 'dist-demos',
-    ...options,
-  }
-
-  // Collect all required data
-  const dataCollector = new DemoDataCollector()
-  const data = await dataCollector.collectLandingPageData(config)
-
-  // Render the page
-  const renderer = new DemoPageRenderer()
-  const html = renderer.renderPage(data)
-
-  // Determine output path
-  let outputPath: string
-
-  if (config.outputPath) {
-    // Use provided outputPath
-    outputPath = config.outputPath
-
-    // If it's a directory (no extension), append the filename
-    if (!extname(outputPath)) {
-      const fileName = 'index.html'
-      outputPath = join(outputPath, fileName)
-    }
-
-    // Ensure parent directory exists
-    await fs.mkdir(dirname(outputPath), { recursive: true })
-  } else {
-    // Use outputDir (legacy behavior)
-    await fs.mkdir(config.outputDir, { recursive: true })
-    const fileName = 'index.html'
-    outputPath = join(config.outputDir, fileName)
-  }
-
-  await fs.writeFile(outputPath, html)
-}

package/src/lib/demos/ui/page-renderer.ts

@@ -1,124 +0,0 @@
-/**
- * HTML page renderer for demo landing pages
- */
-
-import { getDemoConfig } from '../index.ts'
-import {
-  generateDemosGrid,
-  generateFooter,
-  generateHeader,
-  generatePrBanner,
-  generateVersionInfo,
-  getDemoPageStyles,
-} from './components.ts'
-import type { LandingPageData } from './data-collector.ts'
-
-/**
- * Renders complete HTML pages for demo landing
- */
-export class DemoPageRenderer {
-  /**
-   * Render main demo landing page
-   */
-  renderMainLandingPage(data: LandingPageData): string {
-    const config = getDemoConfig().fullConfig
-    const { mode, prNumber } = data.config
-
-    let pageTitle = config.ui.branding.title
-    if (prNumber) {
-      pageTitle = `${pageTitle} - PR #${prNumber} Preview`
-    }
-
-    const prBannerHtml = prNumber ? generatePrBanner(prNumber) : ''
-    const headerHtml = generateHeader(data)
-    const demosGridHtml = generateDemosGrid(data)
-    const versionInfoHtml = generateVersionInfo(data)
-    const footerHtml = generateFooter()
-
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${pageTitle}</title>
-  <meta name="description" content="${config.ui.branding.description}">
-  ${config.ui.branding.logoUrl ? `<link rel="icon" href="${config.ui.branding.logoUrl}">` : ''}
-  <style>
-    ${getDemoPageStyles()}
-  </style>
-</head>
-<body>
-  ${prBannerHtml}
-  <div class="container">
-    ${headerHtml}
-    ${demosGridHtml}
-    ${versionInfoHtml}
-    ${footerHtml}
-  </div>
-</body>
-</html>`
-  }
-
-  /**
-   * Render development page with mock data
-   */
-  renderDevPage(data: LandingPageData): string {
-    const headerHtml = generateHeader(data)
-    const demosGridHtml = generateDemosGrid(data)
-    const versionInfoHtml = generateVersionInfo(data)
-    const footerHtml = generateFooter()
-
-    const devNoticeHtml = `
-      <div style="background: #fff3cd; border: 1px solid #ffeaa7; padding: 1rem; margin-bottom: 2rem; border-radius: 4px;">
-        <strong>Development Mode:</strong> This page is using mock data for development purposes.
-      </div>
-    `
-
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Polen Demos - Development</title>
-  <meta name="description" content="Development version of Polen demos">
-  <style>
-    ${getDemoPageStyles()}
-  </style>
-</head>
-<body>
-  <div class="container">
-    ${devNoticeHtml}
-    ${headerHtml}
-    ${demosGridHtml}
-    ${versionInfoHtml}
-    ${footerHtml}
-  </div>
-</body>
-</html>`
-  }
-
-  /**
-   * Render page based on mode
-   */
-  renderPage(data: LandingPageData): string {
-    const { mode } = data.config
-
-    switch (mode) {
-      case 'development':
-        return this.renderDevPage(data)
-      case 'production':
-      default:
-        return this.renderMainLandingPage(data)
-    }
-  }
-}
-
-/**
- * Utility function for quick page rendering
- */
-export async function renderDemoLandingPage(
-  data: LandingPageData,
-): Promise<string> {
-  const renderer = new DemoPageRenderer()
-  return renderer.renderPage(data)
-}

package/src/lib/demos/utils.ts

@@ -1,43 +0,0 @@
-/**
- * Utility functions for demo management
- */
-
-import type { Version } from '#lib/version-history/index'
-import { promises as fs } from 'node:fs'
-import { join } from 'node:path'
-import { getDemoConfig } from './config.ts'
-
-/**
- * Get list of demo examples from the examples directory
- */
-export async function getDemoExamples(): Promise<string[]> {
-  const examplesDir = join(process.cwd(), 'examples')
-  const examples: string[] = []
-
-  // Read all directories in examples/
-  try {
-    const dirs = await fs.readdir(examplesDir, { withFileTypes: true })
-    const dirNames = dirs
-      .filter(dirent => dirent.isDirectory())
-      .map(dirent => dirent.name)
-
-    examples.push(...dirNames)
-  } catch (e) {
-    console.error(`Error reading examples directory:`, (e as Error).message)
-  }
-
-  // Use DemoConfig to filter and order examples
-  const config = getDemoConfig()
-  return config.getOrderedDemos(examples)
-}
-
-/**
- * Get deployment path for a version
- */
-export const getDistTagPath = (version: Version): string => {
-  return version.isPrerelease ? `/next/` : '/latest/'
-}
-
-export const getSemverPath = (version: Version): string => {
-  return `/${version.semver}/`
-}

package/src/lib/deployment/$$.ts

@@ -1,2 +0,0 @@
-export * from './metadata.ts'
-export * from './path-manager.ts'

package/src/lib/deployment/$.test.ts

@@ -1,53 +0,0 @@
-import { Fs } from '@wollybeard/kit'
-import { beforeEach, describe, expect, test } from 'vitest'
-import { Deployment } from './$.ts'
-
-describe('metadata', () => {
-  let testDir: string
-
-  beforeEach(async () => {
-    testDir = await Fs.makeTemporaryDirectory()
-  })
-
-  test('writes and reads deployment metadata', async () => {
-    const metadata: Deployment.DeploymentMetadata = {
-      timestamp: '2024-01-01T00:00:00.000Z',
-      pullRequest: {
-        number: 123,
-        branch: 'feat/awesome',
-        commit: 'abc123',
-        title: 'Add awesome feature',
-        author: 'octocat',
-      },
-      deployment: {
-        url: 'https://example.github.io/repo/pr-123/',
-        environment: 'pr-123',
-      },
-    }
-
-    await Deployment.metadata.write(metadata, testDir)
-
-    const result = await Deployment.metadata.read(testDir)
-    expect(result).toEqual(metadata)
-  })
-
-  test('creates .deployment.json file', async () => {
-    const metadata: Deployment.DeploymentMetadata = {
-      timestamp: new Date().toISOString(),
-      pullRequest: {
-        number: 456,
-        branch: 'main',
-        commit: 'def456',
-      },
-      deployment: {
-        url: 'https://example.com',
-        environment: 'pr-456',
-      },
-    }
-
-    await Deployment.metadata.write(metadata, testDir)
-
-    const fileExists = await Fs.exists(`${testDir}/.deployment.json`)
-    expect(fileExists).toBe(true)
-  })
-})

package/src/lib/deployment/$.ts

@@ -1 +0,0 @@
-export * as Deployment from './$$.ts'

package/src/lib/deployment/metadata.ts

@@ -1,40 +0,0 @@
-import { Codec, Resource } from '@wollybeard/kit'
-import { z } from 'zod/v4'
-
-export const DeploymentMetadataSchema = z.object({
-  timestamp: z.iso.datetime(),
-  pullRequest: z.object({
-    number: z.number(),
-    branch: z.string(),
-    commit: z.string(),
-    title: z.string().optional(),
-    author: z.string().optional(),
-  }),
-  deployment: z.object({
-    url: z.url(),
-    environment: z.string(),
-  }),
-})
-
-export type DeploymentMetadata = z.infer<typeof DeploymentMetadataSchema>
-
-export const metadata = Resource.create({
-  name: 'deployment-metadata',
-  path: '.deployment.json',
-  codec: Codec.fromZod(DeploymentMetadataSchema),
-  init: {
-    auto: true,
-    value: () => ({
-      timestamp: new Date().toISOString(),
-      pullRequest: {
-        number: 0,
-        branch: 'unknown',
-        commit: 'unknown',
-      },
-      deployment: {
-        url: '',
-        environment: 'unknown',
-      },
-    }),
-  },
-})