zyzz 0.0.7 → 0.0.8

package/src/next/internal/Project.ts

@@ -2,15 +2,13 @@
 import * as Contract from '../../compiler/internal/Contract.js'
 import * as Fs from 'node:fs/promises'
 import * as Graph from '../../compiler/Graph.js'
-import type * as NativeFs from 'node:fs'
 import * as Path from 'node:path'
 import * as Reset from '../../node/Reset.js'
+import * as Stylesheets from '../../compiler/internal/Stylesheets.js'
 import * as Syntax from '../../compiler/internal/Syntax.js'
 
 /** Resolution and dependency notifications supplied by the active loader invocation. */
 export type Context = {
-  /** Track graph membership changes. */
-  addContextDependency(directory: string): void
   /** Track source and contract edits. */
   addDependency(file: string): void
   /** Resolve with the active bundler's aliases and conditions. */
@@ -28,10 +26,6 @@ export type Context = {
 /** Creates project state owned by a loader configuration in one worker process. */
 export function create(options: create.Options) {
   let compiler = Graph.create()
-  const directories = new Map<
-    string,
-    { items: NativeFs.Dirent[]; track: boolean; version: string }
-  >()
   const files = new Map<string, { source: string; version: string }>()
   const libraries = new Map<
     string,
@@ -46,18 +40,19 @@ export function create(options: create.Options) {
 
   return {
     /** Compiles a fresh snapshot while retaining unchanged syntax and graph results. */
-    compile(context: Context, source?: string) {
+    compile(context: Context, source: string) {
       // Loader calls may overlap, but only one immutable snapshot updates the compiler at a time.
       const result = pending.then(async () => {
+        const tracked = new Set<string>()
         try {
-          return await compile(context, source)
+          return await compile(context, source, tracked)
         } catch (error) {
-          // Failed discovery or extraction may leave a partial filesystem snapshot.
+          // Failed resolution or extraction may leave a partial filesystem snapshot.
           compiler = Graph.create()
-          directories.clear()
           files.clear()
           libraries.clear()
           syntax.clear()
+          for (const file of tracked) context.addDependency(file)
           throw error
         }
       })
@@ -72,19 +67,37 @@ export function create(options: create.Options) {
     },
   }
 
-  async function compile(context: Context, source?: string) {
+  async function compile(
+    context: Context,
+    source: string,
+    tracked: Set<string>,
+  ) {
     const root = options.root
+    const runtime = new Set<string>()
+    function track(file: string) {
+      if (tracked.has(file)) return
+      tracked.add(file)
+    }
     const programs = new Map<string, ReturnType<typeof Syntax.parse>>()
-    const seenDirectories = new Set<string>()
-    const seenFiles = new Set<string>()
-    async function read(file: string) {
-      seenFiles.add(file)
+    const reads = new Map<string, Promise<string>>()
+    function read(file: string) {
+      let pending = reads.get(file)
+      if (!pending) {
+        pending = load(file)
+        reads.set(file, pending)
+      }
+      return pending
+    }
+
+    async function load(file: string) {
       const version = await stamp(file)
       let entry = files.get(file)
       if (entry?.version !== version) {
         entry = { source: await Fs.readFile(file, 'utf8'), version }
-        files.set(file, entry)
       }
+      files.delete(file)
+      files.set(file, entry)
+      if (files.size > 256) files.delete(files.keys().next().value!)
       return entry.source
     }
 
@@ -94,7 +107,21 @@ export function create(options: create.Options) {
       Record<string, string | null>
     > = Object.create(null)
     const contracts: Record<string, string> = Object.create(null)
-    const resolve = context.getResolve({})
+    const resolver = context.getResolve({})
+    const resolutions = new Map<string, Promise<string | false | undefined>>()
+    function resolve(directory: string, specifier: string) {
+      const key = JSON.stringify([directory, specifier])
+      let pending = resolutions.get(key)
+      if (!pending) {
+        pending = new Promise<string | false | undefined>((accept, reject) => {
+          resolver(directory, specifier, (error, value) =>
+            error ? reject(error) : accept(value),
+          )
+        })
+        resolutions.set(key, pending)
+      }
+      return pending
+    }
     const id = (file: string) =>
       `app/${Path.relative(root, file).split(Path.sep).join('/')}`
     const eligible = (file: string) =>
@@ -107,70 +134,148 @@ export function create(options: create.Options) {
             part === '..' || part === 'node_modules' || part.startsWith('.'),
         )
 
+    function parse(name: string, source: string) {
+      let entry = syntax.get(name)
+      if (entry?.source !== source)
+        entry = { source, parsed: Syntax.parse({ moduleId: name, source }) }
+      syntax.delete(name)
+      syntax.set(name, entry)
+      if (syntax.size > 256) syntax.delete(syntax.keys().next().value!)
+      return entry.parsed
+    }
+
     async function visit(file: string, text?: string): Promise<void> {
       const name = id(file)
       if (Object.hasOwn(modules, name)) return
 
-      context.addDependency(file)
-      seenFiles.add(file)
+      track(file)
       modules[name] = text ?? (await read(file))
       const links: Record<string, string | null> = Object.create(null)
       imports[name] = links
-      let entry = syntax.get(name)
-      if (entry?.source !== modules[name]) {
-        entry = {
-          source: modules[name]!,
-          parsed: Syntax.parse({ moduleId: name, source: modules[name]! }),
-        }
-        syntax.set(name, entry)
-      }
-      programs.set(name, entry.parsed)
-      const parsed = entry.parsed
+      const parsed = parse(name, modules[name]!)
+      programs.set(name, parsed)
 
-      for (const node of parsed.program.body) {
-        if (
-          (node.type !== 'ImportDeclaration' &&
-            node.type !== 'ExportNamedDeclaration' &&
-            node.type !== 'ExportAllDeclaration') ||
-          !node.source
-        )
-          continue
-        if (
-          node.type === 'ImportDeclaration'
-            ? node.importKind === 'type'
-            : node.exportKind === 'type'
-        )
-          continue
+      const resolutions = await Promise.all(
+        parsed.program.body.map(async (node) => {
+          if (
+            (node.type !== 'ImportDeclaration' &&
+              node.type !== 'ExportNamedDeclaration' &&
+              node.type !== 'ExportAllDeclaration') ||
+            !node.source
+          )
+            return undefined
+          if (
+            node.type === 'ImportDeclaration'
+              ? node.importKind === 'type'
+              : node.exportKind === 'type'
+          )
+            return undefined
 
-        const specifier = node.source.value
-        links[specifier] = null
-        // Next owns this virtual module, which has no physical stylesheet contract.
-        if (specifier === 'next/root-params') continue
-        if (
-          specifier === 'zyzz' ||
-          (specifier.startsWith('zyzz/') && specifier !== 'zyzz/default') ||
-          specifier.startsWith('node:')
-        )
-          continue
+          const specifier = node.source.value
+          links[specifier] = null
+          // Next owns this virtual module, which has no physical stylesheet contract.
+          if (specifier === 'next/root-params') return undefined
+          if (
+            specifier === 'zyzz' ||
+            (specifier.startsWith('zyzz/') && specifier !== 'zyzz/default') ||
+            specifier.startsWith('node:')
+          )
+            return undefined
 
-        const resolved = await new Promise<string | false | undefined>(
-          (accept, reject) => {
-            resolve(Path.dirname(file), specifier, (error, value) =>
-              error ? reject(error) : accept(value),
-            )
-          },
-        )
+          const resolved = await resolve(Path.dirname(file), specifier)
+          return { node, specifier, resolved }
+        }),
+      )
+      for (const resolution of resolutions) {
+        if (!resolution) continue
+        const { node, specifier, resolved } = resolution
         if (!resolved || !/\.[cm]?[jt]sx?$/.test(resolved)) continue
         if (eligible(resolved)) {
+          if (node.type === 'ImportDeclaration' && node.specifiers.length) {
+            track(resolved)
+            const parsed = parse(id(resolved), await read(resolved))
+            const functions = new Set<string>()
+            let defaultBinding: string | undefined
+            for (const statement of parsed.program.body) {
+              if (
+                statement.type === 'ExportDefaultDeclaration' &&
+                [
+                  'FunctionDeclaration',
+                  'ClassDeclaration',
+                  'ArrowFunctionExpression',
+                  'FunctionExpression',
+                ].includes(statement.declaration.type)
+              ) {
+                functions.add('default')
+                if (
+                  statement.declaration.type === 'FunctionDeclaration' ||
+                  statement.declaration.type === 'ClassDeclaration'
+                )
+                  defaultBinding = statement.declaration.id?.name
+              }
+              if (statement.type !== 'ExportNamedDeclaration') continue
+              const declaration = statement.declaration
+              if (
+                (declaration?.type === 'FunctionDeclaration' ||
+                  declaration?.type === 'ClassDeclaration') &&
+                declaration.id
+              )
+                functions.add(declaration.id.name)
+              if (declaration?.type === 'VariableDeclaration')
+                for (const item of declaration.declarations) {
+                  if (
+                    item.id.type === 'Identifier' &&
+                    item.init &&
+                    [
+                      'ArrowFunctionExpression',
+                      'FunctionExpression',
+                      'ClassExpression',
+                    ].includes(item.init.type)
+                  )
+                    functions.add(item.id.name)
+                }
+            }
+            for (const statement of parsed.program.body) {
+              const declaration =
+                statement.type === 'ExportNamedDeclaration'
+                  ? statement.declaration
+                  : statement
+              if (
+                declaration?.type === 'TSModuleDeclaration' &&
+                declaration.id.type === 'Identifier'
+              ) {
+                functions.delete(declaration.id.name)
+                if (declaration.id.name === defaultBinding)
+                  functions.delete('default')
+              }
+            }
+            if (
+              !parsed.errors.length &&
+              node.specifiers.every((specifier) =>
+                specifier.type === 'ImportDefaultSpecifier'
+                  ? functions.has('default')
+                  : specifier.type === 'ImportSpecifier' &&
+                    (specifier.importKind === 'type' ||
+                      functions.has(
+                        specifier.imported.type === 'Identifier'
+                          ? specifier.imported.name
+                          : specifier.imported.value,
+                      )),
+              )
+            ) {
+              runtime.add(resolved)
+              track(resolved)
+              continue
+            }
+          }
           links[specifier] = id(resolved)
           await visit(resolved)
           continue
         }
-
         const sidecar = `${resolved}.zyzz.json`
         try {
           contracts[resolved] = await read(sidecar)
-          context.addDependency(sidecar)
+          track(sidecar)
           links[specifier] = resolved
         } catch (error) {
           if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
@@ -178,48 +283,7 @@ export function create(options: create.Options) {
       }
     }
 
-    async function discover(directory: string): Promise<void> {
-      const version = await stamp(directory)
-      let cached = directories.get(directory)
-      if (cached?.version !== version) {
-        const items = await Fs.readdir(directory, { withFileTypes: true })
-        cached = {
-          items,
-          track:
-            !items.some((item) => item.name === 'node_modules') ||
-            !(await loops(directory)),
-          version,
-        }
-        directories.set(directory, cached)
-      }
-      seenDirectories.add(directory)
-      const items = cached.items
-
-      // Linked package roots are tracked through children to avoid recursive dependency loops.
-      if (cached.track) context.addContextDependency(directory)
-
-      for (const item of items) {
-        if (
-          item.name.startsWith('.') ||
-          [
-            'node_modules',
-            'dist',
-            'build',
-            'coverage',
-            'test',
-            'tests',
-            '__tests__',
-          ].includes(item.name)
-        )
-          continue
-        const file = Path.join(directory, item.name)
-        if (item.isDirectory()) await discover(file)
-        else if (item.isFile() && eligible(file)) await visit(file)
-      }
-    }
-
-    if (source !== undefined) await visit(context.resourcePath, source)
-    await discover(root)
+    await visit(context.resourcePath, source)
     const loaded = new Set<string>()
     async function dependencies(file: string): Promise<void> {
       if (loaded.has(file)) return
@@ -240,13 +304,7 @@ export function create(options: create.Options) {
       for (const dependency of library.dependencies) {
         let owner = file
         for (const specifier of dependency) {
-          const target = await new Promise<string | false | undefined>(
-            (accept, reject) => {
-              resolve(Path.dirname(owner), specifier, (error, value) =>
-                error ? reject(error) : accept(value),
-              )
-            },
-          )
+          const target = await resolve(Path.dirname(owner), specifier)
           if (!target || !Path.isAbsolute(target))
             throw new Error('Unable to resolve packed stylesheet dependency.')
 
@@ -255,7 +313,7 @@ export function create(options: create.Options) {
           if (!Object.hasOwn(contracts, target)) {
             const sidecar = `${target}.zyzz.json`
             contracts[target] = await read(sidecar)
-            context.addDependency(sidecar)
+            track(sidecar)
           }
           await dependencies(target)
           owner = target
@@ -266,20 +324,36 @@ export function create(options: create.Options) {
 
     const graph = compiler.compile({
       [Syntax.cache]: programs,
+      [Stylesheets.entry]: id(context.resourcePath),
       contracts,
+      development: options.development,
       imports,
       modules,
       reset,
     })
 
-    for (const file of files.keys())
-      if (!seenFiles.has(file)) files.delete(file)
-    for (const file of directories.keys())
-      if (!seenDirectories.has(file)) directories.delete(file)
+    const entry = id(context.resourcePath)
+    const output = graph.modules[entry]!
+    // Unchanged runtime modules rely on Next's import graph, not transitive style inputs.
+    if (output.code === source && !output.css) {
+      context.addDependency(context.resourcePath)
+      for (const file of runtime) context.addDependency(file)
+      for (const file of tracked)
+        if (file.endsWith('.zyzz.json')) context.addDependency(file)
+      for (const target of Object.values(imports[entry] ?? {})) {
+        if (!target) continue
+        context.addDependency(
+          target.startsWith('app/')
+            ? Path.join(root, target.slice(4))
+            : `${target}.zyzz.json`,
+        )
+      }
+    } else {
+      for (const file of tracked) context.addDependency(file)
+    }
+
     for (const file of libraries.keys())
       if (!Object.hasOwn(contracts, file)) libraries.delete(file)
-    for (const name of syntax.keys())
-      if (!programs.has(name)) syntax.delete(name)
 
     return graph
   }
@@ -287,8 +361,10 @@ export function create(options: create.Options) {
 
 /** Project cache settings. */
 export declare namespace create {
-  /** Isolates source discovery and shared stylesheet options. */
+  /** Isolates imported source graphs and shared stylesheet options. */
   type Options = {
+    /** Keep development class names stable across value edits. */
+    readonly development?: boolean | undefined
     /** Include the packaged reset in shared CSS. */
     readonly reset?: boolean | undefined
     /** Absolute application directory. */
@@ -300,38 +376,3 @@ async function stamp(file: string) {
   const stat = await Fs.stat(file, { bigint: true })
   return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`
 }
-
-/** Whether an installed dependency links back to the directory or one of its ancestors. */
-async function loops(directory: string): Promise<boolean> {
-  const installed = Path.join(directory, 'node_modules')
-  const entries = await Fs.readdir(installed, { withFileTypes: true }).catch(
-    () => [],
-  )
-  const candidates = (
-    await Promise.all(
-      entries.map(async (entry) => {
-        if (!entry.name.startsWith('@'))
-          return [Path.join(installed, entry.name)]
-
-        const scoped = Path.join(installed, entry.name)
-
-        return (await Fs.readdir(scoped).catch(() => [])).map((name) =>
-          Path.join(scoped, name),
-        )
-      }),
-    )
-  ).flat()
-
-  for (const candidate of candidates) {
-    const stat = await Fs.lstat(candidate).catch(() => undefined)
-    if (!stat?.isSymbolicLink()) continue
-
-    const target = await Fs.realpath(candidate).catch(() => undefined)
-    if (target === undefined) continue
-
-    const relative = Path.relative(target, directory)
-    if (!relative.startsWith('..') && !Path.isAbsolute(relative)) return true
-  }
-
-  return false
-}