@menapo/vicss 1.0.0 → 1.1.0

package/dist/{print-Ds6fkgio.js → print-B_mn7wBu.js}

@@ -22,6 +22,40 @@ const merge = (args) => {
 	}
 	return [names, kept];
 };
+/**
+* The class attribute: the classes kept as they are, then one class per id
+* in id order (S3), so folded, server and client output agree. The ids sort
+* alone: sorting `[id, class]` entries would join each into a string per
+* comparison, five times the cost.
+*/
+const join = ([names, kept]) => [...names, ...[...kept.keys()].sort().map((id) => kept.get(id))].join(" ");
+const cache = /* @__PURE__ */ new Map();
+let nodes = 0;
+let vars;
+/**
+* One argument: the trie node below `node` for it, or 0 once the call cannot
+* be cached. Falsy arguments contribute nothing, so they add no level.
+*/
+const walk = (node, arg) => {
+	if (!arg) return node;
+	const known = node && node.get(arg);
+	if (known) return known;
+	if (arg.map) return arg.reduce(walk, 0);
+	if (arg.$c) {
+		Object.assign(vars, arg.$s);
+		return walk(node, arg.$c);
+	}
+	return node && (nodes++, node.set(arg, /* @__PURE__ */ new Map()).get(arg));
+};
+/** The merged class attribute, cached per argument identity; `style` collects the custom properties. */
+const classes = (args, style) => {
+	if (nodes >> 10) {
+		cache.clear();
+		nodes = 0;
+	}
+	vars = style;
+	return (args.reduce(walk, cache) || {}).r ??= join(merge(args));
+};
 //#endregion
 //#region src/core/hash.ts
 /**
@@ -258,41 +292,6 @@ function compareStrings(a, b) {
 	return a < b ? -1 : a > b ? 1 : 0;
 }
 //#endregion
-//#region src/core/types.ts
-/**
-* What marks a VicssError, shared by every copy of this module in a process:
-* the config entry bundles its own copy, and Vite's `runnerImport` gives a
-* config another instance even of the workspace's source, so an error a
-* preset's utility or `dtcg()` throws is of another class than the one the
-* compiler catches.
-*/
-const BRAND = Symbol.for("@menapo/vicss/error");
-/** Thrown for anything vicss refuses; carries enough to print a code frame. */
-var VicssError = class VicssError extends Error {
-	code;
-	loc;
-	hint;
-	/**
-	* `instanceof VicssError` holds for a VicssError of any copy of vicss.
-	* Subclasses (`ScanConflict`) keep the ordinary prototype check.
-	*/
-	static [Symbol.hasInstance](value) {
-		if (this !== VicssError) return Function.prototype[Symbol.hasInstance].call(this, value);
-		return typeof value === "object" && value !== null && BRAND in value;
-	}
-	constructor(code, message, options = {}) {
-		const limit = Error.stackTraceLimit;
-		Error.stackTraceLimit = 0;
-		super(message);
-		Error.stackTraceLimit = limit;
-		this.name = "VicssError";
-		this.code = code;
-		this.loc = options.loc;
-		this.hint = options.hint;
-		Object.defineProperty(this, BRAND, { value: true });
-	}
-};
-//#endregion
 //#region src/core/css-value.ts
 /**
 * Well-formedness of the text vicss prints into the one global sheet. A value
@@ -389,6 +388,41 @@ function unquotedUrl(text, start) {
 	return "a url() is missing its `)`";
 }
 //#endregion
+//#region src/core/types.ts
+/**
+* What marks a VicssError, shared by every copy of this module in a process:
+* the config entry bundles its own copy, and Vite's `runnerImport` gives a
+* config another instance even of the workspace's source, so an error a
+* preset's utility or `dtcg()` throws is of another class than the one the
+* compiler catches.
+*/
+const BRAND = Symbol.for("@menapo/vicss/error");
+/** Thrown for anything vicss refuses; carries enough to print a code frame. */
+var VicssError = class VicssError extends Error {
+	code;
+	loc;
+	hint;
+	/**
+	* `instanceof VicssError` holds for a VicssError of any copy of vicss.
+	* Subclasses (`ScanConflict`) keep the ordinary prototype check.
+	*/
+	static [Symbol.hasInstance](value) {
+		if (this !== VicssError) return Function.prototype[Symbol.hasInstance].call(this, value);
+		return typeof value === "object" && value !== null && BRAND in value;
+	}
+	constructor(code, message, options = {}) {
+		const limit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 0;
+		super(message);
+		Error.stackTraceLimit = limit;
+		this.name = "VicssError";
+		this.code = code;
+		this.loc = options.loc;
+		this.hint = options.hint;
+		Object.defineProperty(this, BRAND, { value: true });
+	}
+};
+//#endregion
 //#region src/core/tokens.ts
 /**
 * Token resolution (PLAN §4.1, §5.9): token trees and semantic tokens flatten
@@ -5090,4 +5124,4 @@ function printPaletteResets(system, usage, names = READABLE) {
 	return blocks.join("\n");
 }
 //#endregion
-export { keepAtom as $, getProperty as A, splitClasses as At, isRootScope as B, canonicalChain as C, makeClassName as Ct, layerName as D, parseClassName as Dt, flatLayerName as E, mergeIdOf as Et, markerId as F, stableStringify as Ft, minLengthWarning as G, hasPlaceholders as H, markerLabel as I, merge as It, renameClasses as J, placeholder as K, markerSites as L, numberKind as M, toRecord as Mt, scaleNumberKind as N, valueLabel as Nt, layerStatement as O, propertyKey as Ot, MarkerValue as P, hash as Pt, isPaletteAtom as Q, markerStates as R, globToRegExp as S, isArbitrary as St, compareChains as T, mergeClassNames as Tt, isRelating as U, createNamer as V, minLengthOf as W, PALETTE_STYLE_KEY as X, PALETTE_GROUP as Y, isAnyPalette as Z, BUILT_IN_UTILITIES as _, VicssError as _t, modeVar as a, SPACING_STEP as at, hasPrivateAccess as b, escapeClassName as bt, printAtoms as c, cssVarName as ct, printTokens as d, isScaleName as dt, paletteKeyOf as et, scopedModes as f, lookupToken as ft, normalizeStyle as g, malformed as gt, compileKeyframes as h, suggestTokens as ht, modeFlag as i, SCALE_NAMESPACES as it, longhandsOf as j, styleLiteral as jt, PROPERTIES as k, readableClass as kt, printBase as l, didYouMean as lt, FRAME_STYLE as m, scaleTokens as mt, classicValue as n, typedPaletteNames as nt, outerLayers as o, closestNames as ot, switchingTokens as p, resolveReferences as pt, placeholdersIn as q, exclusive as r, SCALES as rt, paletteProblem as s, configError as st, baseTokens as t, paletteTarget as tt, printSheet as u, isPlainObject as ut, FLAG_RESETS as v, classAttribute as vt, checkAtoms as w, mergeAtoms as wt, privateTokenError as x, fromRecord as xt, resolveSystem as y, compareStrings as yt, isCompound as z };
+export { isPaletteAtom as $, PROPERTIES as A, readableClass as At, isCompound as B, globToRegExp as C, isArbitrary as Ct, flatLayerName as D, mergeIdOf as Dt, compareChains as E, mergeClassNames as Et, MarkerValue as F, hash as Ft, minLengthOf as G, createNamer as H, markerId as I, stableStringify as It, placeholdersIn as J, minLengthWarning as K, markerLabel as L, classes as Lt, longhandsOf as M, styleLiteral as Mt, numberKind as N, toRecord as Nt, layerName as O, parseClassName as Ot, scaleNumberKind as P, valueLabel as Pt, isAnyPalette as Q, markerSites as R, merge as Rt, privateTokenError as S, fromRecord as St, checkAtoms as T, mergeAtoms as Tt, hasPlaceholders as U, isRootScope as V, isRelating as W, PALETTE_GROUP as X, renameClasses as Y, PALETTE_STYLE_KEY as Z, normalizeStyle as _, VicssError as _t, modeFlag as a, SCALE_NAMESPACES as at, resolveSystem as b, compareStrings as bt, paletteProblem as c, configError as ct, printSheet as d, isPlainObject as dt, keepAtom as et, printTokens as f, isScaleName as ft, compileKeyframes as g, suggestTokens as gt, FRAME_STYLE as h, scaleTokens as ht, exclusive as i, SCALES as it, getProperty as j, splitClasses as jt, layerStatement as k, propertyKey as kt, printAtoms as l, cssVarName as lt, switchingTokens as m, resolveReferences as mt, chainSelectors as n, paletteTarget as nt, modeVar as o, SPACING_STEP as ot, scopedModes as p, lookupToken as pt, placeholder as q, classicValue as r, typedPaletteNames as rt, outerLayers as s, closestNames as st, baseTokens as t, paletteKeyOf as tt, printBase as u, didYouMean as ut, BUILT_IN_UTILITIES as v, malformed as vt, canonicalChain as w, makeClassName as wt, hasPrivateAccess as x, escapeClassName as xt, FLAG_RESETS as y, classAttribute as yt, markerStates as z };

package/dist/{snapshot-BQb8ZmSV.js → snapshot-DAJ8FLU4.js}

@@ -1,4 +1,4 @@
-import { _ as BUILT_IN_UTILITIES, _t as VicssError, dt as isScaleName, ut as isPlainObject, y as resolveSystem } from "./print-Ds6fkgio.js";
+import { _t as VicssError, b as resolveSystem, dt as isPlainObject, ft as isScaleName, v as BUILT_IN_UTILITIES } from "./print-B_mn7wBu.js";
 //#region src/core/snapshot.ts
 /**
 * The lint snapshot, `vicss.lint.json`: what the lint rules (src/lint) need

package/dist/{theme-C-0LpsJx.js → theme-zBcr5DHi.js}

@@ -1,4 +1,4 @@
-import { B as isRootScope, C as canonicalChain, Ct as makeClassName, Dt as parseClassName, Ft as stableStringify, It as merge, Mt as toRecord, Ot as propertyKey, Pt as hash, Q as isPaletteAtom, T as compareChains, Tt as mergeClassNames, _t as VicssError, a as modeVar, bt as escapeClassName, c as printAtoms, dt as isScaleName, f as scopedModes, ft as lookupToken, gt as malformed, ht as suggestTokens, i as modeFlag, j as longhandsOf, jt as styleLiteral, k as PROPERTIES, lt as didYouMean, n as classicValue, ot as closestNames, p as switchingTokens, pt as resolveReferences, r as exclusive, rt as SCALES, ut as isPlainObject, yt as compareStrings, z as isCompound } from "./print-Ds6fkgio.js";
+import { $ as isPaletteAtom, A as PROPERTIES, B as isCompound, E as compareChains, Et as mergeClassNames, Ft as hash, It as stableStringify, Lt as classes, M as longhandsOf, Mt as styleLiteral, Nt as toRecord, Ot as parseClassName, Rt as merge, V as isRootScope, _t as VicssError, a as modeFlag, bt as compareStrings, dt as isPlainObject, ft as isScaleName, gt as suggestTokens, i as exclusive, it as SCALES, kt as propertyKey, l as printAtoms, m as switchingTokens, mt as resolveReferences, o as modeVar, p as scopedModes, pt as lookupToken, r as classicValue, st as closestNames, ut as didYouMean, vt as malformed, w as canonicalChain, wt as makeClassName, xt as escapeClassName } from "./print-B_mn7wBu.js";
 //#region src/core/location.ts
 /**
 * Offsets to line and column, for diagnostics and source maps. Lines end at
@@ -741,6 +741,29 @@ function shadowedByEarlier(args, atomsOf) {
 	} : void 0;
 }
 //#endregion
+//#region src/runtime/style.ts
+/**
+* One compiled style as a class (PLAN §5.6, §5.16): `class={card}`,
+* `className={card}` and `${card}` read it as its class attribute. A
+* compiled style keeps its shape, merge id → class, so `sx()` still merges
+* it; the string comes from the prototype every compiled style shares. A
+* class method is not enumerable, so the merge's `for…in`, `Object.keys`
+* and a spread never see it, and a constant carries no function of its own.
+*/
+var Styled = class {
+	/**
+	* The class attribute `sx(style)` sets, by `sx()`'s own merge and cache:
+	* the same string by construction, a cache hit after the first render,
+	* and 31 B less than a merge of its own beside `sx()`, which nearly every
+	* app ships (PLAN §6).
+	*/
+	toString() {
+		return classes([this], {});
+	}
+};
+/** What the compiler wraps a compiled style literal in (`__vxStyled({…})`). */
+const styled = (record) => Object.setPrototypeOf(record, Styled.prototype);
+//#endregion
 //#region src/runtime/recipe.ts
 /**
 * The recipe resolver (PLAN §4.4, §5.7): what a compiled `recipe()` becomes,
@@ -803,7 +826,7 @@ const __vxRecipe = (t, x) => {
 			const add = x?.(t, props, values, cells);
 			for (const compound of t.c) if (add) add(compound);
 			else if (Object.keys(compound[0]).every((key) => compound[0][key].includes(values[key]))) cells.push(compound[1]);
-			const slot = (name) => Object.fromEntries(merge(cells.map((cell) => typeof cell == "object" && (name ? cell[name] : cell)))[1]);
+			const slot = (name) => styled(Object.fromEntries(merge(cells.map((cell) => typeof cell == "object" && (name ? cell[name] : cell)))[1]));
 			result = t.s ? Object.fromEntries(t.s.map((name) => [name, slot(name)])) : slot();
 			if (process.env.NODE_ENV != "production") Object.freeze(result);
 			if (memo.size >> 10) memo.clear();

package/dist/{types-file-R_knFzME.js → types-file-D6Iu4kzv.js}

@@ -1,7 +1,7 @@
-import { $ as keepAtom, N as scaleNumberKind, Q as isPaletteAtom, R as markerStates, S as globToRegExp, U as isRelating, Z as isAnyPalette, _t as VicssError, at as SPACING_STEP, b as hasPrivateAccess, ct as cssVarName, dt as isScaleName, et as paletteKeyOf, ft as lookupToken, it as SCALE_NAMESPACES, k as PROPERTIES, mt as scaleTokens, q as placeholdersIn, rt as SCALES, tt as paletteTarget, v as FLAG_RESETS, w as checkAtoms, yt as compareStrings } from "./print-Ds6fkgio.js";
-import { d as baseRule, f as checkBases, l as responsiveConditions, n as compileTheme, u as baseAtoms } from "./theme-C-0LpsJx.js";
-import { _ as isSfc, h as extractScripts, n as WorkerLost, u as resolvesAlike, x as SourceEdits } from "./pool-BGXMhLfL.js";
-import { t as SNAPSHOT_FILE } from "./snapshot-BQb8ZmSV.js";
+import { $ as isPaletteAtom, A as PROPERTIES, C as globToRegExp, J as placeholdersIn, P as scaleNumberKind, Q as isAnyPalette, T as checkAtoms, W as isRelating, _t as VicssError, at as SCALE_NAMESPACES, bt as compareStrings, et as keepAtom, ft as isScaleName, ht as scaleTokens, it as SCALES, lt as cssVarName, nt as paletteTarget, ot as SPACING_STEP, pt as lookupToken, tt as paletteKeyOf, x as hasPrivateAccess, y as FLAG_RESETS, z as markerStates } from "./print-B_mn7wBu.js";
+import { _ as isSfc, h as extractScripts, n as WorkerLost, u as resolvesAlike, x as SourceEdits } from "./pool-F3qb30Fy.js";
+import { d as baseRule, f as checkBases, l as responsiveConditions, n as compileTheme, u as baseAtoms } from "./theme-zBcr5DHi.js";
+import { t as SNAPSHOT_FILE } from "./snapshot-DAJ8FLU4.js";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
 import { glob, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
@@ -485,7 +485,7 @@ var CompileCache = class {
 	#entries = /* @__PURE__ */ new Map();
 	/** `configHash` covers the design system and the files that define it. */
 	key(code, configHash) {
-		return `${hashCode(code)}:${configHash}:13:${VERSION}`;
+		return `${hashCode(code)}:${configHash}:14:${VERSION}`;
 	}
 	/**
 	* The entry for `id` if it is still valid. `depHash` reads a dependency's
@@ -517,7 +517,7 @@ var CompileCache = class {
 		} catch {
 			return;
 		}
-		if (!isRecord(data) || data.format !== 13 || !isRecord(data.entries)) return;
+		if (!isRecord(data) || data.format !== 14 || !isRecord(data.entries)) return;
 		const table = data.atoms;
 		const rules = data.rules;
 		if (!Array.isArray(table) || !table.every(isAtom)) return;
@@ -563,7 +563,7 @@ var CompileCache = class {
 		await mkdir(path.dirname(file), { recursive: true });
 		const temp = `${file}.${process.pid}.tmp`;
 		const data = {
-			format: 13,
+			format: 14,
 			atoms: atoms.table,
 			rules: rules.table,
 			entries

package/dist/vite.d.ts

@@ -242,4 +242,29 @@ interface VicssPluginOptions {
 }
 export declare function vicss(options?: VicssPluginOptions): Plugin[];
 //#endregion
-export { type CriticalDirOptions, type CriticalOptions, type CriticalPage, type CriticalPart, type CriticalReport, type VicssPluginOptions, vicss as default };
+//#region src/core/literals.d.ts
+/** One declaration of a class, its values literal. */
+interface Literal {
+  /** kebab-case: `padding-inline`, `background-color`. */
+  readonly property: string;
+  /** Tokens replaced by their base values, transitively; other `var()` (a runtime value's) stays. */
+  readonly value: string;
+  /** The property's tier: under one condition, a higher tier wins (`padding-top` over `padding`). */
+  readonly tier: number;
+  /** Condition names it applies under, `[]` for always: `["dark"]`, `["md", "hover"]`. */
+  readonly chain: readonly string[];
+  /**
+   * Where it applies, one entry per alternative of the chain's conditions:
+   * a selector with `&` for the element's class, and its at-rules, outermost
+   * first. The color-scheme modes (`dark`, `light`) are left out, for the
+   * caller to read in `chain`: a mail client needs its own selectors for them.
+   */
+  readonly rules: ReadonlyArray<{
+    readonly selector: string;
+    readonly atRules: readonly string[];
+  }>;
+  /** The value under each mode whose tokens change it: `{ dark: "#f9fafb" }`. */
+  readonly modes?: Readonly<Record<string, string>>;
+}
+//#endregion
+export { type CriticalDirOptions, type CriticalOptions, type CriticalPage, type CriticalPart, type CriticalReport, type Literal, type VicssPluginOptions, vicss as default };