polen 0.11.0-next.15 → 0.11.0-next.16

package/src/lib/version/version.ts

@@ -40,14 +40,14 @@ export const Version = S.transformOrFail(
     decode: (input, _, ast) => {
       // Try parsing as integer first
       if (typeof input === 'number' && Number.isInteger(input)) {
-        return ParseResult.succeed(IntegerVersion.make({ value: input }))
+        return ParseResult.succeed(new IntegerVersion.Integer({ value: input }))
       }
 
       // Try parsing string as integer
       if (typeof input === 'string') {
         const parsed = Number(input)
         if (Number.isInteger(parsed) && parsed.toString() === input) {
-          return ParseResult.succeed(IntegerVersion.make({ value: parsed }))
+          return ParseResult.succeed(new IntegerVersion.Integer({ value: parsed }))
         }
       }
 
@@ -56,7 +56,7 @@ export const Version = S.transformOrFail(
         // Try parsing as semver
         try {
           SemverLib.decodeSync(input) // Validate it's a valid semver
-          return ParseResult.succeed(SemverVersion.make({ value: input }))
+          return ParseResult.succeed(new SemverVersion.Semver({ value: input }))
         } catch {
           // Not a semver, continue
         }
@@ -64,13 +64,13 @@ export const Version = S.transformOrFail(
         // Try parsing as ISO date
         try {
           const dateOnly = DateOnly.decodeSync(input)
-          return ParseResult.succeed(DateVersion.make({ value: dateOnly }))
+          return ParseResult.succeed(new DateVersion.Date({ value: dateOnly }))
         } catch {
           // Not an ISO date, continue
         }
 
         // Fall back to custom version
-        return ParseResult.succeed(CustomVersion.make({ value: input }))
+        return ParseResult.succeed(new CustomVersion.Custom({ value: input }))
       }
 
       return ParseResult.fail(new ParseResult.Type(ast, input))
@@ -90,7 +90,7 @@ export const Version = S.transformOrFail(
   },
 )
 
-export type Version = S.Schema.Type<typeof Version>
+export type Version = typeof Version.Type
 
 // ============================================================================
 // Constructors
@@ -184,31 +184,34 @@ export const fromString = S.decodeSync(Version)
  * Create a semver version
  */
 export const fromSemver = (semver: SemverLib.Semver): Version =>
-  SemverVersion.make({ value: semver.version.toString() })
+  S.decodeSync(SemverVersion.Semver)({ _tag: 'VersionSemver', value: semver.version.toString() })
 
 /**
  * Create a date version
  */
-export const fromDateOnly = (date: DateOnly.DateOnly): Version => DateVersion.make({ value: date })
+export const fromDateOnly = (date: DateOnly.DateOnly): Version =>
+  S.decodeSync(DateVersion.Date)({ _tag: 'VersionDate', value: date })
 
 /**
  * Create an integer version
  */
-export const fromInteger = (value: number): Version => IntegerVersion.make({ value })
+export const fromInteger = (value: number): Version =>
+  S.decodeSync(IntegerVersion.Integer)({ _tag: 'VersionInteger', value })
 
 /**
  * Create a custom version
  */
-export const fromCustom = (value: string): Version => CustomVersion.make({ value })
+export const fromCustom = (value: string): Version =>
+  S.decodeSync(CustomVersion.Custom)({ _tag: 'VersionCustom', value })
 
 // ============================================================================
 // Domain Logic
 // ============================================================================
 
 /**
- * Get the string representation of a version
+ * Synchronously encode a version to its string representation
  */
-export const toString = (version: Version): string => {
+export const encodeSync = (version: Version): string => {
   switch (version._tag) {
     case 'VersionInteger':
       return version.value.toString()

package/src/lib/version-selection/$$.ts

@@ -0,0 +1 @@
+export * from './version-selection.js'

package/src/lib/version-selection/$.ts

@@ -0,0 +1 @@
+export * as VersionCoverage from './$$.js'

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

@@ -0,0 +1,117 @@
+import { S } from '#lib/kit-temp/effect'
+import { Version } from '#lib/version/$'
+import { Array, HashSet, pipe } from 'effect'
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+export const VersionCoverageOne = Version.Version
+export const VersionCoverageSet = S.HashSet(Version.Version)
+
+/**
+ * A selection of versions - either a single version or a set of versions.
+ * Used as keys in versioned documents to map version(s) to document content.
+ */
+export const VersionCoverage = S.Union(
+  VersionCoverageOne,
+  VersionCoverageSet,
+).annotations({
+  identifier: 'VersionCoverage',
+  description: 'A single version or set of versions',
+})
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type VersionCoverage = S.Schema.Type<typeof VersionCoverage>
+
+// ============================================================================
+// Constructors
+// ============================================================================
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+export const is = S.is(VersionCoverage)
+
+export const isSingle = Version.is
+
+export const isSet = (selection: VersionCoverage): selection is HashSet.HashSet<Version.Version> =>
+  !Version.is(selection)
+
+// ============================================================================
+// Codec
+// ============================================================================
+
+export const decode = S.decode(VersionCoverage)
+export const decodeSync = S.decodeSync(VersionCoverage)
+export const encode = S.encode(VersionCoverage)
+export const encodeSync = S.encodeSync(VersionCoverage)
+
+// ============================================================================
+// Equivalence
+// ============================================================================
+
+export const equivalence = S.equivalence(VersionCoverage)
+
+// ============================================================================
+// Domain Logic
+// ============================================================================
+
+/**
+ * Check if a version is contained in a selection
+ */
+export const contains = (
+  versionCoverage: VersionCoverage,
+  version: Version.Version,
+): boolean => {
+  if (Version.is(versionCoverage)) {
+    return Version.equivalence(versionCoverage, version)
+  }
+  return HashSet.has(versionCoverage, version)
+}
+
+/**
+ * Get display label for UI
+ */
+export const toLabel = (versionCoverage: VersionCoverage): string => {
+  return pipe(versionCoverage, encodeSync, Array.ensure, Array.map(_ => _.toString()), Array.join(', '))
+}
+
+/**
+ * Get all versions from a selection
+ */
+export const toVersions = (versionCoverage: VersionCoverage): Version.Version[] => {
+  if (Version.is(versionCoverage)) {
+    return [versionCoverage]
+  }
+  return HashSet.toValues(versionCoverage)
+}
+
+/**
+ * Get the latest (highest) version from a version coverage.
+ * For single versions, returns the version itself.
+ * For version sets, returns the maximum version according to Version ordering.
+ *
+ * @param versionCoverage - The version coverage to get the latest version from
+ * @returns The latest version
+ * @throws {Error} If the version set is empty
+ */
+export const getLatest = (versionCoverage: VersionCoverage): Version.Version => {
+  if (Version.is(versionCoverage)) {
+    return versionCoverage
+  }
+
+  // For HashSet, convert to array and find max
+  const versions = HashSet.toValues(versionCoverage)
+  if (versions.length === 0) {
+    throw new Error('Cannot get latest version from empty version set')
+  }
+
+  // Use Version.max which takes exactly 2 arguments
+  // Reduce the array to find the maximum
+  return versions.reduce((latest, current) => Version.max(latest, current))
+}

package/src/lib/vite-reactive/$$.ts

@@ -0,0 +1 @@
+export * from './reactive-asset-plugin.js'

package/src/lib/vite-reactive/$.ts

@@ -0,0 +1 @@
+export * as ViteReactive from './$$.js'

package/src/lib/vite-reactive/reactive-asset-plugin.ts

@@ -0,0 +1,280 @@
+import type { Vite } from '#dep/vite/index'
+import type { ViteVirtual } from '#lib/vite-virtual'
+import { debugPolen } from '#singletons/debug'
+import { FileSystem } from '@effect/platform'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
+import { Cache, Effect } from 'effect'
+import * as Path from 'node:path'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AssetReader<data, error = never, requirements = never> {
+  read: () => Effect.Effect<data, error, requirements>
+  clear: () => Effect.Effect<void, never, requirements>
+}
+
+export const createAssetReader = <data, error = never, requirements = never>(
+  reader: () => Effect.Effect<data, error, requirements>,
+): AssetReader<data, error, requirements> => {
+  // Use Cache for both caching and concurrent deduplication
+  const cacheService = Cache.make({
+    capacity: 1,
+    timeToLive: Infinity,
+    lookup: reader,
+  })
+
+  return {
+    read: () =>
+      Effect.gen(function*() {
+        const cache = yield* cacheService
+        return yield* cache.get('__constant_key__')
+      }),
+    clear: () =>
+      Effect.gen(function*() {
+        const cache = yield* cacheService
+        yield* cache.invalidateAll
+      }),
+  }
+}
+
+export interface ReactiveAssetPluginOptions<$Data, E = never, R = never> {
+  /**
+   * Name of the asset type (e.g., 'pages', 'examples', 'schema')
+   */
+  name: string
+
+  /**
+   * Asset reader with cache management
+   */
+  reader: AssetReader<$Data, E, R>
+
+  /**
+   * File patterns to watch and check
+   */
+  filePatterns: {
+    /**
+     * Paths or patterns to watch for changes
+     */
+    watch: string[] | (() => string[])
+
+    /**
+     * Check if a file change is relevant to this asset
+     */
+    isRelevant: (file: string) => boolean
+  }
+
+  /**
+   * Virtual modules that depend on this asset data
+   */
+  dependentVirtualModules: ViteVirtual.Identifier.Identifier[]
+
+  /**
+   * Optional asset emission configuration
+   */
+  emit?: {
+    /**
+     * Serializer function that converts data to string content
+     * Can return an Effect for async operations (must have FileSystem requirement if needed)
+     */
+    serializer: (data: Exclude<$Data, null>) => Effect.Effect<string, any, FileSystem.FileSystem> | string
+    /**
+     * Relative path for the emitted asset (e.g., 'schemas/catalog.json')
+     * Used for both dev assets and build assets with appropriate base paths
+     */
+    path: string
+  }
+  /**
+   * Optional hooks for customization
+   */
+  hooks?: {
+    /**
+     * Determines whether a full page reload is needed when data changes.
+     * Return true to trigger full browser reload, false for normal HMR.
+     */
+    shouldFullReload?: (oldData: $Data | null, newData: $Data) => boolean | Promise<boolean>
+    /**
+     * Called when diagnostics are available
+     */
+    onDiagnostics?: (data: $Data) => void | Promise<void>
+  }
+}
+
+// ============================================================================
+// Plugin Factory
+// ============================================================================
+
+/**
+ * Creates a Vite plugin that handles reactive asset updates with cache invalidation
+ * and virtual module coordination.
+ */
+export const ReactiveAssetPlugin = <T, E = never, R = never>(
+  options: ReactiveAssetPluginOptions<T, E, R>,
+): Vite.Plugin => {
+  const debug = debugPolen.sub(`vite-reactive:${options.name}`)
+  let viteServer: Vite.ViteDevServer | null = null
+  let viteConfig: Vite.ResolvedConfig
+
+  const invalidateVirtualModules = (server: Vite.ViteDevServer) => {
+    for (const vm of options.dependentVirtualModules) {
+      const module = server.moduleGraph.getModuleById(vm.id)
+      if (module) {
+        server.moduleGraph.invalidateModule(module)
+        debug(`Invalidated virtual module: ${vm.id}`)
+      }
+    }
+  }
+
+  // Helper to run the Effect reader with the provided layer
+  const runReader = async (reader: () => Effect.Effect<T, E, R>): Promise<T> => {
+    const effect = reader()
+    // Always provide NodeFileSystem.layer for file system operations
+    const finalEffect = effect.pipe(Effect.provide(NodeFileSystem.layer as any))
+    return await Effect.runPromise(finalEffect as Effect.Effect<T, E, never>)
+  }
+
+  const handleAssetChange = async (
+    file: string,
+    event: 'add' | 'unlink' | 'change',
+    server: Vite.ViteDevServer,
+  ): Promise<boolean> => {
+    if (!options.filePatterns.isRelevant(file)) return false
+
+    debug(`${options.name} file ${event}: ${file}`)
+
+    // Get old data if we need to compare
+    let oldData: T | null = null
+    if (options.hooks?.shouldFullReload) {
+      oldData = await runReader(options.reader.read)
+    }
+
+    // Clear cache and re-read
+    await Effect.runPromise(
+      options.reader.clear().pipe(Effect.provide(NodeFileSystem.layer as any)) as Effect.Effect<void, never, never>,
+    )
+    const newData = await runReader(options.reader.read)
+
+    // Run diagnostics hook if provided
+    if (options.hooks?.onDiagnostics) {
+      await options.hooks.onDiagnostics(newData)
+    }
+
+    // Invalidate all dependent virtual modules
+    invalidateVirtualModules(server)
+
+    // Check if full reload is needed
+    let needsFullReload = true
+    if (options.hooks?.shouldFullReload) {
+      needsFullReload = await options.hooks.shouldFullReload(oldData, newData)
+    }
+
+    // Handle asset emission in dev mode
+    if (options.emit && viteServer && newData) {
+      await Effect.runPromise(
+        Effect.gen(function*() {
+          // Run the serializer (could be Effect or plain string)
+          const serializerResult = options.emit!.serializer(newData as Exclude<T, null>)
+          const content = typeof serializerResult === 'string'
+            ? serializerResult
+            : yield* serializerResult
+
+          // Write to dev assets directory (in Vite's cache dir)
+          const devAssetsPath = Path.join(viteConfig.cacheDir, 'assets', options.emit!.path)
+          const devAssetsDir = Path.dirname(devAssetsPath)
+
+          // Create directory and write file using Effect's FileSystem
+          const fs = yield* FileSystem.FileSystem
+          yield* fs.makeDirectory(devAssetsDir, { recursive: true })
+          yield* fs.writeFileString(devAssetsPath, content)
+
+          debug(`Dev assets written: ${options.emit!.path}`)
+        }).pipe(
+          Effect.provide(NodeFileSystem.layer),
+        ),
+      )
+    }
+
+    return needsFullReload
+  }
+
+  return {
+    name: `polen:reactive-${options.name}`,
+
+    configResolved(resolvedConfig) {
+      viteConfig = resolvedConfig
+    },
+
+    configureServer(server) {
+      viteServer = server
+
+      // Set up file watching
+      const watchPaths = typeof options.filePatterns.watch === 'function'
+        ? options.filePatterns.watch()
+        : options.filePatterns.watch
+
+      for (const path of watchPaths) {
+        server.watcher.add(path)
+        debug(`Watching ${options.name} path: ${path}`)
+      }
+
+      // Handle file additions and deletions
+      const handleFileStructureChange = async (file: string, event: 'add' | 'unlink') => {
+        const needsFullReload = await handleAssetChange(file, event, server)
+
+        if (needsFullReload) {
+          debug(`Triggering full reload due to ${event} event`)
+          server.ws.send({ type: 'full-reload' })
+        }
+      }
+
+      server.watcher.on('add', (file) => handleFileStructureChange(file, 'add'))
+      server.watcher.on('unlink', (file) => handleFileStructureChange(file, 'unlink'))
+    },
+
+    async buildStart() {
+      // Handle asset emission in build mode
+      if (options.emit && !viteServer) {
+        // Read the data
+        const data = await runReader(options.reader.read)
+
+        if (!data) {
+          debug(`No data to emit for ${options.name}`)
+          return
+        }
+
+        // Run the serializer
+        const serializerResult = options.emit.serializer(data as Exclude<T, null>)
+        const content = typeof serializerResult === 'string'
+          ? serializerResult
+          : await Effect.runPromise(
+            serializerResult.pipe(
+              Effect.provide(NodeFileSystem.layer),
+            ),
+          )
+
+        // Emit the asset (Vite will place it in the correct output directory)
+        this.emitFile({
+          type: 'asset',
+          fileName: `assets/${options.emit.path}`,
+          source: content,
+        })
+
+        debug(`Build asset emitted: ${options.emit.path}`)
+      }
+    },
+
+    async handleHotUpdate({ file, server, modules }) {
+      const needsFullReload = await handleAssetChange(file, 'change', server)
+
+      if (needsFullReload) {
+        debug(`Triggering full reload due to change event`)
+        server.ws.send({ type: 'full-reload' })
+        return []
+      }
+
+      // Allow normal HMR to proceed
+      return modules
+    },
+  }
+}