polen 0.11.0-next.26 → 0.11.0-next.28

package/src/api/builder/ssg/page-generator.worker.ts

@@ -2,15 +2,11 @@
  * Worker that generates static pages by fetching from servers.
  * This is executed in a worker thread using Effect Worker API.
  */
-import { debugPolen } from '#singletons/debug'
-import { Path, WorkerRunner } from '@effect/platform'
+import { FileSystem, Path, WorkerRunner } from '@effect/platform'
 import { NodeContext, NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
-import { Data, Effect, Layer } from 'effect'
-import { promises as fs } from 'node:fs'
+import { Array, Data, Duration, Effect, Either, Layer } from 'effect'
 import { type GenerateResult, PageMessage } from './worker-messages.js'
 
-const debug = debugPolen.sub(`api:ssg:page-generator`)
-
 // ============================================================================
 // Error Types
 // ============================================================================
@@ -31,85 +27,118 @@ class RouteProcessingError extends Data.Error<{
 // Generate Pages Handler
 // ============================================================================
 
+// Fetch HTML from server using Effect patterns
+const fetchPage = (url: string) =>
+  Effect.gen(function*() {
+    const response = yield* Effect.tryPromise({
+      try: () => fetch(url),
+      catch: (error) => new Error(`Network error: ${error}`),
+    })
+
+    if (!response.ok) {
+      return yield* Effect.fail(
+        new Error(`HTTP ${response.status}: ${response.statusText}`),
+      )
+    }
+
+    return yield* Effect.tryPromise({
+      try: () => response.text(),
+      catch: (error) => new Error(`Failed to read response: ${error}`),
+    })
+  })
+
+// Write HTML to file system
+const writeHtmlFile = (outputPath: string, html: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+
+    const dir = path.dirname(outputPath)
+    yield* fs.makeDirectory(dir, { recursive: true })
+    yield* fs.writeFileString(outputPath, html)
+  })
+
+// Process a single route
+const processRoute = (
+  route: string,
+  serverPort: number,
+  outputDir: string,
+) =>
+  Effect.gen(function*() {
+    const path = yield* Path.Path
+
+    // Fetch the page from the server
+    const url = `http://localhost:${serverPort}${route}`
+    const html = yield* fetchPage(url).pipe(
+      Effect.mapError(error => new RouteProcessingError({ route, cause: error })),
+    )
+
+    // Determine output file path
+    const outputPath = path.join(
+      outputDir,
+      route === '/' ? 'index.html' : `${route.slice(1)}/index.html`,
+    )
+
+    // Write the HTML file
+    yield* writeHtmlFile(outputPath, html).pipe(
+      Effect.mapError(error => new RouteProcessingError({ route, cause: error })),
+    )
+
+    return route
+  })
+
 const handlers = {
   GeneratePages: (
     { routes, serverPort, outputDir }: { routes: readonly string[]; serverPort: number; outputDir: string },
   ) =>
     Effect.gen(function*() {
-      const path = yield* Path.Path
-      const startTime = Date.now()
-      let processedCount = 0
-
-      debug(`Starting batch generation`, {
-        totalRoutes: routes.length,
-        serverPort,
-      })
-
-      // Process each route by fetching from the server
-      for (const route of routes) {
-        yield* Effect.tryPromise({
-          try: async () => {
-            // Fetch the page from the server
-            const url = `http://localhost:${serverPort}${route}`
-            const response = await fetch(url)
-
-            if (!response.ok) {
-              throw new Error(`Failed to fetch ${route}: ${response.status} ${response.statusText}`)
-            }
-
-            const html = await response.text()
-
-            // Determine output file path
-            const outputPath = path.join(
-              outputDir,
-              route === '/' ? 'index.html' : `${route.slice(1)}/index.html`,
-            )
-
-            // Ensure directory exists
-            const dir = path.dirname(outputPath)
-            await fs.mkdir(dir, { recursive: true })
-
-            // Write the HTML file
-            await fs.writeFile(outputPath, html, 'utf-8')
-
-            processedCount++
-
-            // Log progress every 5 routes or on last route
-            if (processedCount % 5 === 0 || processedCount === routes.length) {
-              debug(`Progress`, {
-                processedCount,
-                totalRoutes: routes.length,
-                serverPort,
-              })
-            }
-          },
-          catch: (error) => {
-            debug(`Failed to process route`, { route, error })
-            return new RouteProcessingError({ route, cause: error })
-          },
-        })
-      }
+      yield* Effect.logDebug(`Starting batch generation`).pipe(
+        Effect.annotateLogs({
+          totalRoutes: routes.length,
+          serverPort,
+        }),
+      )
+
+      // Process all routes with timing, collecting both successes and failures
+      const [duration, results] = yield* Effect.forEach(
+        routes,
+        (route, index) =>
+          processRoute(route, serverPort, outputDir).pipe(
+            Effect.tap(() =>
+              // Log progress every 5 routes
+              (index + 1) % 5 === 0 || index === routes.length - 1
+                ? Effect.logDebug(`Progress: ${index + 1}/${routes.length} routes processed`)
+                : Effect.void
+            ),
+            Effect.either, // Convert to Either to capture both success and failure
+          ),
+        { concurrency: 1 }, // Process sequentially to avoid overwhelming the server
+      ).pipe(Effect.timed)
+
+      // Partition results into successes and failures
+      const [failures, successes] = Array.partition(results, Either.isRight)
+      const processedCount = successes.length
 
       const result: GenerateResult = {
-        success: true,
+        success: failures.length === 0,
         processedCount,
-        duration: Date.now() - startTime,
+        duration: Duration.toMillis(duration),
         memoryUsed: process.memoryUsage().heapUsed,
+        ...(failures.length > 0 && {
+          error: `Failed to generate ${failures.length} out of ${routes.length} routes`,
+          failures: failures.map((f) => ({
+            route: f.left.route,
+            error: f.left.cause instanceof Error ? f.left.cause.message : String(f.left.cause),
+          })),
+        }),
       }
 
-      debug(`Batch generation complete`, result)
+      yield* Effect.logDebug(`Batch generation complete`).pipe(
+        Effect.annotateLogs(result),
+      )
+
       return result
-    }).pipe(
-      Effect.catchAll((error) =>
-        Effect.succeed({
-          success: false,
-          processedCount: 0,
-          duration: Date.now() - Date.now(),
-          memoryUsed: process.memoryUsage().heapUsed,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      ),
-    ),
+    }),
 }
 
 // ============================================================================
@@ -120,6 +149,9 @@ const handlers = {
 WorkerRunner.launch(
   Layer.provide(
     WorkerRunner.layerSerialized(PageMessage, handlers),
-    Layer.merge(NodeWorkerRunner.layer, NodeContext.layer),
+    Layer.mergeAll(
+      NodeWorkerRunner.layer,
+      NodeContext.layer,
+    ),
   ),
 ).pipe(NodeRuntime.runMain)

package/src/api/builder/ssg/server-runner.worker.ts

@@ -2,18 +2,15 @@
  * Worker that runs a Polen server for SSG.
  * This is executed in a child process using Effect Worker API.
  */
-import { debugPolen } from '#singletons/debug'
 import { WorkerRunner } from '@effect/platform'
 import { NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
-import { Duration, Effect, Layer, Scope } from 'effect'
+import { Duration, Effect, Layer, Ref, Scope } from 'effect'
 import { spawn } from 'node:child_process'
 import type { ChildProcess } from 'node:child_process'
 import { ServerMessage } from './worker-messages.js'
 
-const debug = debugPolen.sub(`api:ssg:server-runner`)
-
-// Store the server process for cleanup
-let serverProcess: ChildProcess | null = null
+// Store the server process reference for cleanup
+const serverProcessRef = Ref.unsafeMake<ChildProcess | null>(null)
 
 // ============================================================================
 // Handlers
@@ -23,20 +20,21 @@ const handlers = {
   StartServer: ({ serverPath, port }: { serverPath: string; port: number }) =>
     Effect.gen(function*() {
       // If there's already a server running, stop it first
-      if (serverProcess) {
-        serverProcess.kill('SIGTERM')
+      const existingProcess = yield* Ref.get(serverProcessRef)
+      if (existingProcess) {
+        existingProcess.kill('SIGTERM')
         yield* Effect.sleep(Duration.millis(500))
-        if (!serverProcess.killed) {
-          serverProcess.kill('SIGKILL')
+        if (!existingProcess.killed) {
+          existingProcess.kill('SIGKILL')
         }
-        serverProcess = null
+        yield* Ref.set(serverProcessRef, null)
       }
 
       // Start the server process
-      const startServer = Effect.sync((): ChildProcess => {
-        debug(`Starting server with command: node ${serverPath}`)
+      yield* Effect.logDebug(`Starting server with command: node ${serverPath}`)
 
-        serverProcess = spawn('node', [serverPath], {
+      const proc = yield* Effect.sync(() => {
+        const serverProc = spawn('node', [serverPath], {
           env: {
             ...process.env,
             PORT: port.toString(),
@@ -44,18 +42,23 @@ const handlers = {
           stdio: ['ignore', 'pipe', 'pipe'],
         })
 
-        serverProcess.stdout?.on('data', (data) => {
-          debug(`[Server ${port}] stdout`, data.toString().trim())
+        // Log server output
+        serverProc.stdout?.on('data', (data) => {
+          Effect.logDebug(`[Server ${port}] stdout: ${data.toString().trim()}`).pipe(
+            Effect.runSync,
+          )
         })
 
-        serverProcess.stderr?.on('data', (data) => {
-          debug(`[Server ${port}] stderr`, data.toString().trim())
+        serverProc.stderr?.on('data', (data) => {
+          Effect.logDebug(`[Server ${port}] stderr: ${data.toString().trim()}`).pipe(
+            Effect.runSync,
+          )
         })
 
-        return serverProcess
+        return serverProc
       })
 
-      const proc: ChildProcess = yield* startServer
+      yield* Ref.set(serverProcessRef, proc)
 
       // Wait for server to be ready with proper interruption support
       const waitForReady = Effect.async<void>((resume) => {
@@ -80,7 +83,7 @@ const handlers = {
           try {
             const response = await fetch(`http://localhost:${port}/`)
             if (response.ok || response.status === 404) {
-              debug(`[Server ${port}] Ready!`)
+              Effect.logDebug(`[Server ${port}] Ready!`).pipe(Effect.runSync)
               if (checkInterval) clearInterval(checkInterval)
               proc.removeListener('error', errorHandler)
               proc.removeListener('exit', exitHandler)
@@ -114,33 +117,25 @@ const handlers = {
           Effect.die(new Error(`Server on port ${port} failed to start within 30 seconds`))),
       )
 
-      // Add finalizer to ensure cleanup
-      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => {
-          debug(`Finalizer: Stopping server on port ${port}`)
-          if (serverProcess && !serverProcess.killed) {
-            serverProcess.kill('SIGTERM')
-            // Try to kill forcefully after a brief wait
-            setTimeout(() => {
-              if (serverProcess && !serverProcess.killed) {
-                serverProcess.kill('SIGKILL')
-              }
-              serverProcess = null
-            }, 100)
-          }
-        })
-      )
-    }).pipe(Effect.scoped),
-  StopServer: () =>
+      yield* Effect.logDebug(`Server on port ${port} started successfully`)
+    }),
+  StopServer: ({ port }: { port?: number | undefined }) =>
     Effect.gen(function*() {
-      if (serverProcess) {
-        serverProcess.kill('SIGTERM')
+      const serverProc = yield* Ref.get(serverProcessRef)
+      if (serverProc) {
+        if (port !== undefined) {
+          yield* Effect.logDebug(`Stopping server on port ${port}`)
+        }
+        serverProc.kill('SIGTERM')
         // Give it time to shut down gracefully
         yield* Effect.sleep(Duration.millis(500))
-        if (!serverProcess.killed) {
-          serverProcess.kill('SIGKILL')
+        if (!serverProc.killed) {
+          serverProc.kill('SIGKILL')
+        }
+        yield* Ref.set(serverProcessRef, null)
+        if (port !== undefined) {
+          yield* Effect.logDebug(`Server on port ${port} stopped`)
         }
-        serverProcess = null
       }
     }),
 }

package/src/api/builder/ssg/worker-messages.ts

@@ -16,6 +16,14 @@ const GenerateResultSchema = S.Struct({
   duration: S.Number,
   memoryUsed: S.Number,
   error: S.optional(S.String),
+  failures: S.optional(
+    S.Array(
+      S.Struct({
+        route: S.String,
+        error: S.String,
+      }),
+    ),
+  ),
 })
 
 export type GenerateResult = S.Schema.Type<typeof GenerateResultSchema>
@@ -40,7 +48,9 @@ export class StopServerMessage extends S.TaggedRequest<StopServerMessage>()(
   'StopServer',
   {
     failure: S.Never,
-    payload: {},
+    payload: {
+      port: S.optional(S.Number),
+    },
     success: S.Void,
   },
 ) {}

package/src/template/components/ReferenceLink.tsx

@@ -14,6 +14,7 @@ import { Link } from './Link.js'
 export const ReferenceLink = forwardRef<
   HTMLAnchorElement,
   {
+    className?: string
     /** The GraphQL type name */
     type: string
     /** Optional field name for field-specific links */

package/src/template/components/graphql/type-link.tsx

@@ -14,15 +14,27 @@ export const TypeLink: React.FC<{
   const hasDescription = type.description && type.description.trim() !== ''
 
   const linkContent = (
-    // <a href='https://foo.bar'>
-    <ReferenceLink type={type.name}>
-      <Flex align='center' gap='1' display='inline-flex'>
-        <TypeKindIcon kind={kind} />
-        {` `}
-        <Code color={typeKindTokensIndex[kind].color} variant='ghost'>{type.name}</Code>
-      </Flex>
-    </ReferenceLink>
-    // {/*</a>*/}
+    <>
+      <style>
+        {`
+          .type-link-content:hover code:not(:first-child) {
+            text-decoration: underline;
+            text-underline-offset: 2px;
+          }
+        `}
+      </style>
+      <ReferenceLink type={type.name} className='type-link-content'>
+        <Flex
+          align='center'
+          gap='1'
+          display='inline-flex'
+        >
+          <TypeKindIcon kind={kind} />
+          {` `}
+          <Code color={typeKindTokensIndex[kind].color} variant='ghost'>{type.name}</Code>
+        </Flex>
+      </ReferenceLink>
+    </>
   )
 
   // Only show HoverCard if showDescription is true AND description exists

package/src/vite/plugins/routes-manifest.ts

@@ -3,6 +3,7 @@ import { Vite } from '#dep/vite/index'
 import { Catalog } from '#lib/catalog/$'
 import { FileRouter } from '#lib/file-router/$'
 import { SchemaDefinition } from '#lib/schema-definition/$'
+import { Version } from '#lib/version/$'
 import { debugPolen } from '#singletons/debug'
 import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
 import consola from 'consola'
@@ -102,12 +103,14 @@ function processVersionedCatalog(
 ): void {
   for (const schema of Catalog.Versioned.getAll(catalog)) {
     const version = schema.version
-    routes.push(`/reference/version/${version}`)
+    // Properly encode the version to its string representation
+    const versionValue = Version.encodeSync(version)
+    routes.push(`/reference/version/${versionValue}`)
 
     processSchemaDefinition(
       schema.definition,
       routes,
-      `/reference/version/${version}`,
+      `/reference/version/${versionValue}`,
     )
   }
 }

package/build/lib/extensible-data/$.d.ts

@@ -1,2 +0,0 @@
-export * as ExtensibleData from './extensible-data.js';
-//# sourceMappingURL=$.d.ts.map

package/build/lib/extensible-data/$.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/lib/extensible-data/$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA"}

package/build/lib/extensible-data/$.js

@@ -1,2 +0,0 @@
-export * as ExtensibleData from './extensible-data.js';
-//# sourceMappingURL=$.js.map

package/build/lib/extensible-data/$.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$.js","sourceRoot":"","sources":["../../../src/lib/extensible-data/$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA"}

package/build/lib/extensible-data/extensible-data.d.ts

@@ -1,17 +0,0 @@
-import type { ComputedRef } from '@vue/reactivity';
-type Join<$Data> = (chunks: $Data[]) => $Data;
-type Create<$Data> = () => $Data;
-interface DataTypeOperations<$Data> {
-    join: Join<$Data>;
-    create: Create<$Data>;
-}
-export declare const create: <$Data extends object = object>(dataTypeOperations: DataTypeOperations<$Data>) => ExtensibleData<$Data>;
-export declare class ExtensibleData<$Data extends object = object> {
-    value: ComputedRef<$Data>;
-    private namespacedReactiveData;
-    private dataTypeOperations;
-    constructor(dataTypeOperations: DataTypeOperations<$Data>);
-    get(namespace: string): $Data;
-}
-export {};
-//# sourceMappingURL=extensible-data.d.ts.map

package/build/lib/extensible-data/extensible-data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extensible-data.d.ts","sourceRoot":"","sources":["../../../src/lib/extensible-data/extensible-data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,iBAAiB,CAAA;AAEnE,KAAK,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,CAAA;AAC7C,KAAK,MAAM,CAAC,KAAK,IAAI,MAAM,KAAK,CAAA;AAEhC,UAAU,kBAAkB,CAAC,KAAK;IAChC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IACjB,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;CACtB;AAED,eAAO,MAAM,MAAM,GAAI,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,oBAAoB,kBAAkB,CAAC,KAAK,CAAC,0BAElG,CAAA;AAED,qBAAa,cAAc,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IAChD,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,CAI9B;IAEF,OAAO,CAAC,sBAAsB,CAAqC;IAEnE,OAAO,CAAC,kBAAkB,CAA2B;gBAEzC,kBAAkB,EAAE,kBAAkB,CAAC,KAAK,CAAC;IAIzD,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK;CAO9B"}

package/build/lib/extensible-data/extensible-data.js

@@ -1,24 +0,0 @@
-import { computed, reactive } from '@vue/reactivity';
-export const create = (dataTypeOperations) => {
-    return new ExtensibleData(dataTypeOperations);
-};
-export class ExtensibleData {
-    value = computed(() => {
-        const namespacedDataItems = Array.from(this.namespacedReactiveData.values());
-        const data = this.dataTypeOperations.join(namespacedDataItems);
-        return data;
-    });
-    namespacedReactiveData = reactive(new Map());
-    dataTypeOperations;
-    constructor(dataTypeOperations) {
-        this.dataTypeOperations = dataTypeOperations;
-    }
-    get(namespace) {
-        if (!this.namespacedReactiveData.has(namespace)) {
-            const data = this.dataTypeOperations.create();
-            this.namespacedReactiveData.set(namespace, data);
-        }
-        return this.namespacedReactiveData.get(namespace);
-    }
-}
-//# sourceMappingURL=extensible-data.js.map

package/build/lib/extensible-data/extensible-data.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extensible-data.js","sourceRoot":"","sources":["../../../src/lib/extensible-data/extensible-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAWpD,MAAM,CAAC,MAAM,MAAM,GAAG,CAAgC,kBAA6C,EAAE,EAAE;IACrG,OAAO,IAAI,cAAc,CAAQ,kBAAkB,CAAC,CAAA;AACtD,CAAC,CAAA;AAED,MAAM,OAAO,cAAc;IAClB,KAAK,GAAuB,QAAQ,CAAC,GAAG,EAAE;QAC/C,MAAM,mBAAmB,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,CAAA;QAC5E,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,mBAA8B,CAAC,CAAA;QACzE,OAAO,IAAI,CAAA;IACb,CAAC,CAAC,CAAA;IAEM,sBAAsB,GAAG,QAAQ,CAAC,IAAI,GAAG,EAAiB,CAAC,CAAA;IAE3D,kBAAkB,CAA2B;IAErD,YAAY,kBAA6C;QACvD,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAA;IAC9C,CAAC;IAED,GAAG,CAAC,SAAiB;QACnB,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAA;YAC7C,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,EAAE,IAA8B,CAAC,CAAA;QAC5E,CAAC;QACD,OAAO,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAW,CAAA;IAC7D,CAAC;CACF"}

package/build/lib/vite-plugin-reactive-data/$.d.ts

@@ -1,2 +0,0 @@
-export * as VitePluginReactiveData from './vite-plugin-reactive-data.js';
-//# sourceMappingURL=$.d.ts.map

package/build/lib/vite-plugin-reactive-data/$.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/lib/vite-plugin-reactive-data/$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,sBAAsB,MAAM,gCAAgC,CAAA"}

package/build/lib/vite-plugin-reactive-data/$.js

@@ -1,2 +0,0 @@
-export * as VitePluginReactiveData from './vite-plugin-reactive-data.js';
-//# sourceMappingURL=$.js.map

package/build/lib/vite-plugin-reactive-data/$.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$.js","sourceRoot":"","sources":["../../../src/lib/vite-plugin-reactive-data/$.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,sBAAsB,MAAM,gCAAgC,CAAA"}

package/build/lib/vite-plugin-reactive-data/vite-plugin-reactive-data.d.ts

@@ -1,32 +0,0 @@
-import type { VitePluginJson } from '#lib/vite-plugin-json';
-import { type ComputedRef } from '@vue/reactivity';
-import type { Plugin } from 'vite';
-interface ReactiveDataOptions {
-    /**
-     * Virtual module ID (e.g., 'virtual:polen/navbar') that this data will be exported from.
-     * The appropriate extension will be appended automatically based on moduleType.
-     */
-    moduleId: string;
-    /**
-     * The reactive data to expose.
-     * Can be either:
-     * - A Vue computed ref (recommended)
-     * - A function that returns reactive data
-     * - A reactive value directly
-     */
-    data: ComputedRef<object | unknown[]> | (() => object | unknown[]) | object | unknown[];
-    /**
-     * JSON codec to use
-     * Default: JSON
-     * Only used when includeJsonPlugin is true
-     */
-    codec?: VitePluginJson.Codec;
-    /**
-     * Custom plugin name. Can use to help identify this plugin in logs if using many instances of this plugin.
-     @default 'reactive-data'
-     */
-    name?: string;
-}
-export declare const create: (options: ReactiveDataOptions) => Plugin;
-export {};
-//# sourceMappingURL=vite-plugin-reactive-data.d.ts.map

package/build/lib/vite-plugin-reactive-data/vite-plugin-reactive-data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-reactive-data.d.ts","sourceRoot":"","sources":["../../../src/lib/vite-plugin-reactive-data/vite-plugin-reactive-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE3D,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,iBAAiB,CAAA;AACjE,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAA;AAEjD,UAAU,mBAAmB;IAC3B;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;;;OAMG;IACH,IAAI,EAAE,WAAW,CAAC,MAAM,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,MAAM,MAAM,GAAG,OAAO,EAAE,CAAC,GAAG,MAAM,GAAG,OAAO,EAAE,CAAA;IACvF;;;;OAIG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC,KAAK,CAAA;IAC5B;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAID,eAAO,MAAM,MAAM,GAAI,SAAS,mBAAmB,KAAG,MAyFrD,CAAA"}

package/build/lib/vite-plugin-reactive-data/vite-plugin-reactive-data.js

@@ -1,85 +0,0 @@
-import { debugPolen } from '#singletons/debug';
-import { effect, isRef } from '@vue/reactivity';
-const pluginDebug = debugPolen.sub(`vite-reactive-data`);
-export const create = (options) => {
-    const codec = options.codec ?? JSON;
-    const moduleId = options.moduleId;
-    const name = options.name ?? `reactive-data`;
-    const debug = pluginDebug.sub(name);
-    debug(`constructor`, { moduleId });
-    let $server;
-    let $invalidationScheduled = false;
-    const tryInvalidate = () => {
-        $invalidationScheduled = false;
-        if (!$server)
-            throw new Error(`Server not available yet - this should be impossible`);
-        const moduleNode = $server.moduleGraph.getModuleById(moduleId);
-        if (moduleNode) {
-            debug(`invalidate`, { id: moduleNode.id });
-            $server.moduleGraph.invalidateModule(moduleNode);
-        }
-        else {
-            debug(`cannot invalidate`, {
-                reason: `notInModuleGraph`,
-                moduleId,
-                hint: `maybe it was not loaded yet`,
-            });
-        }
-    };
-    const scheduleInvalidate = () => {
-        if ($invalidationScheduled)
-            return; // already scheduled
-        $invalidationScheduled = true;
-        if (!$server)
-            return; // server will flush when ready
-        tryInvalidate();
-    };
-    // Helper to get the current data value
-    const getData = () => {
-        if (isRef(options.data)) {
-            return options.data.value;
-        }
-        else if (typeof options.data === `function`) {
-            return options.data();
-        }
-        else {
-            return options.data;
-        }
-    };
-    // Set up reactive effect immediately
-    effect(() => {
-        // Access data to track dependencies
-        const data = getData();
-        debug(`effect triggered`, { data });
-        scheduleInvalidate();
-    });
-    return {
-        name,
-        configureServer(_server) {
-            debug(`hook configureServer`);
-            $server = _server;
-            if ($invalidationScheduled) {
-                debug(`try invalidate scheduled before server was ready`);
-                tryInvalidate();
-            }
-        },
-        resolveId(id) {
-            if (id === moduleId) {
-                return moduleId;
-            }
-        },
-        // todo make use of Vite's builtin json plugin
-        // for example, call it here somehow
-        load(id) {
-            if (id !== moduleId)
-                return;
-            const data = getData();
-            debug(`hook load`, { data });
-            return {
-                code: codec.stringify(data),
-                map: null,
-            };
-        },
-    };
-};
-//# sourceMappingURL=vite-plugin-reactive-data.js.map