polen 0.10.0-next.14 → 0.10.0-next.3

package/src/lib/task/task.ts

@@ -1,112 +0,0 @@
-import type { Mask } from '#lib/mask'
-import type { Report } from './report.ts'
-import { exitWithReport } from './report.ts'
-
-export interface Definition<$Input = any, $Output = any> {
-  name: string
-  mask?: MaskOptions<$Input, $Output>
-}
-
-export interface Task<$Input, $Output> {
-  (input: $Input): Promise<Report<$Input, $Output>>
-  definition: Definition<$Input, $Output>
-}
-
-export interface MaskOptions<$Input, $Output> {
-  /**
-   * @default true
-   */
-  input?: Mask.InferOptions<$Input>
-  /**
-   * @default true
-   */
-  output?: Mask.InferOptions<$Output>
-}
-
-export const create = <$Input, $Output>(
-  fn: (input: $Input) => Promise<$Output>,
-  options?: {
-    /**
-     * @default the fn name
-     */
-    name?: string
-    /**
-     * An optional default mask to use for successfully returned values.
-     */
-    mask?: MaskOptions<$Input, $Output>
-  },
-): Task<$Input, $Output> => {
-  const definition: Definition<$Input, $Output> = {
-    name: options?.name ?? (fn.name || 'anonymous'),
-    mask: options?.mask,
-  }
-
-  const task = async (input: $Input): Promise<Report<$Input, $Output>> => {
-    const start = performance.now()
-
-    try {
-      const output = await fn(input)
-      const end = performance.now()
-
-      return {
-        task: definition,
-        execution: {
-          input,
-          output,
-          timings: {
-            start,
-            end,
-            duration: end - start,
-          },
-        },
-      }
-    } catch (error) {
-      const end = performance.now()
-
-      return {
-        task: definition,
-        execution: {
-          input,
-          output: error as Error,
-          timings: {
-            start,
-            end,
-            duration: end - start,
-          },
-        },
-      }
-    }
-  }
-
-  task.definition = definition
-
-  return task
-}
-
-/**
- * Sugar method that creates a task, executes it, and exits with the report.
- * Equivalent to: create(fn, options) -> task(input) -> exitWithReport(report)
- *
- * @param fn - The function to wrap as a task
- * @param input - Input to pass to the task
- * @param options - Combined task creation and format options
- */
-export const runAndExit = async <$Input, $Output>(
-  fn: (input: $Input) => Promise<$Output>,
-  input: $Input,
-  options?: {
-    name?: string
-    mask?: MaskOptions<$Input, $Output>
-    debug?: boolean
-  },
-): Promise<never> => {
-  const task = create(fn, {
-    name: options?.name,
-    mask: options?.mask,
-  })
-  const report = await task(input)
-  return exitWithReport(report, {
-    debug: options?.debug,
-    mask: options?.mask,
-  })
-}

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

@@ -1,196 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,68 +0,0 @@
-/**
- * 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

@@ -1,293 +0,0 @@
-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/sandbox.ts

@@ -1,20 +0,0 @@
-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)