zyzz 0.0.24 → 0.0.25

package/src/compiler/Graph.ts

@@ -46,6 +46,8 @@ export declare namespace compile {
     readonly [ThemeRules.shared]?: 'all' | 'defaults' | undefined
     /** Host entrypoints emit owned stylesheet effects without packed contracts. */
     readonly [Stylesheets.entry]?: string | undefined
+    /** Lets modules reuse shared rule names from unrelated modules of this one graph. */
+    readonly [ClassName.complete]?: boolean | undefined
     /** Host syntax from the same immutable source snapshot. */
     readonly [Syntax.cache]?:
       | ReadonlyMap<string, Parser.ParseResult>
@@ -1682,6 +1684,37 @@ function build(options: compile.Options, cache?: Cache): Cache {
   )
 
   const ownerSignature = JSON.stringify(owners)
+  const units = ClassName.registry()
+  const closures = new Map<string, ReadonlySet<string>>()
+
+  function closure(moduleId: string): ReadonlySet<string> {
+    const cached = closures.get(moduleId)
+    if (cached) return cached
+
+    const result = new Set<string>()
+    closures.set(moduleId, result)
+    for (const dependency of dependencies[moduleId] ?? []) {
+      result.add(dependency)
+      for (const nested of closure(dependency)) result.add(nested)
+    }
+
+    return result
+  }
+
+  // Hosts that compile a module within several graphs must name it the same in
+  // each, so it may reuse only names its dependencies introduce.
+  function visible(moduleId: string) {
+    if (options[ClassName.complete]) return undefined
+    return (owner: string) => closure(moduleId).has(owner)
+  }
+
+  function restore(moduleId: string, output: Transform.compile.ReturnType) {
+    return units.restore({
+      owner: moduleId,
+      used: output[ClassName.units] ?? new Map(),
+      visible: visible(moduleId),
+    })
+  }
 
   // Extraction visits dependencies first; their emitted classes must precede consumers.
   for (const moduleId of extracted.keys()) {
@@ -1695,14 +1728,21 @@ function build(options: compile.Options, cache?: Cache): Cache {
       Object.entries(cached.classes).every(
         ([name, value]) => styleClasses[name] === value,
       ) &&
-      cached.owners === ownerSignature
+      cached.owners === ownerSignature &&
+      restore(moduleId, cached.output)
     modules[moduleId] = reusable
       ? cached.output
       : sameThemes &&
           previous!.schemes === schemes &&
-          extracted.get(moduleId) === previous!.extracted.get(moduleId)
+          extracted.get(moduleId) === previous!.extracted.get(moduleId) &&
+          restore(moduleId, previous!.result.modules[moduleId]!)
         ? previous!.result.modules[moduleId]!
         : Transform.compile({
+            [ClassName.units]: units.scope({
+              owner: moduleId,
+              qualifier: Identity.compact(moduleId).slice(-6),
+              visible: visible(moduleId),
+            }),
             [ThemeRules.shared]:
               options[Stylesheets.entry] === undefined
                 ? (options[ThemeRules.shared] ?? 'defaults')

package/src/compiler/Source.ts

@@ -1291,11 +1291,19 @@ export function extract(options: extract.Options): extract.ReturnType {
 
       if (diagnostics.length !== before) continue
 
-      const cssOutput = themes?.styles.get(call.start)?.theme[Token.definition]
-        .contract.cssOutput
+      const contract = themes?.styles.get(call.start)?.theme[Token.definition]
+        .contract
+      const composition = contract?.composition
+      const cssOutput = contract?.cssOutput
       styles.push(
         ...definition.styles.map((style) =>
-          cssOutput ? Object.freeze({ ...style, cssOutput }) : style,
+          composition || cssOutput
+            ? Object.freeze({
+                ...style,
+                ...(composition ? { composition } : {}),
+                ...(cssOutput ? { cssOutput } : {}),
+              })
+            : style,
         ),
       )
 

package/src/compiler/Transform.ts

@@ -9,6 +9,7 @@ import type * as Ast from '@oxc-project/types'
 import * as Css from '../web/Css.js'
 import * as ClassName from '../web/internal/ClassName.js'
 import * as Expression from './internal/Expression.js'
+import * as Identity from '../internal/Identity.js'
 import MagicString from 'magic-string'
 import * as Mapping from '@jridgewell/gen-mapping'
 import * as Namespaces from './internal/Namespaces.js'
@@ -183,6 +184,47 @@ export function compile(options: compile.Options): compile.ReturnType {
     },
   })
 
+  const found = localApplications?.find() ?? []
+  // Compositions supersede their inputs' classes, so those reads stay unfolded.
+  const composing = (application: Span) =>
+    extracted.calls.some(
+      (call) =>
+        (call.composition || call.runtimeComposition) &&
+        call.start < application.start &&
+        application.end <= call.end,
+    )
+  const folded = new Set(
+    found.filter(
+      (application) =>
+        !composing(application) &&
+        !extracted.calls.some(
+          (call) =>
+            call.output === 'html' &&
+            call.runtimeComposition?.some(
+              (input) => input.applicationStart === application.start,
+            ),
+        ),
+    ),
+  )
+
+  const local =
+    portable || options.development
+      ? undefined
+      : localApplications?.definitions()
+
+  // Styles applied only alone to DOM elements, or inside cx, never meet another
+  // style's classes. Atomic ones share rules like independent styles.
+  const standalone = new Set(
+    [...(local?.values.keys() ?? [])].filter((name) =>
+      found.every(
+        (application) =>
+          application.name !== name ||
+          application.terminal ||
+          composing(application),
+      ),
+    ),
+  )
+
   // Scheme rules accompany modules whose runtime helpers can apply a scheme class.
   const schemes =
     options.schemes ??
@@ -196,6 +238,12 @@ export function compile(options: compile.Options): compile.ReturnType {
     [ThemeRules.shared]: options[ThemeRules.shared],
     development: options.development,
     [ClassName.labels]: extracted.styles[ClassName.labels],
+    [ClassName.units]:
+      options[ClassName.units] ??
+      ClassName.registry().scope({
+        owner: options.moduleId,
+        qualifier: Identity.compact(options.moduleId).slice(-6),
+      }),
     composition: options.composition,
     cssOutput: options.cssOutput,
     names: portable ? portableNames : undefined,
@@ -206,14 +254,23 @@ export function compile(options: compile.Options): compile.ReturnType {
       if (portable || options.development) return extracted.styles
 
       const dead = localApplications?.dead()
-      if (!dead?.size) return extracted.styles
+      if (!dead?.size && !standalone.size) return extracted.styles
 
       return {
-        styles: extracted.styles.styles.map((style) =>
-          dead.has(style.name)
-            ? { cssOutput: style.cssOutput, declarations: [], name: style.name }
-            : style,
-        ),
+        styles: extracted.styles.styles.map((style) => {
+          if (dead?.has(style.name))
+            return {
+              cssOutput: style.cssOutput,
+              declarations: [],
+              name: style.name,
+            }
+
+          // Grouped output keeps one class per style.
+          return standalone.has(style.name) &&
+            (style.cssOutput ?? options.cssOutput ?? 'atomic') === 'atomic'
+            ? { ...style, composition: 'independent' as const }
+            : style
+        }),
       }
     })(),
     contributions: extracted.contributions,
@@ -319,6 +376,35 @@ export function compile(options: compile.Options): compile.ReturnType {
     ),
   )
 
+  // Definitions read only through folded applications need no class list of
+  // their own. True marks definitions whose every read follows initialization.
+  const unread = new Map(
+    [...(local?.values ?? [])].filter(([name]) =>
+      found.every(
+        (application) => application.name !== name || folded.has(application),
+      ),
+    ),
+  )
+  const namespaces = (local?.namespaces ?? []).filter((namespace) =>
+    [...namespace.ends.keys()].every((name) => unread.get(name)),
+  )
+
+  const erased = new Map(namespaces.flatMap((namespace) => [...namespace.ends]))
+
+  // An ambient namespace keeps member types without runtime initialization.
+  for (const namespace of namespaces)
+    module.prependRight(namespace.start, 'declare ')
+
+  for (const call of extracted.calls) {
+    const end = erased.get(call.name)
+    if (end !== undefined)
+      module.overwrite(
+        end,
+        call.start,
+        `: import('zyzz').style.ReturnType${call.output === 'html' ? "<'html'>" : ''}`,
+      )
+  }
+
   let callable = false
 
   const composed = (node: Span) =>
@@ -438,6 +524,17 @@ export function compile(options: compile.Options): compile.ReturnType {
         return typed ? `(${result} as ${type})` : result
       }
 
+      const initialized = unread.get(call.name)
+      if (initialized !== undefined) {
+        if (erased.has(call.name)) return ''
+
+        // Guards read only truthiness, and failures before initialization still call it.
+        const value = initialized ? 'void 0' : '1'
+        return /\.[cm]?tsx?$/.test(options.moduleId)
+          ? `(${value} as unknown as import('zyzz').style.ReturnType${call.output === 'html' ? "<'html'>" : ''})`
+          : value
+      }
+
       if (application.folded)
         return composeHtml
           ? `${compositionHtml}.from({className:${JSON.stringify(classes[call.name])}})`
@@ -463,31 +560,13 @@ export function compile(options: compile.Options): compile.ReturnType {
       !call.slots &&
       !call.runtimeComposition &&
       !application.folded &&
+      !unread.has(call.name) &&
       call.output !== 'html'
     )
       callable = true
   }
 
-  for (const application of localApplications?.find() ?? []) {
-    if (
-      extracted.calls.some(
-        (call) =>
-          call.output === 'html' &&
-          call.runtimeComposition?.some(
-            (input) => input.applicationStart === application.start,
-          ),
-      )
-    )
-      continue
-    if (
-      extracted.calls.some(
-        (call) =>
-          (call.composition || call.runtimeComposition) &&
-          call.start < application.start &&
-          application.end <= call.end,
-      )
-    )
-      continue
+  for (const application of folded) {
     const className = JSON.stringify(classes[application.name])
 
     const key =
@@ -495,12 +574,18 @@ export function compile(options: compile.Options): compile.ReturnType {
       'html'
         ? 'class'
         : 'className'
+    const callee = options.source.slice(
+      application.start,
+      application.calleeEnd,
+    )
 
-    // Keep a callable guard so bundlers also retain failures before initialization.
     module.overwrite(
       application.start,
       application.end,
-      `(${options.source.slice(application.start, application.calleeEnd)}?{${key}:${className}}:${options.source.slice(application.start, application.calleeEnd)}())`,
+      application.initialized
+        ? `({${key}:${className}})`
+        : // Keep a callable guard so bundlers also retain failures before initialization.
+          `(${callee}?{${key}:${className}}:${callee}())`,
     )
   }
 
@@ -688,7 +773,17 @@ export function compile(options: compile.Options): compile.ReturnType {
         specifier.importKind === 'type' ||
         !(
           node.source.value === 'zyzz'
-            ? ['Config', 'cx', 'style', 'Vars', 'variable', 'variants']
+            ? [
+                'Config',
+                'cx',
+                'defineConfig',
+                'defineVars',
+                'extendVars',
+                'style',
+                'Vars',
+                'variable',
+                'variants',
+              ]
             : [
                 'Css',
                 'cssFunction',
@@ -1135,6 +1230,7 @@ export function compile(options: compile.Options): compile.ReturnType {
       ? { [ThemeRules.shared]: emitted[ThemeRules.shared] }
       : {}),
     [ClassName.rules]: emitted[ClassName.rules],
+    [ClassName.units]: emitted[ClassName.units],
     classes,
     code: portable ? options.source : module.toString(),
     css: namespaced.css,
@@ -1150,6 +1246,7 @@ export function compile(options: compile.Options): compile.ReturnType {
     vars: emitted.vars,
   }
   Object.defineProperty(result, ClassName.rules, { enumerable: false })
+  Object.defineProperty(result, ClassName.units, { enumerable: false })
   return Object.freeze(result)
 }
 
@@ -1161,6 +1258,8 @@ export declare namespace compile {
   type Options = Source.extract.Options & {
     /** Separates generated token definitions for independently loaded modules. */
     readonly [ThemeRules.shared]?: 'all' | 'defaults' | undefined
+    /** Names shared independent atomic rules, with one name table across a graph's modules. */
+    readonly [ClassName.units]?: ClassName.Units | undefined
     /** Disable source rewriting while emitting CSS for runtime authoring. Defaults to true. */
     readonly compiler?: boolean | undefined
     /** Whether compiled applications can be combined with one another. */
@@ -1188,6 +1287,8 @@ export declare namespace compile {
     readonly code: string
     /** Exact emitted rules retained for collision diagnostics. */
     readonly [ClassName.rules]: Readonly<Record<string, string>>
+    /** Shared rule names chosen by this module, for graph cache validation. */
+    readonly [ClassName.units]?: ClassName.Units['used'] | undefined
     /** Ordered, unminified stylesheet text. */
     readonly css: string
     /** Standard stylesheet map with authored selector/declaration locations. */