@kudzujs/core 0.8.21 → 0.8.23

package/framework/compiler/source-graph.mjs

@@ -0,0 +1,29 @@
+import { dirname, extname, join, relative, resolve } from "node:path"
+import ts from "typescript"
+
+const root = process.cwd()
+
+export function resolveSourceImport(importer, specifier, sourceFiles) {
+  const base = resolve(dirname(importer), specifier)
+  const extension = extname(base)
+  const stem = /\.(?:js|jsx|ts|tsx)$/.test(extension) ? base.slice(0, -extension.length) : base
+  const candidates = extension === ".ts" || extension === ".tsx"
+    ? [base]
+    : [`${stem}.ts`, `${stem}.tsx`, join(stem, "index.ts"), join(stem, "index.tsx")]
+  const matches = candidates.filter(candidate => sourceFiles.has(candidate))
+  if (matches.length !== 1) throw new Error(`${relative(root, importer)} Relative import ${JSON.stringify(specifier)} must resolve to one TypeScript file in src/`)
+  return matches[0]
+}
+
+export function runtimeModuleReference(node) {
+  if (ts.isExportDeclaration(node)) return !node.isTypeOnly && (!node.exportClause || !ts.isNamedExports(node.exportClause) || node.exportClause.elements.some(entry => !entry.isTypeOnly))
+  const clause = node.importClause
+  if (!clause) return true
+  if (clause.isTypeOnly) return false
+  if (clause.name || clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) return true
+  return clause.namedBindings?.elements.some(entry => !entry.isTypeOnly) ?? false
+}
+
+export function parseSourceFile(file, source) {
+  return ts.createSourceFile(file, source, ts.ScriptTarget.ES2022, true, file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS)
+}

package/framework/compiler/worker-compiler.mjs

@@ -4,11 +4,12 @@ import { dirname, relative, resolve, sep } from "node:path"
 import { build as bundle } from "esbuild"
 import ts from "typescript"
 import { containsJsx, isUnshadowedGlobal, nearestFunction, sourceNodeError } from "./ast-helpers.mjs"
+import { assetPath } from "./path-helpers.mjs"
+import { parseSourceFile, resolveSourceImport, runtimeModuleReference } from "./source-graph.mjs"
 
 export function createWorkerCompiler({
   root,
   sourceDirectory,
-  outputDirectory,
   assetPath,
   parseSourceFile,
   resolveSourceImport,
@@ -158,7 +159,7 @@ export function createWorkerCompiler({
       const entry = resolve(root, metadata.entryPoint)
       const rootReferences = references.filter(reference => resolve(sourceDirectory, reference.root) === entry)
       const outputFile = resolve(root, output)
-      const url = assetPath(base, relative(outputDirectory, outputFile).replaceAll(sep, "/"))
+      const url = assetPath(base, relative(resolve(assetsDirectory, ".."), outputFile).replaceAll(sep, "/"))
       for (const reference of rootReferences) emitted.set(reference.placeholder, url)
     }
     for (const reference of references) if (!emitted.has(reference.placeholder)) throw new Error(`Worker entry was not emitted: ${reference.root}`)
@@ -167,3 +168,9 @@ export function createWorkerCompiler({
 
   return { candidate, emit, rejectConstructions, rejectOrdinaryImports, rewriteEffect }
 }
+
+export function emitWorkers(references, sourceFiles, assetsDirectory, base, minify) {
+  const root = process.cwd()
+  const sourceDirectory = resolve(root, "src")
+  return createWorkerCompiler({ root, sourceDirectory, assetPath, parseSourceFile, resolveSourceImport, runtimeModuleReference }).emit(references, sourceFiles, assetsDirectory, base, minify)
+}

package/framework/core.d.ts

@@ -131,6 +131,46 @@ export type ListDescriptor = {
   valueSeed?: Record<string, string | number | boolean | null>
 }
 
+export interface RouteIR {
+  version: 1
+  states: Array<{ slot: number; id: string; name: string; initialValue: unknown; lifetime?: "layout" | "route"; internal?: true }>
+  params: Array<{ name: string; id: string }>
+  searchParams: Array<{ name: string; id: string }>
+  searchParamsWritable: boolean
+  events: Array<{
+    event: string
+    commands?: Array<[string, string, unknown]>
+    native?: { module: string; handler: string; states: Record<string, string>; scope: Record<string, unknown> }
+  }>
+  effects: Array<{
+    module: string
+    handler: string
+    states: Record<string, string>
+    scope: Record<string, unknown>
+    lifetime?: "layout" | "route"
+    dependencies?: string[]
+    dependencyExpressions?: unknown[]
+    dependencyStates?: Record<string, string>
+    itemDependencies?: string[]
+    listState?: string
+    cleanup?: true
+    owner?: string
+    list?: true
+  }>
+  bindings: Array<{
+    target: string
+    state?: string
+    module?: string
+    handler?: string
+    states?: Record<string, string>
+    scope?: Record<string, unknown>
+    scopeStates?: Record<string, string>
+    scopeBindings?: Record<string, unknown>
+  }>
+  conditions: Array<Record<string, unknown>>
+  lists: ListDescriptor[]
+}
+
 export function renderPage<Props = Record<string, never>>(
   component: (props: Props) => unknown | Promise<unknown>,
   metadata?: PageMetadata,
@@ -146,42 +186,5 @@ export function renderPage<Props = Record<string, never>>(
   hasListStyles: boolean
   hasStateSeed: boolean
   handlerModules: string[]
-  plan: {
-    states: Array<{ id: string; name: string; initialValue: unknown; lifetime?: "layout" | "route"; internal?: true }>
-    params: Array<{ name: string; id: string }>
-    searchParams: Array<{ name: string; id: string }>
-    searchParamsWritable: boolean
-    events: Array<{
-      event: string
-      commands?: Array<[string, string, unknown]>
-      native?: { module: string; handler: string; states: Record<string, string>; scope: Record<string, unknown> }
-    }>
-    effects: Array<{
-      module: string
-      handler: string
-      states: Record<string, string>
-      scope: Record<string, unknown>
-      lifetime?: "layout" | "route"
-      dependencies?: string[]
-      dependencyExpressions?: unknown[]
-      dependencyStates?: Record<string, string>
-      itemDependencies?: string[]
-      listState?: string
-      cleanup?: true
-      owner?: string
-      list?: true
-    }>
-    bindings: Array<{
-      target: string
-      state?: string
-      module?: string
-      handler?: string
-      states?: Record<string, string>
-      scope?: Record<string, unknown>
-      scopeStates?: Record<string, string>
-      scopeBindings?: Record<string, unknown>
-    }>
-    conditions: Array<Record<string, unknown>>
-    lists: ListDescriptor[]
-  }
+  plan: RouteIR
 }>

package/framework/core.mjs

@@ -527,7 +527,8 @@ export async function renderPage(component, metadata = {}, props = {}, layout) {
       hasStateSeed: initialState.length > 0,
       handlerModules: [...renderContext.handlerModules],
       plan: {
-        states: Object.entries(renderContext.states).map(([id, state]) => ({ id, ...state })),
+        version: 1,
+        states: Object.entries(renderContext.states).map(([id, state], slot) => ({ slot, id, ...state })),
         params: renderContext.paramEntries,
         searchParams: renderContext.searchParamEntries,
         searchParamsWritable: renderContext.searchParamsWritable,

package/framework/dev-server.mjs

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto"
 import { readFile, stat, watch } from "node:fs/promises"
 import { createServer } from "node:http"
 import { extname, join, resolve, sep } from "node:path"
+import { browserPath, withBase } from "./compiler/path-helpers.mjs"
 import { stateSchema } from "./dev-state.js"
 
 const devClient = (session, revision, schema) => `<script>(()=>{const show=event=>{let box=document.getElementById("__kudzu_error");if(!box){box=document.createElement("div");box.id="__kudzu_error";box.setAttribute("role","alert");box.setAttribute("aria-live","assertive");box.style.cssText="position:fixed;inset:0;z-index:2147483647;overflow:auto;padding:2rem;background:#200;color:#fff;font:16px/1.5 ui-monospace,monospace";const title=document.createElement("strong"),text=document.createElement("pre");title.textContent="Kudzu build error";text.style.whiteSpace="pre-wrap";box.append(title,text);document.body.append(box)}box.querySelector("pre").textContent=event.data};const schema=${inlineJson(schema)},route=location.pathname+location.search+location.hash,urls=[...document.querySelectorAll('script[type="module"][src]')].map(node=>node.src).filter(url=>/\/assets\/kudzu(?:-(?:binding|list|native))?\.js$/.test(new URL(url).pathname));const devImport=import("/__kudzu_dev.js"),runtimeImports=Promise.allSettled(urls.map(url=>import(url)));const ready=(async()=>{const dev=await devImport,modules=await runtimeImports,runtime=modules.find(result=>result.status==="fulfilled"&&result.value.browserState instanceof Map&&typeof result.value.commitDom==="function")?.value;try{dev.restoreState(sessionStorage,route,runtime?.browserState,schema,runtime?.commitDom)}catch{}return{dev,runtime}})().catch(()=>({}));const events=new EventSource("/__kudzu_reload?session=${session}&revision=${revision}");let reloading=false;events.addEventListener("reload",async()=>{if(reloading)return;reloading=true;try{const{dev,runtime}=await ready;dev?.snapshotState(sessionStorage,route,runtime?.browserState,schema)}catch{}location.reload()});events.addEventListener("build-error",show)})()</script>`
@@ -216,14 +217,6 @@ function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
 }
 
-function browserPath(path) {
-  return path ? new URL(path, "http://kudzu.local").pathname : ""
-}
-
-function withBase(base, path) {
-  return base ? `${base}${path}` : path
-}
-
 async function exists(path) {
   try {
     await stat(path)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.8.21",
+  "version": "0.8.23",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",