zyzz 0.0.7 → 0.0.9

package/src/vite/index.ts

@@ -14,6 +14,8 @@ import * as Reset from '../node/Reset.js'
 import { isBuiltin } from 'node:module'
 import * as Parser from 'oxc-parser'
 import * as Walker from 'oxc-walker'
+import * as Snapshot from '../node/internal/Snapshot.js'
+import * as Syntax from '../compiler/internal/Syntax.js'
 import * as Scope from '../compiler/internal/Scope.js'
 import type { Environment, Plugin, Rollup, ViteDevServer } from 'vite'
 import * as Graph from '../compiler/Graph.js'
@@ -40,7 +42,23 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   if (native && options.compiler === false)
     throw new Error('Native builds require source compilation.')
 
+  const snapshots = new WeakMap<
+    Environment,
+    ReturnType<typeof Snapshot.create>
+  >()
   const states = new WeakMap<Environment, Map<string, Entry>>()
+  const removed = new WeakMap<Environment, Set<string>>()
+  const reads = new WeakMap<Environment, Map<string, string>>()
+  const compilers = new WeakMap<Environment, Graph.create.ReturnType>()
+
+  function compiler(environment: Environment) {
+    let value = compilers.get(environment)
+    if (!value) {
+      value = Graph.create()
+      compilers.set(environment, value)
+    }
+    return value
+  }
   const discoveries = new WeakMap<Environment, Promise<Map<string, string>>>()
   const contributionFiles = new WeakMap<Environment, Set<string>>()
   const assets = new Map<string, string>()
@@ -49,8 +67,19 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   const graphs = new Map<string, ReadonlySet<string>>()
   const initializers = new WeakMap<Environment, Entry>()
   const sourceEntrypoints = new Set<string>()
+  const identities = new Map<string, string>()
+  const lazyImports = new WeakMap<Parser.ParseResult, string[]>()
   let root: string
 
+  function snapshot(environment: Environment) {
+    let value = snapshots.get(environment)
+    if (!value) {
+      value = Snapshot.create()
+      snapshots.set(environment, value)
+    }
+    return value
+  }
+
   function entries(environment: Environment) {
     let state = states.get(environment)
 
@@ -63,7 +92,12 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   }
 
   function sourceId(file: string) {
-    return `app/${Path.relative(root, file).split(Path.sep).join('/')}`
+    let id = identities.get(file)
+    if (!id) {
+      id = `app/${Path.relative(root, file).split(Path.sep).join('/')}`
+      identities.set(file, id)
+    }
+    return id
   }
 
   function resource(id: string) {
@@ -273,7 +307,20 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     file: string,
     event: string,
   ) {
-    if (event === 'delete') entries(environment).delete(file)
+    reads.delete(environment)
+    if (event === 'delete') {
+      if (entries(environment).has(file)) {
+        let files = removed.get(environment)
+        if (!files) {
+          files = new Set()
+          removed.set(environment, files)
+        }
+        files.add(file)
+      }
+      entries(environment).delete(file)
+      snapshot(environment).delete(file, sourceId(file))
+      identities.delete(file)
+    }
 
     const pending = discoveries.get(environment)
     if (!pending || !eager(file)) return
@@ -330,7 +377,17 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       host.watch(file)
 
       const id = sourceId(file)
-      const text = source ?? (await Fs.readFile(file, 'utf8'))
+      let cached = reads.get(entry.environment)
+      if (!cached) {
+        cached = new Map()
+        reads.set(entry.environment, cached)
+      }
+      // Full-project compilation must not reuse reads from concurrent module transforms.
+      const text =
+        source ??
+        (everything ? undefined : cached.get(file)) ??
+        (await snapshot(entry.environment).read(file))
+      if (!everything) cached.set(file, text)
 
       modules[id] = text
 
@@ -338,8 +395,9 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
 
       imports[id] = resolutions
 
-      const parsed = Parser.parseSync('source.tsx', text, {
-        sourceType: 'module',
+      const parsed = snapshot(entry.environment).parse({
+        moduleId: id,
+        source: text,
       })
 
       for (const node of parsed.program.body) {
@@ -433,18 +491,22 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       }
 
       // Lazy imports stay outside this compile but scope the documents that load them.
-      const specifiers: string[] = []
-
-      Walker.walk(parsed.program, {
-        enter(node) {
-          if (
-            node.type === 'ImportExpression' &&
-            node.source.type === 'Literal' &&
-            typeof node.source.value === 'string'
-          )
-            specifiers.push(node.source.value)
-        },
-      })
+      let specifiers = lazyImports.get(parsed)
+      if (!specifiers) {
+        specifiers = []
+        const collected = specifiers
+        Walker.walk(parsed.program, {
+          enter(node) {
+            if (
+              node.type === 'ImportExpression' &&
+              node.source.type === 'Literal' &&
+              typeof node.source.value === 'string'
+            )
+              collected.push(node.source.value)
+          },
+        })
+        lazyImports.set(parsed, specifiers)
+      }
 
       const targets = new Set<string>()
 
@@ -471,8 +533,9 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       const selected = contributionFiles.get(entry.environment)?.has(file)
 
       if (allSources) {
-        const { program } = Parser.parseSync('source.tsx', source, {
-          sourceType: 'module',
+        const { program } = snapshot(entry.environment).parse({
+          moduleId: sourceId(file),
+          source,
         })
         const dynamic: import('@oxc-project/types').ImportExpression[] = []
 
@@ -642,6 +705,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       )
 
     const result = entry.compiler.compile({
+      [Syntax.cache]: snapshot(entry.environment).programs(modules),
       compiler: options.compiler,
       reset: options.reset ? Reset.read() : undefined,
       native,
@@ -656,6 +720,8 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       entry.files = files
       const map = Mapping.toEncodedMap(new Mapping.GenMapping())
       return {
+        imports,
+        modules: result.modules,
         code: output.code,
         contractIds: Object.keys(result.contracts),
         css: '',
@@ -897,6 +963,8 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     entry.files = files
 
     return {
+      imports,
+      modules: result.modules,
       code: output.code,
       contractIds: Object.keys(compiled),
       css: styles.join('\n'),
@@ -915,6 +983,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   /** Compiles every discovered source once so index.html can inline each configuration's script before modules load. */
   async function initializations(server: ViteDevServer) {
     const environment = server.environments.client
+    reads.delete(environment)
     const host: Host = {
       asset: async (file) => file,
       resolve: (source, importer) =>
@@ -930,7 +999,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       if (file === undefined) return []
 
       entry = {
-        compiler: Graph.create(),
+        compiler: compiler(environment),
         environment,
         file,
         files: new Set([file]),
@@ -1097,6 +1166,9 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   }
 
   return {
+    buildStart() {
+      reads.delete(this.environment)
+    },
     config: {
       order: 'post',
       handler(config) {
@@ -1241,27 +1313,73 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     async watchChange(file, change) {
       await updateDiscovery(this.environment, file, change.event)
     },
-    async hotUpdate({ file, modules, timestamp, type }) {
+    async hotUpdate({ file, modules, timestamp, type, server }) {
       await updateDiscovery(this.environment, file, type)
 
-      const affected = new Set(modules)
+      const state = entries(this.environment)
+      const first = [...state.values()].find(
+        (entry) => entry.files.has(file) || eager(file),
+      )
+      if (!first && !removed.get(this.environment)?.has(file)) return modules
+
+      // Failed edits retain normal invalidation so Vite reports errors on reload.
+      const output =
+        first && type === 'update' && eligible(file)
+          ? await compile(
+              first,
+              {
+                resolve: (source, importer) =>
+                  this.environment.pluginContainer.resolveId(source, importer),
+                watch: (file) => {
+                  server.watcher.add(file)
+                },
+                asset: async (file) => file,
+              },
+              undefined,
+              true,
+              true,
+            ).catch(() => undefined)
+          : undefined
+      const affected = new Set(
+        modules.filter((module) => {
+          const entry = module.id && state.get(module.id)
+          return (
+            !output ||
+            !entry ||
+            entry.code !== output.modules[sourceId(entry.file)]?.code ||
+            entry.imports !==
+              JSON.stringify(output.imports[sourceId(entry.file)])
+          )
+        }),
+      )
+      const ids = new Set<string>()
+      if (type === 'delete') ids.add(cssId(file))
 
       for (const entry of entries(this.environment).values()) {
         if (!entry.files.has(file) && !eager(file)) continue
 
         // Theme scopes affect CSS even when Vite's JavaScript import was erased.
-        for (const id of [entry.file, cssId(entry.file), sharedId]) {
-          const module = this.environment.moduleGraph.getModuleById(id)
-          if (!module) continue
-
-          this.environment.moduleGraph.invalidateModule(
-            module,
-            new Set(),
-            timestamp,
-            true,
-          )
-          affected.add(module)
-        }
+        if (
+          !output ||
+          entry.code !== output.modules[sourceId(entry.file)]?.code ||
+          entry.imports !== JSON.stringify(output.imports[sourceId(entry.file)])
+        )
+          ids.add(entry.file)
+        ids.add(cssId(entry.file))
+        ids.add(sharedId)
+      }
+
+      for (const id of ids) {
+        const module = this.environment.moduleGraph.getModuleById(id)
+        if (!module) continue
+
+        this.environment.moduleGraph.invalidateModule(
+          module,
+          new Set(),
+          timestamp,
+          true,
+        )
+        affected.add(module)
       }
 
       return [...affected]
@@ -1278,6 +1396,8 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
         file === undefined
           ? entries(this.environment).values().next().value
           : entries(this.environment).get(file)
+      // A pruned JavaScript module can leave its stylesheet loaded in the browser.
+      if (!entry && file && removed.get(this.environment)?.has(file)) return ''
       if (!entry) throw new Error(`Unknown Zyzz stylesheet: ${file}`)
 
       const output = await compile(
@@ -1333,12 +1453,13 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
 
       if (!entry) {
         entry = {
-          compiler: Graph.create(),
+          compiler: compiler(this.environment),
           environment: this.environment,
           file: id,
           files: new Set([id]),
         }
         state.set(id, entry)
+        removed.get(this.environment)?.delete(id)
       }
 
       const output = await compile(
@@ -1360,6 +1481,9 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
         code,
       )
 
+      entry.imports = JSON.stringify(output.imports[sourceId(entry.file)])
+      entry.code = output.code
+
       if (native) return { code: output.code, map: JSON.stringify(output.map) }
 
       // Keep the CSS dependency even when the current graph has no live rules.
@@ -1459,6 +1583,8 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
 }
 
 type Entry = {
+  code?: string
+  imports?: string
   environment: Environment
   compiler: Graph.create.ReturnType
   file: string