polen 0.9.1-next.2 → 0.10.0-next.11

package/src/lib/version-history/index.test.ts

@@ -0,0 +1,196 @@
+import { parse as semverParse } from '@vltpkg/semver'
+import type { SimpleGit } from 'simple-git'
+import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'
+import { VersionHistory } from './index.ts'
+
+// Mock the simple-git module
+vi.mock('simple-git', () => ({
+  simpleGit: vi.fn(),
+}))
+
+describe('VersionHistory', () => {
+  describe('parseSemver', () => {
+    it('parses standard semver tags', () => {
+      const version = VersionHistory.parseSemver('1.2.3')
+      expect(version).not.toBeNull()
+      expect(version?.major).toBe(1)
+      expect(version?.minor).toBe(2)
+      expect(version?.patch).toBe(3)
+      expect(version?.prerelease).toBeUndefined()
+    })
+
+    it('parses semver tags with v prefix', () => {
+      const version = VersionHistory.parseSemver('v1.2.3')
+      expect(version).not.toBeNull()
+      expect(version?.major).toBe(1)
+      expect(version?.minor).toBe(2)
+      expect(version?.patch).toBe(3)
+    })
+
+    it('parses prerelease versions', () => {
+      const version = VersionHistory.parseSemver('1.2.3-beta.1')
+      expect(version).not.toBeNull()
+      expect(version?.major).toBe(1)
+      expect(version?.minor).toBe(2)
+      expect(version?.patch).toBe(3)
+      expect(version?.prerelease).toEqual(['beta', 1])
+    })
+
+    it('returns null for invalid semver', () => {
+      expect(VersionHistory.parseSemver('not-a-version')).toBeNull()
+      expect(VersionHistory.parseSemver('1.2')).toBeNull()
+      expect(VersionHistory.parseSemver('latest')).toBeNull()
+    })
+  })
+
+  describe('isSemverTag', () => {
+    it('identifies valid semver tags', () => {
+      expect(VersionHistory.isSemverTag('1.2.3')).toBe(true)
+      expect(VersionHistory.isSemverTag('v1.2.3')).toBe(true)
+      expect(VersionHistory.isSemverTag('1.0.0-beta.1')).toBe(true)
+      expect(VersionHistory.isSemverTag('0.0.1')).toBe(true)
+    })
+
+    it('rejects invalid semver tags', () => {
+      expect(VersionHistory.isSemverTag('latest')).toBe(false)
+      expect(VersionHistory.isSemverTag('next')).toBe(false)
+      expect(VersionHistory.isSemverTag('1.2')).toBe(false)
+      expect(VersionHistory.isSemverTag('v1.2')).toBe(false)
+      expect(VersionHistory.isSemverTag('not-a-version')).toBe(false)
+    })
+  })
+
+  describe('isPrerelease', () => {
+    it('identifies prerelease versions', () => {
+      expect(VersionHistory.isPrerelease('1.0.0-beta.1')).toBe(true)
+      expect(VersionHistory.isPrerelease('2.0.0-next.5')).toBe(true)
+      expect(VersionHistory.isPrerelease('3.0.0-alpha')).toBe(true)
+    })
+
+    it('identifies stable versions', () => {
+      expect(VersionHistory.isPrerelease('1.0.0')).toBe(false)
+      expect(VersionHistory.isPrerelease('v2.3.4')).toBe(false)
+    })
+  })
+
+  describe('version sorting', () => {
+    it('sorts versions correctly', () => {
+      const versions = [
+        { semver: semverParse('1.0.0')!, isPrerelease: false },
+        { semver: semverParse('2.0.0')!, isPrerelease: false },
+        { semver: semverParse('1.1.0')!, isPrerelease: false },
+        { semver: semverParse('1.0.1')!, isPrerelease: false },
+        { semver: semverParse('2.0.0-beta.1')!, isPrerelease: true },
+      ]
+
+      const sorted = [...versions].sort((a, b) => {
+        // Reverse comparison for descending order
+        return b.semver.compare(a.semver)
+      })
+
+      expect(sorted[0]!.semver.toString()).toBe('2.0.0')
+      expect(sorted[1]!.semver.toString()).toBe('2.0.0-beta.1')
+      expect(sorted[2]!.semver.toString()).toBe('1.1.0')
+      expect(sorted[3]!.semver.toString()).toBe('1.0.1')
+      expect(sorted[4]!.semver.toString()).toBe('1.0.0')
+    })
+  })
+
+  describe('getCurrentDevelopmentCycle', () => {
+    let mockGit: {
+      tags: Mock
+      show: Mock
+      revparse: Mock
+      tag: Mock
+    }
+
+    beforeEach(async () => {
+      vi.clearAllMocks()
+
+      mockGit = {
+        tags: vi.fn(),
+        show: vi.fn(),
+        revparse: vi.fn(),
+        tag: vi.fn(),
+      }
+
+      // Mock the simpleGit function to return our mock git instance
+      const { simpleGit } = await import('simple-git')
+      vi.mocked(simpleGit).mockReturnValue(mockGit as unknown as SimpleGit)
+    })
+
+    it('returns latest stable and newer prereleases', async () => {
+      // Mock git tags
+      mockGit.tags.mockResolvedValue({
+        all: ['1.0.0', '1.1.0', '1.2.0', '2.0.0-beta.1', '2.0.0-beta.2', '2.0.0'],
+      })
+
+      // Mock git show for each tag
+      const mockDates = {
+        '1.0.0': '1234567890',
+        '1.1.0': '1234567900',
+        '1.2.0': '1234567910',
+        '2.0.0-beta.1': '1234567920',
+        '2.0.0-beta.2': '1234567930',
+        '2.0.0': '1234567940',
+      }
+
+      mockGit.show.mockImplementation((args: string[]) => {
+        const tag = args[0]?.replace('^{commit}', '') || ''
+        const timestamp = mockDates[tag as keyof typeof mockDates]
+        return Promise.resolve(`abc123 ${timestamp}`)
+      })
+
+      const cycle = await VersionHistory.getCurrentDevelopmentCycle()
+
+      expect(cycle.stable?.git.tag).toBe('2.0.0')
+      expect(cycle.prereleases).toHaveLength(0) // No prereleases after stable version 2.0.0
+      expect(cycle.all).toHaveLength(1) // Just the stable version
+    })
+
+    it('includes prereleases newer than latest stable', async () => {
+      // Mock git tags
+      mockGit.tags.mockResolvedValue({
+        all: ['1.0.0', '1.1.0', '2.0.0-beta.1', '2.0.0-beta.2'],
+      })
+
+      // Mock git show for each tag
+      const mockDates = {
+        '1.0.0': '1234567890',
+        '1.1.0': '1234567900',
+        '2.0.0-beta.1': '1234567910',
+        '2.0.0-beta.2': '1234567920',
+      }
+
+      mockGit.show.mockImplementation((args: string[]) => {
+        const tag = args[0]?.replace('^{commit}', '') || ''
+        const timestamp = mockDates[tag as keyof typeof mockDates]
+        return Promise.resolve(`abc123 ${timestamp}`)
+      })
+
+      const cycle = await VersionHistory.getCurrentDevelopmentCycle()
+
+      expect(cycle.stable?.git.tag).toBe('1.1.0') // Latest stable version
+      expect(cycle.prereleases).toHaveLength(2) // Prereleases newer than stable
+      expect(cycle.prereleases[0]?.git.tag).toBe('2.0.0-beta.2')
+      expect(cycle.prereleases[1]?.git.tag).toBe('2.0.0-beta.1')
+      expect(cycle.all).toHaveLength(3) // Stable + 2 prereleases
+    })
+
+    it('returns all versions as prereleases when no stable version exists', async () => {
+      // Mock git tags with only prereleases
+      mockGit.tags.mockResolvedValue({
+        all: ['0.1.0-alpha.1', '0.1.0-alpha.2', '0.1.0-beta.1'],
+      })
+
+      // Mock git show for each tag
+      mockGit.show.mockImplementation(() => Promise.resolve('abc123 1234567890'))
+
+      const cycle = await VersionHistory.getCurrentDevelopmentCycle()
+
+      expect(cycle.stable).toBeNull()
+      expect(cycle.prereleases).toHaveLength(3)
+      expect(cycle.all).toHaveLength(3)
+    })
+  })
+})

package/src/lib/version-history/index.ts

@@ -0,0 +1,4 @@
+export * as VersionHistory from './version-history.ts'
+
+// Re-export types at the top level for convenience
+export type { DevelopmentCycle, DistTagInfo, Version, VersionCatalog } from './types.ts'

package/src/lib/version-history/types.ts

@@ -0,0 +1,68 @@
+/**
+ * Version history types
+ */
+
+import type { Version as Semver } from '@vltpkg/semver'
+
+export interface Version {
+  /**
+   * Git-related information for this version
+   */
+  git: {
+    /**
+     * The git tag name for this version (e.g., "1.2.3" or "2.0.0-beta.1")
+     */
+    tag: string
+    /**
+     * The full git commit SHA associated with this version tag
+     */
+    sha: string
+  }
+  /**
+   * The date when this version tag was created
+   */
+  date: Date
+  /**
+   * Whether this version is a prerelease (contains -alpha, -beta, -rc, etc.)
+   */
+  isPrerelease: boolean
+  /**
+   * Parsed semver object containing major, minor, patch, and prerelease info
+   */
+  semver: Semver
+}
+
+export interface DistTagInfo {
+  name: string
+  commit: string
+  semverTag?: string
+}
+
+export interface DevelopmentCycle {
+  stable: Version | null
+  prereleases: Version[]
+  all: Version[]
+}
+
+/**
+ * Complete registry of all versions and dist-tags in the repository
+ */
+export interface VersionCatalog {
+  /**
+   * All dist-tags mapped to their corresponding versions
+   */
+  distTags: {
+    latest?: Version
+    next?: Version
+    [tagName: string]: Version | undefined
+  }
+  /**
+   * All versions sorted by semver (newest first)
+   */
+  versions: Version[]
+  /**
+   * Quick access to commonly needed subsets
+   */
+  stable: Version[]
+  prerelease: Version[]
+}

package/src/lib/version-history/version-history.ts

@@ -0,0 +1,293 @@
+import {
+  compare as semverCompare,
+  parse as semverParse,
+  prerelease as semverPrerelease,
+  type Version as SemverVersion,
+} from '@vltpkg/semver'
+import { type SimpleGit, simpleGit } from 'simple-git'
+import type { DevelopmentCycle, DistTagInfo, Version, VersionCatalog } from './types.ts'
+
+export type { DevelopmentCycle, DistTagInfo, Version, VersionCatalog } from './types.ts'
+
+// Helper to get git instance
+function getGit(repoPath: string = process.cwd()): SimpleGit {
+  return simpleGit(repoPath)
+}
+
+/**
+ * Parse a semver string into a Version object
+ */
+export function parseSemver(tag: string): SemverVersion | null {
+  return semverParse(tag) || null
+}
+
+/**
+ * Check if a tag is a semver tag
+ */
+export function isSemverTag(tag: string): boolean {
+  return semverParse(tag) !== undefined
+}
+
+/**
+ * Check if a version is a prerelease
+ */
+export function isPrerelease(tag: string): boolean {
+  const prereleaseArray = semverPrerelease(tag)
+  return prereleaseArray !== undefined && prereleaseArray.length > 0
+}
+
+/**
+ * Check if a version is stable (not a prerelease)
+ */
+export function isStableVersion(tag: string): boolean {
+  return !isPrerelease(tag)
+}
+
+/**
+ * Get the deployment path for a version
+ * Stable versions go to /latest/, prereleases go to /[version]/
+ */
+export function getDeploymentPath(version: string, prefix: string = '/polen'): string {
+  const isStable = isStableVersion(version)
+  return isStable ? `${prefix}/latest/` : `${prefix}/${version}/`
+}
+
+/**
+ * Get all versions from the repository
+ */
+export async function getVersions(repoPath?: string): Promise<Version[]> {
+  const git = getGit(repoPath)
+  const tags = await git.tags()
+  const versions: Version[] = []
+
+  for (const tag of tags.all) {
+    if (!isSemverTag(tag)) continue
+
+    const semver = parseSemver(tag)
+    if (!semver) continue
+
+    try {
+      const tagInfo = await git.show([`${tag}^{commit}`, `--format=%H %at`])
+      const [commit, timestamp] = tagInfo.trim().split(' ')
+
+      if (!commit) continue
+
+      versions.push({
+        git: {
+          tag,
+          sha: commit,
+        },
+        date: new Date(parseInt(timestamp || '0', 10) * 1000),
+        isPrerelease: isPrerelease(tag),
+        semver,
+      })
+    } catch (e) {
+      // Skip tags that can't be resolved
+      console.warn(`Failed to get info for tag ${tag}:`, e)
+    }
+  }
+
+  // Sort by semver (newest first) - reverse of semverCompare
+  return versions.sort((a, b) => semverCompare(b.semver, a.semver))
+}
+
+/**
+ * Get dist-tag information (latest, next, etc.)
+ */
+export async function getDistTag(tagName: string, repoPath?: string): Promise<DistTagInfo | null> {
+  const git = getGit(repoPath)
+  try {
+    const commit = await git.revparse([tagName])
+
+    // Find semver tag at this commit
+    const tags = await git.tag([`--points-at`, commit])
+    const semverTags = tags.split('\n').filter(isSemverTag)
+
+    return {
+      name: tagName,
+      commit: commit.trim(),
+      semverTag: semverTags[0],
+    }
+  } catch (e) {
+    return null
+  }
+}
+
+/**
+ * Get the 'latest' dist-tag
+ */
+export async function getDistTagLatest(repoPath?: string): Promise<DistTagInfo | null> {
+  return getDistTag('latest', repoPath)
+}
+
+/**
+ * Get all dist-tags
+ */
+export async function getDistTags(repoPath?: string): Promise<DistTagInfo[]> {
+  const commonDistTags = ['latest', 'next', 'beta', 'alpha', 'canary']
+  const distTags: DistTagInfo[] = []
+
+  for (const tag of commonDistTags) {
+    const info = await getDistTag(tag, repoPath)
+    if (info) {
+      distTags.push(info)
+    }
+  }
+
+  return distTags
+}
+
+/**
+ * Get the latest stable version
+ */
+export async function getLatestStableVersion(repoPath?: string): Promise<Version | null> {
+  const versions = await getVersions(repoPath)
+  return versions.find(v => !v.isPrerelease) || null
+}
+
+/**
+ * Get the latest prerelease version
+ */
+export async function getLatestPrereleaseVersion(repoPath?: string): Promise<Version | null> {
+  const versions = await getVersions(repoPath)
+  return versions.find(v => v.isPrerelease) || null
+}
+
+/**
+ * Get version at a specific commit
+ */
+export async function getVersionAtCommit(commit: string, repoPath?: string): Promise<Version | null> {
+  const git = getGit(repoPath)
+  const tags = await git.tag([`--points-at`, commit])
+  const semverTags = tags.split('\n').filter(isSemverTag)
+
+  if (semverTags.length === 0) return null
+
+  // Get full info for the first semver tag
+  const versions = await getVersions(repoPath)
+  return versions.find(v => v.git.tag === semverTags[0]) || null
+}
+
+/**
+ * Get deployment history for demos (versions that should have demos)
+ */
+export async function getDeploymentHistory(minimumVersion?: string, repoPath?: string): Promise<Version[]> {
+  const versions = await getVersions(repoPath)
+
+  if (!minimumVersion) return versions
+
+  const minSemver = parseSemver(minimumVersion)
+  if (!minSemver) return versions
+
+  return versions.filter(v => semverCompare(v.semver, minSemver) >= 0)
+}
+
+/**
+ * Get the current development cycle: latest stable + all newer prereleases
+ */
+export async function getCurrentDevelopmentCycle(repoPath?: string): Promise<DevelopmentCycle> {
+  const latestStable = await getLatestStableVersion(repoPath)
+  if (!latestStable) {
+    // No stable version yet, return all versions as prereleases
+    const allVersions = await getVersions(repoPath)
+    return {
+      stable: null,
+      prereleases: allVersions,
+      all: allVersions,
+    }
+  }
+
+  const allVersions = await getVersions(repoPath)
+  const prereleases = allVersions.filter(
+    v => v.isPrerelease && semverCompare(v.semver, latestStable.semver) > 0,
+  )
+
+  return {
+    stable: latestStable,
+    prereleases,
+    all: [latestStable, ...prereleases],
+  }
+}
+
+/**
+ * Get versions since a specific version (inclusive)
+ */
+export async function getVersionsSince(
+  sinceVersion: string,
+  skipVersions: string[] = [],
+  repoPath?: string,
+): Promise<Version[]> {
+  const sinceSemver = parseSemver(sinceVersion)
+  if (!sinceSemver) {
+    throw new Error(`Invalid version: ${sinceVersion}`)
+  }
+
+  const allVersions = await getVersions(repoPath)
+  return allVersions.filter(v => {
+    // Skip if in skip list
+    if (skipVersions.includes(v.git.tag)) return false
+    // Include if >= sinceVersion
+    return semverCompare(v.semver, sinceSemver) >= 0
+  })
+}
+
+/**
+ * Get all prereleases from past development cycles
+ *
+ * A development cycle is the set of prereleases between stable versions.
+ * This returns all prereleases that are not part of the current development cycle.
+ *
+ * Note: This only returns prereleases. Stable versions are not part of development cycles.
+ */
+export async function getPastDevelopmentCycles(repoPath?: string): Promise<Version[]> {
+  const allVersions = await getVersions(repoPath)
+  const currentCycle = await getCurrentDevelopmentCycle(repoPath)
+  const currentCycleTags = new Set(currentCycle.all.map(v => v.git.tag))
+
+  // Return prereleases not in the current cycle
+  return allVersions.filter(v => {
+    return v.isPrerelease && !currentCycleTags.has(v.git.tag)
+  })
+}
+
+/**
+ * Get a complete registry of all versions and dist-tags
+ */
+export async function getVersionCatalog(repoPath?: string): Promise<VersionCatalog> {
+  const [allVersions, distTagInfos] = await Promise.all([
+    getVersions(repoPath),
+    getDistTags(repoPath),
+  ])
+
+  // Map dist-tags to versions
+  const distTags: VersionCatalog['distTags'] = {}
+  for (const tagInfo of distTagInfos) {
+    if (tagInfo.semverTag) {
+      const version = allVersions.find(v => v.git.tag === tagInfo.semverTag)
+      if (version) {
+        distTags[tagInfo.name] = version
+      }
+    }
+  }
+
+  // Separate stable and prerelease versions
+  const stable = allVersions.filter(v => !v.isPrerelease)
+  const prerelease = allVersions.filter(v => v.isPrerelease)
+
+  return {
+    distTags,
+    versions: allVersions,
+    stable,
+    prerelease,
+  }
+}
+
+// Legacy class export for backward compatibility
+// TODO: Remove this once all usages are migrated
+export class VersionHistory {
+  static parseSemver = parseSemver
+  static isSemverTag = isSemverTag
+  static isPrerelease = isPrerelease
+  static isStableVersion = isStableVersion
+  static getDeploymentPath = getDeploymentPath
+}

package/src/project-data.ts

@@ -3,7 +3,6 @@ import type { Schema } from './api/schema/index.ts'
 
 export interface ProjectData {
   schema: null | Schema.Schema
-  faviconPath: string
   basePath: string
   paths: Config.Config[`paths`][`project`]
   server: {

package/src/sandbox.ts

@@ -0,0 +1,20 @@
+import { filePathToRouteLogical } from '#lib/file-router/scan'
+import { Path } from '@wollybeard/kit'
+
+// Test parsing of numbered directory
+const testPath1 = Path.parse('a/10_b/index.md')
+const logical1 = filePathToRouteLogical(testPath1)
+console.log('Path 1:', testPath1)
+console.log('Logical 1:', logical1)
+
+// Test parsing of numbered file
+const testPath2 = Path.parse('a/10_b/g.md')
+const logical2 = filePathToRouteLogical(testPath2)
+console.log('\nPath 2:', testPath2)
+console.log('Logical 2:', logical2)
+
+// Test directory structure
+const testPath3 = Path.parse('a/30_d/index.md')
+const logical3 = filePathToRouteLogical(testPath3)
+console.log('\nPath 3:', testPath3)
+console.log('Logical 3:', logical3)

package/src/singletons/debug.ts

@@ -1,3 +1,3 @@
 import { Debug } from '@wollybeard/kit'
 
-export const debug = Debug.create(`polen`)
+export const debugPolen = Debug.create(`polen`)