zyzz 0.0.27 → 0.0.28

package/src/vite/index.ts

@@ -9,16 +9,24 @@ import * as Contracts from '../node/internal/Contracts.js'
 import * as Mapping from '@jridgewell/gen-mapping'
 import * as Lightning from 'lightningcss'
 import * as Crypto from 'node:crypto'
+import { existsSync } from 'node:fs'
 import * as Fs from 'node:fs/promises'
 import * as Path from 'node:path'
 import * as Reset from '../node/Reset.js'
-import { isBuiltin } from 'node:module'
+import { createRequire, 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 type {
+  DevEnvironment,
+  Environment,
+  Plugin,
+  Rollup,
+  UserConfig,
+  ViteDevServer,
+} from 'vite'
 import * as Graph from '../compiler/Graph.js'
 import * as Source from '../compiler/Source.js'
 import * as ThemeRules from '../web/internal/Themes.js'
@@ -51,6 +59,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   const states = new WeakMap<Environment, Map<string, Entry>>()
   const removed = new WeakMap<Environment, Set<string>>()
   const reads = new WeakMap<Environment, Map<string, string>>()
+  const lookups = new WeakMap<Environment, Lookups>()
   const compilers = new WeakMap<Environment, Graph.create.ReturnType>()
   const packages = Contracts.create()
 
@@ -71,8 +80,11 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   const initializers = new WeakMap<Environment, Entry>()
   const sourceEntrypoints = new Set<string>()
   const identities = new Map<string, string>()
+  const exclusions = new Map<string, boolean>()
   const lazyImports = new WeakMap<Parser.ParseResult, string[]>()
   let directories: readonly string[]
+  let filter: (id: unknown) => boolean
+  let optimizeRuntime = false
   let root: string
 
   function snapshot(environment: Environment) {
@@ -149,10 +161,26 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       Path.isAbsolute(id) &&
       sourceRoot(id) !== undefined &&
       /\.[cm]?[jt]sx?$/.test(id) &&
-      !/\.(?:d|test|test-d|bench|bench-d)\.[cm]?[jt]sx?$/.test(id)
+      !/\.(?:d|test|test-d|bench|bench-d)\.[cm]?[jt]sx?$/.test(id) &&
+      !excluded(id)
     )
   }
 
+  /** Matches excluded files inside source directories. Package files never match, so packed contracts stay readable. */
+  function excluded(id: string) {
+    const file = id.split(/[?#]/)[0]!
+    let value = exclusions.get(file)
+
+    // Vite's filter recompiles each glob per call, and every compile checks each import.
+    if (value === undefined) {
+      value =
+        Path.isAbsolute(file) && sourceRoot(file) !== undefined && !filter(file)
+      exclusions.set(file, value)
+    }
+
+    return value
+  }
+
   function sourceRoot(file: string) {
     return directories.find((directory) => {
       const relative = Path.relative(directory, file)
@@ -355,6 +383,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     event: string,
   ) {
     reads.delete(environment)
+    lookups.delete(environment)
     if (event === 'delete') {
       if (entries(environment).has(file)) {
         let files = removed.get(environment)
@@ -392,9 +421,32 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     allSources = false,
     everything = false,
   ) {
+    // Every compile visits the discovered project, so modules share lookups
+    // until the watcher reports a change. Full-project compiles look up afresh.
+    const cache = (() => {
+      const fresh: Lookups = { contracts: new Map(), resolutions: new Map() }
+      if (everything) return fresh
+
+      let value = lookups.get(entry.environment)
+      if (!value) {
+        value = fresh
+        lookups.set(entry.environment, value)
+      }
+      return value
+    })()
+
     async function resolve(source: string, importer: string) {
       if (isBuiltin(source)) return { id: source, external: true }
-      const resolved = await host.resolve(source, importer)
+
+      const key = `${importer}\0${source}`
+      let pending = cache.resolutions.get(key)
+      if (!pending) {
+        pending = host.resolve(source, importer)
+        cache.resolutions.set(key, pending)
+        pending.catch(() => cache.resolutions.delete(key))
+      }
+
+      const resolved = await pending
       if (!resolved) return resolved
 
       if (entry.environment.mode === 'dev') {
@@ -416,15 +468,41 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     const lazy: Record<string, ReadonlySet<string>> = Object.create(null)
     const modules: Record<string, string> = Object.create(null)
     const files = new Set<string>()
-    const contractHost: Contracts.read.Options = {
-      read: async (file) => {
-        const source = await snapshot(entry.environment).read(file)
-        host.watch(file)
-        files.add(file)
-        return source
-      },
-      resolve: async (specifier, importer) =>
-        (await resolve(specifier, importer))?.id.split(/[?#]/)[0],
+
+    // A package contract derives from the files it reads and the resolutions
+    // above. A cached contract still makes this compile watch those files.
+    async function readContract(file: string, required = false) {
+      const key = `${required}\0${file}`
+      let pending = cache.contracts.get(key)
+      if (!pending) {
+        const read = new Set<string>()
+
+        pending = packages
+          .read(file, {
+            read: async (path) => {
+              const source = await snapshot(entry.environment).read(path)
+              read.add(path)
+              return source
+            },
+            required,
+            resolve: async (specifier, importer) =>
+              (await resolve(specifier, importer))?.id.split(/[?#]/)[0],
+          })
+          .then((contract) => ({ contract, files: read }))
+        cache.contracts.set(key, pending)
+        pending.catch(() => cache.contracts.delete(key))
+      }
+
+      const derived = await pending
+
+      for (const path of derived.files) {
+        if (files.has(path)) continue
+
+        files.add(path)
+        host.watch(path)
+      }
+
+      return derived.contract
     }
 
     async function visit(file: string, source?: string) {
@@ -522,11 +600,18 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
           await visit(resolved.id)
           continue
         }
+
+        // An excluded source stays a runtime import instead of deriving a package contract.
+        if (excluded(resolved.id)) {
+          resolutions[specifier] = null
+          continue
+        }
+
         if (resolved.external || !eligible(resolved.id)) {
           const physical = resolved.id.split('?')[0]!.split('#')[0]!
           const contract =
             Path.isAbsolute(physical) && /\.[cm]?[jt]sx?$/.test(physical)
-              ? await packages.read(physical, contractHost)
+              ? await readContract(physical)
               : undefined
 
           if (contract !== undefined) {
@@ -648,7 +733,11 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
             continue
 
           const resolved = await resolve(specifier, file)
-          if (!resolved || (!resolved.external && eligible(resolved.id)))
+          if (
+            !resolved ||
+            (!resolved.external && eligible(resolved.id)) ||
+            excluded(resolved.id)
+          )
             continue
 
           if (resource(specifier) || resource(resolved.id)) continue
@@ -657,7 +746,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
           if (!Path.isAbsolute(physical) || !/\.[cm]?[jt]sx?$/.test(physical))
             continue
 
-          const contract = await packages.read(physical, contractHost)
+          const contract = await readContract(physical)
           if (contract === undefined) continue
 
           contracts[resolved.id] = contract
@@ -715,9 +804,9 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
           imports[owner] ??= Object.create(null)
           imports[owner]![specifier] = target.id
 
-          contracts[target.id] ??= (await packages.read(
+          contracts[target.id] ??= (await readContract(
             target.id.split(/[?#]/)[0]!,
-            { ...contractHost, required: true },
+            true,
           ))!
 
           await dependencies(target.id)
@@ -995,10 +1084,10 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   async function initializations(server: ViteDevServer) {
     const environment = server.environments.client
     reads.delete(environment)
+    lookups.delete(environment)
     const host: Host = {
       asset: async (file) => file,
-      resolve: (source, importer) =>
-        environment.pluginContainer.resolveId(source, importer),
+      resolve: resolver(environment),
       watch: (file) => server.watcher.add(file),
     }
     const sources = await discover(environment, host)
@@ -1189,10 +1278,17 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   return {
     buildStart() {
       reads.delete(this.environment)
+      lookups.delete(this.environment)
     },
     config: {
       order: 'post',
-      handler(config) {
+      handler(config, env) {
+        // Ordered after other config hooks, so plugin-provided aliases are visible.
+        optimizeRuntime =
+          env.command === 'serve' &&
+          options.compiler !== false &&
+          installed(config)
+
         if (native) return
         // Inline color-scheme changes cannot initialize Lightning's lowered helpers.
         return {
@@ -1221,6 +1317,32 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
         }
       },
     },
+    configEnvironment: {
+      // Plugins without enforce settle their environment options first.
+      order: 'post',
+      handler(name, config) {
+        if (!optimizeRuntime) return
+
+        const optimizeDeps = config.optimizeDeps ?? {}
+        const consumer =
+          config.consumer ?? (name === 'client' ? 'client' : 'server')
+
+        // Vite defaults server environments to noDiscovery. An include list there
+        // would create an explicit optimizer that otherwise never exists.
+        if (optimizeDeps.noDiscovery ?? consumer === 'server') return
+        if (
+          optimizeDeps.include?.includes(runtime) ||
+          optimizeDeps.exclude?.some((id) => id === 'zyzz' || id === runtime)
+        )
+          return
+
+        // Vite scans authored source, so the runtime import that compilation
+        // adds first appears while a request transforms a module. Discovering
+        // it then re-runs the optimizer, and modules loaded before the re-run
+        // can keep a separate copy of a shared dependency such as React.
+        return { optimizeDeps: { include: [runtime] } }
+      },
+    },
     configureServer(server) {
       // Directory watches belong to the server, not module import dependencies.
       server.watcher.add(directories.slice(1))
@@ -1257,6 +1379,14 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
           }),
         )),
       ]
+
+      // Portable build adapters share this module and do not require Vite.
+      const { createFilter } = await import('vite')
+      const patterns = [...configFiles, ...(options.exclude ?? [])]
+
+      filter = createFilter(null, patterns, { resolve: root })
+      exclusions.clear()
+
       if (native) return
       const lightning = (config.css.lightningcss ??= {})
       lightning.include =
@@ -1370,8 +1500,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
           ? await compile(
               first,
               {
-                resolve: (source, importer) =>
-                  this.environment.pluginContainer.resolveId(source, importer),
+                resolve: resolver(this.environment),
                 watch: (file) => {
                   server.watcher.add(file)
                 },
@@ -1465,7 +1594,10 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       const output = await compile(
         entry,
         {
-          resolve: (source, importer) => this.resolve(source, importer),
+          resolve:
+            this.environment.mode === 'dev'
+              ? resolver(this.environment)
+              : (source, importer) => this.resolve(source, importer),
           watch: (file) => this.addWatchFile(file),
           asset: async (file) => {
             const reference = this.emitFile({
@@ -1527,7 +1659,10 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       const output = await compile(
         entry,
         {
-          resolve: (source, importer) => this.resolve(source, importer),
+          resolve:
+            this.environment.mode === 'dev'
+              ? resolver(this.environment)
+              : (source, importer) => this.resolve(source, importer),
           watch: (file) => this.addWatchFile(file),
           asset: async (file) => {
             const reference = this.emitFile({
@@ -1629,8 +1764,7 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
           return await documentCatalogs(
             html,
             context.filename,
-            (source, importer) =>
-              environment.pluginContainer.resolveId(source, importer),
+            resolver(environment),
             state,
           )
         })()
@@ -1666,7 +1800,81 @@ type Host = {
   watch: (file: string) => void
 }
 
+type Lookups = {
+  contracts: Map<
+    string,
+    Promise<{ contract: string | undefined; files: ReadonlySet<string> }>
+  >
+  resolutions: Map<string, ReturnType<Host['resolve']>>
+}
+
+/**
+ * Whether `zyzz/runtime` resolves inside node_modules from the Vite root. Vite
+ * optimizes a discovered import only there, so linked and aliased copies stay
+ * source modules beside the other entrypoints.
+ */
+function installed(config: UserConfig) {
+  const aliases = config.resolve?.alias ?? {}
+  const entries = Array.isArray(aliases)
+    ? aliases
+    : Object.entries(aliases).map(([find, replacement]) => ({
+        find,
+        replacement,
+      }))
+
+  // Matches Vite's alias semantics: a string entry covers its subpaths.
+  if (
+    entries.some((entry) =>
+      typeof entry.find === 'string'
+        ? runtime === entry.find || runtime.startsWith(`${entry.find}/`)
+        : entry.find.test(runtime),
+    )
+  )
+    return false
+
+  try {
+    const require = createRequire(
+      Path.join(Path.resolve(config.root ?? ''), 'package.json'),
+    )
+
+    // Vite keeps a symlinked package at its node_modules path, which Node dereferences.
+    if (config.resolve?.preserveSymlinks)
+      return (require.resolve.paths('zyzz') ?? []).some((directory) =>
+        existsSync(Path.join(directory, 'zyzz/package.json')),
+      )
+
+    return require.resolve(runtime).split(Path.sep).includes('node_modules')
+  } catch {
+    return false
+  }
+}
+
+// Vite forwards `scan` to `resolveId` hooks but leaves it out of its public types.
+type ScanOptions = NonNullable<
+  Parameters<DevEnvironment['pluginContainer']['resolveId']>[2]
+> & { scan: boolean }
+
+const scan: ScanOptions = { scan: true }
+
+/**
+ * Resolves imports read from source before other plugins transform their
+ * importers. Marking them as scans, as Vite's dependency scanner does, keeps the
+ * optimizer from discovering their dependencies and lets plugins tell them apart
+ * from imports that reach the module graph.
+ */
+function resolver(environment: DevEnvironment): Host['resolve'] {
+  return (source, importer) =>
+    environment.pluginContainer.resolveId(source, importer, scan)
+}
+
+// Vite and Vitest load their own configuration modules, which application code never imports.
+const configFiles = [
+  '**/vite.config.*',
+  '**/vitest.config.*',
+  '**/vitest.workspace.*',
+]
 const prefix = '\0zyzz:'
+const runtime = 'zyzz/runtime'
 const sharedId = `${prefix}shared.css`
 
 function cssId(file: string) {
@@ -1679,6 +1887,13 @@ export declare namespace zyzz {
   type Options = {
     /** False retains authored calls and requires explicit identities where needed. */
     readonly compiler?: boolean | undefined
+    /**
+     * Source modules left out of discovery and transforms. Globs resolve against the
+     * Vite root unless they start with `**`, and regular expressions test absolute paths.
+     * Imports of excluded modules stay runtime imports. Vite and Vitest configuration
+     * modules are always excluded.
+     */
+    readonly exclude?: readonly (RegExp | string)[] | undefined
     /** Additional source directories, absolute or relative to the Vite root. */
     readonly include?: readonly string[] | undefined
     /** Native context captured at creation. Disables CSS delivery and initialization scripts. */