zyzz 0.0.27 → 0.0.29

package/src/runtime/Composition.ts

@@ -29,39 +29,62 @@ export function create(options: create.Options) {
     ...input,
     classes: new Set(input.className.split(/\s+/).filter(Boolean)),
   }))
+  // Only conditional arguments select a precompiled case.
+  const conditional = inputs.some((input) => input.condition !== undefined)
 
   return (...entries: readonly Entry[]) => {
     let mask = 0
-    for (const [index, input] of inputs.entries())
-      if (input.condition !== undefined && entries[index])
-        mask |= 1 << input.condition
+    if (conditional)
+      for (let index = 0; index < inputs.length; index++) {
+        const condition = inputs[index]!.condition
+        if (condition !== undefined && entries[index]) mask |= 1 << condition
+      }
     const className = options.cases?.[mask] ?? options.className
-    const result: style.Props & Record<string, unknown> = {
-      className,
-    }
-    const external: string[] = []
-    const style: Record<string, string | number | undefined> = {}
-    for (const [index, entry] of entries.entries()) {
+    // Mutable while entries merge, then returned as immutable props.
+    const result: {
+      className: string
+      style?: Record<string, string | number | undefined>
+    } & Record<string, unknown> = { className }
+    let attributes = false
+    let external: string[] | undefined
+    let style: Record<string, string | number | undefined> | undefined
+    for (let index = 0; index < entries.length; index++) {
+      const entry = entries[index]
       if (!entry) continue
       const input = inputs[index]!
-      for (const owner of input.owners) {
-        for (const attribute of owner.attributes) delete result[attribute]
-        for (const slot of owner.slots) delete style[slot]
-      }
-      for (const name of entry.className.split(/\s+/))
-        if (name && !input.classes.has(name)) external.push(name)
-      for (const [name, value] of Object.entries(entry))
-        if (name.startsWith('data-')) result[name] = value
-      for (const [name, value] of Object.entries(entry.style ?? {})) {
-        // Reinsert overwritten keys so inline shorthand/longhand ordering follows arguments.
-        delete style[name]
-        style[name] = value
+      // Owners replace only what earlier entries added, so the first contributions skip deletion.
+      if (attributes || style)
+        for (const owner of input.owners) {
+          if (attributes)
+            for (const attribute of owner.attributes) delete result[attribute]
+          if (style) for (const slot of owner.slots) delete style[slot]
+        }
+      // An application's own class list adds nothing beyond the composition class.
+      if (entry.className !== input.className)
+        for (const name of entry.className.split(/\s+/))
+          if (name && !input.classes.has(name)) (external ??= []).push(name)
+      for (const name in entry)
+        if (name.startsWith('data-') && Object.hasOwn(entry, name)) {
+          result[name] = entry[name as `data-${string}`]
+          attributes = true
+        }
+      const inline = entry.style
+      if (inline) {
+        style ??= {}
+        for (const name in inline) {
+          if (!Object.hasOwn(inline, name)) continue
+          // Reinsert overwritten keys so inline shorthand/longhand ordering follows arguments.
+          delete style[name]
+          style[name] = inline[name as keyof typeof inline]
+        }
       }
     }
-    return {
-      ...result,
-      className: [className, ...external].filter(Boolean).join(' '),
-      ...(Object.keys(style).length ? { style } : {}),
+    result.className = external
+      ? [className, ...external].filter(Boolean).join(' ')
+      : className || ''
+    if (style && Object.keys(style).length) result.style = style
+    return result as style.Props & {
+      readonly [name: `data-${string}`]: string | undefined
     }
   }
 }

package/src/runtime/Recipe.ts

@@ -37,25 +37,32 @@ export type Payload = {
  */
 export function create(options: create.Options) {
   const props = Props.create({ className: options.className })
-  const axes = Object.keys(options.axes)
+  // Attribute names and defaults are fixed, so calls only read the selection.
+  const axes = Object.keys(options.axes).map((axis) => ({
+    attribute: `data-${axis}` as const,
+    axis,
+    fallback: Object.hasOwn(options.defaults, axis)
+      ? options.defaults[axis]
+      : undefined,
+  }))
 
   return (input: Record<string, unknown> & style.Options = {}) => {
     const overrides: style.Options = input
-    const result: style.Props & Record<`data-${string}`, string> = {
-      ...props(overrides),
-    }
+    // Props are fresh on every call, so selection attributes extend them in place.
+    const result = props(overrides) as style.Props &
+      Record<`data-${string}`, string>
 
-    for (const axis of axes) {
-      const selected = Object.hasOwn(input, axis) ? input[axis] : undefined
-      const value = (
-        selected === undefined
-          ? Object.hasOwn(options.defaults, axis)
-            ? options.defaults[axis]
-            : undefined
-          : selected
-      ) as string | boolean | null | undefined
+    for (const entry of axes) {
+      const selected = Object.hasOwn(input, entry.axis)
+        ? input[entry.axis]
+        : undefined
+      const value = (selected === undefined ? entry.fallback : selected) as
+        | string
+        | boolean
+        | null
+        | undefined
       if (value !== null && value !== undefined)
-        result[`data-${axis}`] = String(value)
+        result[entry.attribute] = String(value)
     }
 
     return options.html ? Html.from(result) : result

package/src/styleFunction.ts

@@ -29,9 +29,21 @@ type VariableOptions<input> = input extends {
     }
   : unknown
 
+// Composition entries are static definitions or exact literal objects.
+type Entries<entries> = {
+  readonly [index in keyof entries]: Entry<entries[index]>
+}
+
+// Distributes over mixed element unions so each member keeps its own contract.
+type Entry<entry> = entry extends (...args: never) => unknown
+  ? style.Composable<entry>
+  : entry & NoInfer<Style.Accepted<entry, {}, true>> & Completion.Properties
+
 /**
  * Declares literal styles for source extraction. Requires a compile-time transform.
- * @param styles - Token-free literal CSS properties. Omit for an empty definition.
+ * An array composes static definitions and literal objects in order, so later entries
+ * win as later declarations do.
+ * @param styles - Token-free literal CSS properties, or an array of static definitions and literal objects. Omit for an empty definition.
  * @returns A callable style definition after source rewriting.
  * @throws {Error} When a definition needs an explicit identity and none is supplied.
  */
@@ -53,16 +65,29 @@ export function style<
       ? [options?: style.DefinitionOptions]
       : [invalid: never, unavailable: never]
     : [invalid: never, unavailable: never]
-): style.Dynamic<values>
+  // TypeScript types a call that matches no overload with this signature. Other
+  // inputs leave `callback` at its constraint, so their definitions stay static.
+): ((...args: never[]) => unknown) extends callback
+  ? style.ReturnType
+  : style.Dynamic<values>
 export function style<const styles extends Record<string, unknown>>(
   styles: styles &
     NoInfer<Style.Accepted<styles, {}, true>> &
     Completion.Properties,
   options?: style.DefinitionOptions,
 ): style.ReturnType
+export function style<const entries>(
+  styles: entries & Entries<entries>,
+  // Exclude non-array inputs by arity so they cannot mask object-property diagnostics.
+  ...options: entries extends readonly unknown[]
+    ? [options?: style.DefinitionOptions]
+    : [invalid: never, unavailable: never]
+): style.ReturnType
 export function style(
   styles?: unknown,
   options: style.DefinitionOptions = {},
+  // Matches the arity-gated overloads, whose invalid branches add parameters.
+  ..._: readonly never[]
 ): style.ReturnType {
   return Authoring.create(styles, options)
 }
@@ -73,6 +98,10 @@ type Reference = { readonly [identity]: true }
 
 /** Contracts for the literal authoring boundary. */
 export declare namespace style {
+  /** Accepts a static definition as a composition entry. Dynamic definitions and variants require cx. */
+  type Composable<entry> = entry extends Reference & (() => unknown)
+    ? entry
+    : ReturnType<Output>
   /** Stable identity for selectors and definitions that cannot be content-addressed. */
   type DefinitionOptions = { readonly id?: string | undefined }
   /** Callable compiled bindings with required scalar inputs and styling overrides. */

package/src/unplugin/index.ts

@@ -5,15 +5,14 @@ import * as Fs from 'node:fs/promises'
 import * as Path from 'node:path'
 import * as Reset from '../node/Reset.js'
 import * as Snapshot from '../node/internal/Snapshot.js'
-import * as Syntax from '../compiler/internal/Syntax.js'
 import { createUnplugin } from 'unplugin'
 import type { UnpluginBuildContext } from 'unplugin'
 import * as Graph from '../compiler/Graph.js'
 import * as AtRules from '../compiler/internal/AtRules.js'
 import * as Catalogs from '../compiler/internal/Catalogs.js'
 import * as ClassName from '../web/internal/ClassName.js'
-import * as Contract from '../compiler/internal/Contract.js'
 import * as Contracts from '../node/internal/Contracts.js'
+import * as Results from '../compiler/internal/Results.js'
 import * as Vite from '../vite/index.js'
 import * as ThemeRules from '../web/internal/Themes.js'
 
@@ -218,10 +217,12 @@ const portable = createUnplugin<Options | undefined, false>(
             })
             if (source === undefined) return false
             contracts[file] = source
-            const metadata = Contract.read(contracts[file]!, new Map(), file)
-            for (const section of metadata.stylesheets) {
+            for (const dependency of Results.dependencies(
+              contracts[file]!,
+              file,
+            )) {
               let owner = file
-              for (const specifier of section.dependency ?? []) {
+              for (const specifier of dependency) {
                 const target = await resolve(specifier, owner)
                 if (!target)
                   throw new Error(
@@ -289,7 +290,6 @@ const portable = createUnplugin<Options | undefined, false>(
           const result = compiler.compile({
             [ClassName.complete]: true,
             [ThemeRules.shared]: 'all',
-            [Syntax.cache]: snapshot.programs(modules),
             compiler: options.compiler,
             reset: options.reset ? Reset.read() : undefined,
             contracts,