zyzz 0.0.8 → 0.0.11

package/src/vite/index.ts

@@ -47,6 +47,18 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     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>()
@@ -55,6 +67,8 @@ 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) {
@@ -78,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) {
@@ -288,9 +307,19 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
     file: string,
     event: string,
   ) {
+    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)
@@ -348,7 +377,17 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
       host.watch(file)
 
       const id = sourceId(file)
-      const text = source ?? (await snapshot(entry.environment).read(file))
+      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
 
@@ -452,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>()
 
@@ -490,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[] = []
 
@@ -676,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: '',
@@ -917,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'),
@@ -935,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) =>
@@ -950,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]),
@@ -1117,6 +1166,9 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
   }
 
   return {
+    buildStart() {
+      reads.delete(this.environment)
+    },
     config: {
       order: 'post',
       handler(config) {
@@ -1261,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]
@@ -1298,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(
@@ -1353,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(
@@ -1380,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.
@@ -1479,6 +1583,8 @@ export function zyzz(options: zyzz.Options = {}): Plugin {
 }
 
 type Entry = {
+  code?: string
+  imports?: string
   environment: Environment
   compiler: Graph.create.ReturnType
   file: string

package/src/web/colorProfile.ts

@@ -5,16 +5,8 @@ import * as Identity from '../internal/Identity.js'
 import type * as RuleReference from '../internal/RuleReference.js'
 
 /** Emits static descriptors and returns a domain-specific CSS name. */
-export function colorProfile<
-  const options extends Omit<colorProfile.Options, 'renderingIntent'> & {
-    readonly renderingIntent?: string | undefined
-  },
->(
-  options: options &
-    Record<Exclude<keyof options, keyof colorProfile.Options>, never> &
-    RuleReference.Checked<options> & {
-      readonly renderingIntent?: Intent<options['renderingIntent']>
-    },
+export function colorProfile<const options extends Record<string, unknown>>(
+  options: options & NoInfer<Accepted<options>>,
   context: Context.Options = {},
 ): colorProfile.Reference {
   void options
@@ -58,3 +50,26 @@ type Keyword<value extends string> =
     : value extends `${infer rest}${' ' | '\t' | '\n' | '\r' | '\f'}`
       ? Keyword<rest>
       : Lexical.Fold<value>
+
+type Accepted<input> = {
+  [key in keyof input as key extends Context.Group ? key : never]: Accepted<
+    input[key]
+  >
+} & (keyof input extends never
+  ? Definition<input>
+  : Exclude<keyof input, Context.Group> extends never
+    ? unknown
+    : Definition<Omit<input, Context.Group>>)
+
+type Definition<options> = options extends Omit<
+  colorProfile.Options,
+  'renderingIntent'
+> & {
+  readonly renderingIntent?: string | undefined
+}
+  ? options &
+      Record<Exclude<keyof options, keyof colorProfile.Options>, never> &
+      RuleReference.Checked<options> & {
+        readonly renderingIntent?: Intent<options['renderingIntent']>
+      }
+  : never

package/src/web/counterStyle.ts

@@ -5,20 +5,8 @@ import * as Identity from '../internal/Identity.js'
 import type * as RuleReference from '../internal/RuleReference.js'
 
 /** Emits static descriptors and returns a domain-specific CSS name. */
-export function counterStyle<
-  const options extends Omit<counterStyle.Options, 'system'> & {
-    readonly system?: string | undefined
-  },
->(
-  options: options &
-    Record<Exclude<keyof options, keyof counterStyle.Options>, never> &
-    RuleReference.Checked<options> & {
-      readonly system?: Checked<options['system']>
-    } & (System<options['system']> extends 'additive'
-      ? { readonly additiveSymbols: string }
-      : System<options['system']> extends `extends ${string}`
-        ? unknown
-        : { readonly symbols: string }),
+export function counterStyle<const options extends Record<string, unknown>>(
+  options: options & NoInfer<Accepted<options>>,
   context: Context.Options = {},
 ): counterStyle.Reference {
   void options
@@ -80,3 +68,30 @@ type Trim<value extends string> = value extends `${Space}${infer rest}`
   : value extends `${infer rest}${Space}`
     ? Trim<rest>
     : value
+
+type Accepted<input> = {
+  [key in keyof input as key extends Context.Group ? key : never]: Accepted<
+    input[key]
+  >
+} & (keyof input extends never
+  ? Definition<input>
+  : Exclude<keyof input, Context.Group> extends never
+    ? unknown
+    : Definition<Omit<input, Context.Group>>)
+
+type Definition<options> = options extends Omit<
+  counterStyle.Options,
+  'system'
+> & {
+  readonly system?: string | undefined
+}
+  ? options &
+      Record<Exclude<keyof options, keyof counterStyle.Options>, never> &
+      RuleReference.Checked<options> & {
+        readonly system?: Checked<options['system']>
+      } & (System<options['system']> extends 'additive'
+        ? { readonly additiveSymbols: string }
+        : System<options['system']> extends `extends ${string}`
+          ? unknown
+          : { readonly symbols: string })
+  : never

package/src/web/cssFunction.ts

@@ -6,30 +6,14 @@ import type * as Literal from '../internal/Literal.js'
 import * as Identity from '../internal/Identity.js'
 import type * as Numeric from '../internal/Numeric.js'
 /** Emits a CSS function and returns a callable that formats its fixed CSS expression. */
-export function cssFunction<const options extends cssFunction.Options>(
-  options: options &
-    Record<Exclude<keyof options, keyof cssFunction.Options>, never> & {
-      readonly body: Checked<options['body']>
-      readonly parameters: {
-        [index in keyof options['parameters']]: options['parameters'][index] extends {
-          syntax: infer syntax extends string
-        }
-          ? options['parameters'][index] & {
-              readonly syntax: FunctionSyntax.Checked<syntax>
-            }
-          : options['parameters'][index]
-      }
-    } & {
-      readonly returns?: options extends {
-        returns: infer syntax extends string
-      }
-        ? FunctionSyntax.Checked<syntax>
-        : undefined
-    },
+export function cssFunction<const options extends Record<string, unknown>>(
+  options: options & NoInfer<Accepted<options>>,
   context: Context.Options = {},
 ): cssFunction.Reference<
-  options['parameters'],
-  options extends { returns: infer syntax extends cssFunction.Syntax }
+  Definitions<options>['parameters'],
+  Definitions<options> extends {
+    returns: infer syntax extends cssFunction.Syntax
+  }
     ? syntax
     : '*'
 > {
@@ -49,8 +33,10 @@ export function cssFunction<const options extends cssFunction.Options>(
       )
       .join(',') +
     ')') as cssFunction.Reference<
-    options['parameters'],
-    options extends { returns: infer syntax extends cssFunction.Syntax }
+    Definitions<options>['parameters'],
+    Definitions<options> extends {
+      returns: infer syntax extends cssFunction.Syntax
+    }
       ? syntax
       : '*'
   >
@@ -179,3 +165,40 @@ type InputSyntax<syntax extends string> =
                                   | '<transform-list>'
                               ? string
                               : syntax
+
+type Accepted<input> = {
+  [key in keyof input as key extends Context.Group ? key : never]: Accepted<
+    input[key]
+  >
+} & (keyof input extends never
+  ? Definition<input>
+  : Exclude<keyof input, Context.Group> extends never
+    ? unknown
+    : Definition<Omit<input, Context.Group>>)
+
+type Definition<options> = options extends cssFunction.Options
+  ? options &
+      Record<Exclude<keyof options, keyof cssFunction.Options>, never> & {
+        readonly body: Checked<options['body']>
+        readonly parameters: {
+          [index in keyof options['parameters']]: options['parameters'][index] extends {
+            syntax: infer syntax extends string
+          }
+            ? options['parameters'][index] & {
+                readonly syntax: FunctionSyntax.Checked<syntax>
+              }
+            : options['parameters'][index]
+        }
+      } & {
+        readonly returns?: options extends {
+          returns: infer syntax extends string
+        }
+          ? FunctionSyntax.Checked<syntax>
+          : undefined
+      }
+  : never
+
+type Definitions<input> = Extract<
+  Context.Definitions<input>,
+  cssFunction.Options
+>

package/src/web/fontFace.ts

@@ -2,9 +2,8 @@
 import type * as Context from './internal/Context.js'
 
 /** Compiles literal font-face descriptors into the initial stylesheet. */
-export function fontFace<const options extends fontFace.Options>(
-  options: options &
-    Record<Exclude<keyof options, keyof fontFace.Options>, never>,
+export function fontFace<const options extends Record<string, unknown>>(
+  options: options & NoInfer<Accepted<options>>,
   context: Context.Options = {},
 ): void {
   void context
@@ -39,3 +38,17 @@ export declare namespace fontFace {
     readonly lineGapOverride?: 'normal' | `${number}%` | undefined
   }
 }
+
+type Accepted<input> = {
+  [key in keyof input as key extends Context.Group ? key : never]: Accepted<
+    input[key]
+  >
+} & (keyof input extends never
+  ? Definition<input>
+  : Exclude<keyof input, Context.Group> extends never
+    ? unknown
+    : Definition<Omit<input, Context.Group>>)
+
+type Definition<options> = options extends fontFace.Options
+  ? options & Record<Exclude<keyof options, keyof fontFace.Options>, never>
+  : never

package/src/web/fontFeatureValues.ts

@@ -4,25 +4,9 @@ import type * as Lexical from '../internal/Lexical.js'
 
 /** Emits eager font feature aliases in authored block and declaration order. */
 export function fontFeatureValues<
-  const options extends Omit<fontFeatureValues.Options, 'fontDisplay'> & {
-    readonly fontDisplay?: string | undefined
-  },
+  const options extends Record<string, unknown>,
 >(
-  options: options &
-    Record<Exclude<keyof options, keyof fontFeatureValues.Options>, never> & {
-      readonly fontDisplay?: Checked<
-        options['fontDisplay'],
-        Exclude<fontFeatureValues.Options['fontDisplay'], undefined>
-      >
-    } & {
-      readonly features: Record<
-        Exclude<
-          keyof options['features'],
-          keyof fontFeatureValues.Options['features']
-        >,
-        never
-      >
-    },
+  options: options & NoInfer<Accepted<options>>,
   context: Context.Options = {},
 ): void {
   void options
@@ -77,3 +61,36 @@ type Checked<value, domain> = value extends string
     ? value
     : never
   : undefined
+
+type Accepted<input> = {
+  [key in keyof input as key extends Context.Group ? key : never]: Accepted<
+    input[key]
+  >
+} & (keyof input extends never
+  ? Definition<input>
+  : Exclude<keyof input, Context.Group> extends never
+    ? unknown
+    : Definition<Omit<input, Context.Group>>)
+
+type Definition<options> = options extends Omit<
+  fontFeatureValues.Options,
+  'fontDisplay'
+> & {
+  readonly fontDisplay?: string | undefined
+}
+  ? options &
+      Record<Exclude<keyof options, keyof fontFeatureValues.Options>, never> & {
+        readonly fontDisplay?: Checked<
+          options['fontDisplay'],
+          Exclude<fontFeatureValues.Options['fontDisplay'], undefined>
+        >
+      } & {
+        readonly features: Record<
+          Exclude<
+            keyof options['features'],
+            keyof fontFeatureValues.Options['features']
+          >,
+          never
+        >
+      }
+  : never

package/src/web/fontPaletteValues.ts

@@ -5,18 +5,9 @@ import type * as Context from './internal/Context.js'
 
 /** Emits static descriptors and returns a domain-specific CSS name. */
 export function fontPaletteValues<
-  const options extends fontPaletteValues.Options,
+  const options extends Record<string, unknown>,
 >(
-  options: options &
-    Record<Exclude<keyof options, keyof fontPaletteValues.Options>, never> &
-    RuleReference.Checked<options> &
-    (options extends { basePalette: infer value extends number }
-      ? `${value}` extends `${bigint}`
-        ? `${value}` extends `-${string}`
-          ? never
-          : unknown
-        : never
-      : unknown),
+  options: options & NoInfer<Accepted<options>>,
   context: Context.Options = {},
 ): fontPaletteValues.Reference {
   void options
@@ -40,3 +31,26 @@ export declare namespace fontPaletteValues {
   /** Compiler-owned reference usable in the matching CSS domain. */
   type Reference = RuleReference.Reference<'fontPaletteValues'>
 }
+
+type Accepted<input> = {
+  [key in keyof input as key extends Context.Group ? key : never]: Accepted<
+    input[key]
+  >
+} & (keyof input extends never
+  ? Definition<input>
+  : Exclude<keyof input, Context.Group> extends never
+    ? unknown
+    : Definition<Omit<input, Context.Group>>)
+
+type Definition<options> = options extends fontPaletteValues.Options
+  ? options &
+      Record<Exclude<keyof options, keyof fontPaletteValues.Options>, never> &
+      RuleReference.Checked<options> &
+      (options extends { basePalette: infer value extends number }
+        ? `${value}` extends `${bigint}`
+          ? `${value}` extends `-${string}`
+            ? never
+            : unknown
+          : never
+        : unknown)
+  : never

package/src/web/internal/Context.ts

@@ -7,10 +7,16 @@ export type Group =
   | `@layer ${string}`
   | `@media ${string}`
   | `@supports ${string}`
-/** Ordered enclosing groups, from outermost to innermost. */
+/** Identity options for stylesheet declarations. */
 export type Options = {
   /** Explicit identity for named declarations without source rewriting. */
   readonly id?: string | undefined
-  /** Enclosing groups; omitted means stylesheet scope. */
-  readonly within?: readonly Group[] | undefined
 }
+
+/** Complete definitions nested inside enclosing group keys. */
+export type Definitions<input> =
+  input extends Record<string, unknown>
+    ? Exclude<keyof input, Group> extends never
+      ? Definitions<input[keyof input]>
+      : Omit<input, Group>
+    : never