@yahoo/uds-create-config 5.61.1 → 5.62.1

package/dist/lint/context.js

@@ -0,0 +1,622 @@
+import { isNativeConfig } from "../configs/platform.js";
+import { isRef, kindOf, pathOf } from "../framework/utils/refs.js";
+import { rootLayerOf } from "../entities/system/element.js";
+import { modeAxes } from "../entities/system/Modifier.js";
+import { literalValueOf, resolveTokenValue, resolveTokenValueUnder, stylePropEntries } from "../framework/projections.js";
+import { layerDeclarations } from "../framework/layer-styles.js";
+import { Component } from "../entities/system/Component.js";
+import { rnStyleName } from "../entities/native/NativeStyleProperty.js";
+import { contrastRatio, hueOf, luminance, parseColor } from "../framework/utils/color.js";
+import { parseCssLength } from "../framework/utils/css-length.js";
+import "../index.js";
+//#region src/lint/context.ts
+/**
+* What the lint's config checks read, built once per run: the system's components with their style
+* sites and cells, what each style key's tokens hold, the color modes, and the helpers every check
+* shares (contrast, color parsing, px). Each rule's `check` in `rules.ts` reads from it, so the
+* config is walked and its tokens resolved once however many rules run.
+*
+* Nothing here reads a file: a config check runs wherever a config is loaded, Create's browser
+* included. A finding names where its value is written as the config stores it (component, rule,
+* layer, style key), and the lint over the sources finds the line.
+*/
+/**
+* The entry that keeps a finding, if one does: same rule, and every place the entry names (component
+* or token, then layer, style key and rule) the finding's own. An entry naming less reaches more.
+*/
+function ignoredBy(ignores, finding) {
+	return ignores.find((entry) => entry.rule === finding.rule && (entry.component === void 0 || entry.component === finding.component) && (entry.token === void 0 || entry.token === finding.token) && (entry.layer === void 0 || entry.layer === finding.layer) && (entry.prop === void 0 || entry.prop === finding.prop) && (entry.when === void 0 || entry.when === finding.when));
+}
+const tokenOf = (value) => isRef(value) && kindOf(value) === "token" ? pathOf(value) : void 0;
+const BREAKPOINTS = new Set([
+	"base",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"2xl"
+]);
+/** A value as written, for a message. */
+function written(value) {
+	const token = tokenOf(value);
+	if (token) return token;
+	return typeof value === "string" || typeof value === "number" ? String(value) : JSON.stringify(value);
+}
+/** Every value a component's rules write, with where. */
+function styleSites(styles) {
+	const out = [];
+	for (const [when, rule] of Object.entries(styles ?? {})) {
+		const { when: whenValue, layers } = rule ?? {};
+		for (const [layer, bag] of Object.entries(layers ?? {})) {
+			const walk = (node, modifiers, prop) => {
+				if (prop !== void 0 && (isRef(node) || typeof node !== "object")) {
+					out.push({
+						when,
+						whenValue,
+						layer,
+						prop,
+						modifiers,
+						value: node
+					});
+					return;
+				}
+				if (!node || typeof node !== "object" || Array.isArray(node)) return;
+				for (const [key, value] of Object.entries(node)) if (key.startsWith("_") || BREAKPOINTS.has(key)) walk(value, [...modifiers, key], prop);
+				else if (prop === void 0) walk(value, modifiers, key);
+				else out.push({
+					when,
+					whenValue,
+					layer,
+					prop,
+					modifiers,
+					value
+				});
+			};
+			walk(bag, []);
+		}
+	}
+	return out;
+}
+/** What the style properties offer, read once per run. */
+var Values = class {
+	entries = /* @__PURE__ */ new Map();
+	/** Each style property's `arbitrary`: what a bare value or a bracketed one reads as. */
+	arbitrary = /* @__PURE__ */ new Map();
+	/** The style keys that set a color. */
+	colorKeys = /* @__PURE__ */ new Set();
+	/** The style keys that set each CSS property, by the property (`background-color` → `bg`). */
+	byCss = /* @__PURE__ */ new Map();
+	/** Whether the system is native, where a bare number is a length in points. */
+	native;
+	constructor(config) {
+		this.config = config;
+		this.native = isNativeConfig(config);
+		for (const property of config.list("style-property")) {
+			const json = property.toJSON();
+			const key = property.path.split("/").pop() ?? property.path;
+			this.arbitrary.set(key, json.arbitrary);
+			for (const css of json.properties ?? []) {
+				const name = rnStyleName(css);
+				this.byCss.set(name, [...this.byCss.get(name) ?? [], key]);
+			}
+			if (!json.opacityOf && (json.properties ?? []).some((css) => /(^|-)color$/.test(css))) this.colorKeys.add(key);
+		}
+	}
+	/** The style keys that set any of `css`: what a check reads for a CSS property, whatever the
+	*  system calls its style property. */
+	keysFor(...css) {
+		return [...new Set(css.flatMap((one) => this.byCss.get(rnStyleName(one)) ?? []))];
+	}
+	/** The entries a style key offers, by the name a rule writes. */
+	offered(key) {
+		const hit = this.entries.get(key);
+		if (hit) return hit;
+		const out = /* @__PURE__ */ new Map();
+		const property = this.config.list("style-property").find((one) => (one.path.split("/").pop() ?? one.path) === key);
+		if (property) for (const { leaf, value } of stylePropEntries(this.config, property.path)) {
+			if (out.has(leaf)) continue;
+			out.set(leaf, this.config.resolve("token", value) !== void 0 ? { token: value } : { literal: value });
+		}
+		this.entries.set(key, out);
+		return out;
+	}
+	/** The token a value names, written as a ref or by its name. */
+	tokenOf(key, value) {
+		return tokenOf(value) ?? (typeof value === "string" ? this.offered(key).get(value)?.token : void 0);
+	}
+	/** A value as the literal it paints, under a mode's override condition (`null` for the base). */
+	literal(key, value, condition = null) {
+		const token = this.tokenOf(key, value);
+		if (token) return resolveTokenValueUnder(this.config, token, condition);
+		if (typeof value === "number") return value;
+		if (typeof value === "string") {
+			const bracketed = /^\[(.+)\]$/.exec(value)?.[1];
+			if (bracketed) return bracketed.replace(/_/g, " ");
+			const offered = this.offered(key).get(value);
+			if (offered && "literal" in offered) return literalValueOf(this.config, offered.literal) ?? value;
+			return value;
+		}
+		return literalValueOf(this.config, value);
+	}
+	/** A length in px, or `undefined` for one that isn't (`50%`, `auto`). A rem is read at 16px. */
+	px(key, value, condition = null) {
+		const literal = this.literal(key, value, condition);
+		if (typeof literal === "number") return this.native || this.arbitrary.get(key) === "px" ? literal : void 0;
+		if (typeof literal !== "string") return void 0;
+		const length = parseCssLength(literal);
+		if (!length) return void 0;
+		const { number, unit } = length;
+		if (unit === "rem") return number * 16;
+		if (unit === "px" || number === 0 || unit === "" && this.native) return number;
+		return this.arbitrary.get(key) === "px" ? number : void 0;
+	}
+};
+/**
+* The color modes a check reads each value under: the mode axis the config declares that its tokens'
+* overrides key on most, its default option first (`condition: null`), then each other option as the
+* override key that names it alone. One `default` mode for a system with no such axis.
+*/
+function colorModes(config) {
+	const keyed = /* @__PURE__ */ new Map();
+	for (const token of config.list("token")) {
+		const overrides = token.toJSON().overrides;
+		for (const key of Object.keys(overrides ?? {})) keyed.set(key, (keyed.get(key) ?? 0) + 1);
+	}
+	const axis = modeAxes(config).map((axis) => ({
+		axis,
+		uses: axis.options.reduce((sum, option) => sum + (keyed.get(option.leaf) ?? 0), 0)
+	})).filter(({ uses }) => uses > 0).sort((a, b) => b.uses - a.uses)[0]?.axis;
+	if (!axis) return [{
+		condition: null,
+		label: "default"
+	}];
+	const chosen = axis.meta.default;
+	const base = (chosen && isRef(chosen) ? pathOf(chosen).split("/").pop() : void 0) ?? axis.options.find((option) => !keyed.has(option.leaf))?.leaf ?? axis.options[0]?.leaf ?? "default";
+	return [{
+		condition: null,
+		label: base
+	}, ...axis.options.filter((option) => option.leaf !== base).map((option) => ({
+		condition: option.leaf,
+		label: option.leaf
+	}))];
+}
+/** A rule's `when` as prop values: a variant's value ref as its name, anything else as it is. */
+function whenPropsOf(when) {
+	if (!when || typeof when !== "object" || Array.isArray(when)) return null;
+	return Object.fromEntries(Object.entries(when).flatMap(([prop, value]) => isRef(value) ? [[prop, value.__ref.split("/").pop() ?? value.__ref]] : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? [[prop, value]] : []));
+}
+/**
+* Each layer's parent, from the anatomy tree: what it sits on and inherits from. `undefined` for a
+* component with no anatomy (one loaded from its source before a build reads the tree), where the
+* nesting isn't known.
+*/
+function layerParents(json) {
+	if (!json.anatomy) return void 0;
+	const [root] = rootLayerOf(json.layers ?? {});
+	const layerOf = (node) => {
+		const element = json.anatomy?.[node]?.element;
+		return isRef(element) && kindOf(element) === "layer" ? pathOf(element) : node;
+	};
+	const parents = /* @__PURE__ */ new Map();
+	for (const [node, { children = [] } = {}] of Object.entries(json.anatomy)) for (const child of children) if (typeof child === "string") parents.set(layerOf(child), layerOf(node));
+	for (const layer of Object.keys(json.layers ?? {})) if (layer !== root && !parents.has(layer)) parents.set(layer, root);
+	return parents;
+}
+/** Each combination of a component's variants, the rest of its props at their defaults, capped. */
+function cellsOf(json, cap = 120) {
+	const variants = Object.entries(json.props ?? {}).flatMap(([name, prop]) => prop?.type === "variant" && prop.value ? [{
+		name,
+		values: Object.keys(prop.value)
+	}] : []);
+	let cells = [{
+		...Object.fromEntries(variants.map(({ name, values }) => [name, values[0]])),
+		...json.defaultProps
+	}];
+	for (const { name, values } of variants) {
+		const next = cells.flatMap((cell) => values.map((value) => ({
+			...cell,
+			[name]: value
+		})));
+		if (next.length > cap) break;
+		cells = next;
+	}
+	return cells;
+}
+const cellLabel = (cell, json) => Object.entries(json.props ?? {}).filter(([, prop]) => prop?.type === "variant").map(([name]) => `${name}=${String(cell[name])}`).join(", ");
+/** A scale step's name: a number (`3`, `0.5`, `3/5`) or a size (`md`, `2xl`). */
+const SCALE_STEP = new RegExp(`^(\\d+(\\.\\d+)?(/\\d+)?|${[
+	"3xs",
+	"xxs",
+	"2xs",
+	"xs",
+	"sm",
+	"small",
+	"md",
+	"medium",
+	"lg",
+	"large",
+	"xl",
+	"xxl",
+	"2xl",
+	"3xl",
+	"4xl"
+].join("|")})$`);
+/** The elements a browser makes pressable itself. */
+const PRESS_TAGS = new Set(["button", "a"]);
+/** A press handler, as React DOM (`onClick`) and React Native (`onPress`) name it. */
+const PRESS_HANDLER = /^on(Click|Press)$/;
+const MIN_CONTRAST = 4.5;
+const TRANSPARENT = /^(transparent|currentcolor|inherit|initial|unset|none)$/i;
+/** What a site's value writes inside brackets (`[180px]` → `180px`), if it's bracketed. */
+const bracketedOf = (site) => typeof site.value === "string" ? /^\[(.+)\]$/.exec(site.value)?.[1] : void 0;
+function configLintContext({ config, rules, own: isOwn }) {
+	const own = isOwn ?? ((kind, path) => config.ownerOf(kind, path) === config && !config.borrowedFrom(kind, path));
+	const values = new Values(config);
+	const modes = colorModes(config);
+	const tokenLiterals = /* @__PURE__ */ new Map();
+	const tokensFor = (key) => {
+		const hit = tokenLiterals.get(key);
+		if (hit) return hit;
+		const out = [...values.offered(key)].flatMap(([name, entry]) => {
+			if (!entry.token) return [];
+			const literal = resolveTokenValue(config, entry.token);
+			if (literal === void 0) return [];
+			const px = values.px(key, `[${String(literal)}]`);
+			return [{
+				name,
+				literal: String(literal).trim().toLowerCase(),
+				...px !== void 0 ? { px } : {}
+			}];
+		});
+		tokenLiterals.set(key, out);
+		return out;
+	};
+	const all = new Map(config.list("component").map(({ path }) => [path, Component.get(config, path)?.toJSON() ?? {}]));
+	const components = [...all].filter(([path]) => own("component", path)).map(([path, json]) => ({
+		path,
+		json,
+		sites: styleSites(json.styles),
+		cells: cellsOf(json)
+	}));
+	const answers = /* @__PURE__ */ new Map();
+	const rendered = (element, test, depth = 0) => {
+		if (!isRef(element) || kindOf(element) !== "component" || depth > 6) return false;
+		const path = pathOf(element);
+		let known = answers.get(test);
+		if (!known) {
+			known = /* @__PURE__ */ new Map();
+			answers.set(test, known);
+		}
+		const hit = known.get(path);
+		if (hit !== void 0) return hit;
+		const json = all.get(path);
+		const answer = json !== void 0 && (test(json) || rendered(rootLayerOf(json.layers ?? {})[1], test, depth + 1));
+		known.set(path, answer);
+		return answer;
+	};
+	/** Whether a component takes a press handler: declared, or read by its render. */
+	const handlesPress = (json) => [...Object.keys(json.props ?? {}), ...json.renderProps ?? []].some((name) => PRESS_HANDLER.test(name));
+	/** Whether a component draws an icon: it takes a slot an icon library fills. */
+	const drawsIcon = (json) => Object.values(json.props ?? {}).some((prop) => prop?.type === "slot" && isRef(prop.value) && kindOf(prop.value) === "icon");
+	const pressable = (json) => {
+		if (handlesPress(json)) return true;
+		const [, element] = rootLayerOf(json.layers ?? {});
+		if (typeof element === "string") return PRESS_TAGS.has(element);
+		return rendered(element, handlesPress);
+	};
+	const colorIn = (key, value, condition) => {
+		const literal = values.literal(key, value, condition);
+		return typeof literal === "string" ? parseColor(literal) : void 0;
+	};
+	const family = (a, b) => {
+		const x = hueOf(a);
+		const y = hueOf(b);
+		const gray = (one) => one.saturation < .15;
+		if (gray(x) || gray(y)) return gray(x) && gray(y);
+		const apart = Math.abs(x.hue - y.hue);
+		return Math.min(apart, 360 - apart) <= 30;
+	};
+	const swatches = /* @__PURE__ */ new Map();
+	const swatchesFor = (prop) => {
+		const hit = swatches.get(prop);
+		if (hit) return hit;
+		const out = [];
+		for (const [name, entry] of values.offered(prop)) {
+			if (!entry.token) continue;
+			const ref = { __ref: `token:${entry.token}` };
+			const literals = modes.map(({ condition }) => values.literal(prop, ref, condition));
+			out.push({
+				name,
+				token: entry.token,
+				colors: literals.map((literal) => typeof literal === "string" ? parseColor(literal) : void 0),
+				follows: literals.some((literal, at) => modes[at]?.condition !== null && String(literal) !== String(literals[0]))
+			});
+		}
+		swatches.set(prop, out);
+		return out;
+	};
+	const colors = /* @__PURE__ */ new WeakMap();
+	const colorsOf = (site) => {
+		let hit = colors.get(site);
+		if (!hit) {
+			hit = modes.map(({ condition }) => colorIn(site.prop, site.value, condition));
+			colors.set(site, hit);
+		}
+		return hit;
+	};
+	const pairs = /* @__PURE__ */ new WeakMap();
+	const pairsOf = (component) => {
+		const hit = pairs.get(component);
+		if (hit) return hit;
+		const bySite = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ new Map();
+		for (const layer of layers(component)) {
+			const text = layer.text?.site;
+			const background = layer.background?.site;
+			if (!text || !background) continue;
+			if (JSON.stringify(text.value) === JSON.stringify(background.value)) continue;
+			const on = seen.get(text) ?? /* @__PURE__ */ new Set();
+			if (on.has(background)) continue;
+			on.add(background);
+			seen.set(text, on);
+			const pair = {
+				text,
+				background
+			};
+			for (const site of [text, background]) {
+				const list = bySite.get(site) ?? [];
+				list.push(pair);
+				bySite.set(site, list);
+			}
+		}
+		pairs.set(component, bySite);
+		return bySite;
+	};
+	const keepsOthers = ({ component, changed, swatch, text, background }) => {
+		for (const pair of pairsOf(component).get(changed) ?? []) {
+			if (pair.text === text && pair.background === background) continue;
+			const fgs = colorsOf(pair.text);
+			const bgs = colorsOf(pair.background);
+			for (let at = 0; at < modes.length; at++) {
+				const fg = fgs[at];
+				const bg = bgs[at];
+				const after = swatch.colors[at];
+				if (!fg || !bg || !after || fg[3] === 0 || bg[3] < 1) continue;
+				const was = contrastRatio(fg, bg);
+				if ((pair.text === changed ? contrastRatio(after, bg) : contrastRatio(fg, after)) < was) return false;
+			}
+		}
+		return true;
+	};
+	const passingToken = ({ component, change, text, background, minimum }) => {
+		const changed = change === "text" ? text : background;
+		const textColors = colorsOf(text);
+		const backgroundColors = colorsOf(background);
+		const before = change === "text" ? textColors : backgroundColors;
+		const wantFollows = modes.some(({ condition }) => condition !== null && String(values.literal(changed.prop, changed.value, condition)) !== String(values.literal(changed.prop, changed.value)));
+		const was = before[0];
+		const textAt = textColors[0];
+		const backgroundAt = backgroundColors[0];
+		const lighter = textAt && backgroundAt ? luminance(textAt) > luminance(backgroundAt) : void 0;
+		let best;
+		for (const swatch of swatchesFor(changed.prop)) {
+			if (wantFollows && !swatch.follows) continue;
+			const base = swatch.colors[0];
+			if (!base || was && !family(base, was)) continue;
+			if (lighter !== void 0 && textAt && backgroundAt) {
+				const fg = change === "text" ? base : textAt;
+				const bg = change === "background" ? base : backgroundAt;
+				if (luminance(fg) > luminance(bg) !== lighter) continue;
+			}
+			let distance = 0;
+			let passes = true;
+			for (let at = 0; at < modes.length; at++) {
+				const fg = change === "text" ? swatch.colors[at] : textColors[at];
+				const bg = change === "background" ? swatch.colors[at] : backgroundColors[at];
+				const after = swatch.colors[at];
+				if (!fg || !bg || fg[3] < 1 || bg[3] < 1 || !after) {
+					passes = false;
+					break;
+				}
+				const prior = before[at];
+				if (prior) distance += (after[0] - prior[0]) ** 2 + (after[1] - prior[1]) ** 2 + (after[2] - prior[2]) ** 2;
+				if (contrastRatio(fg, bg) < minimum) {
+					passes = false;
+					break;
+				}
+			}
+			if (!passes) continue;
+			if (!keepsOthers({
+				component,
+				changed,
+				swatch,
+				text,
+				background
+			})) continue;
+			if (!best || distance < best.distance) best = {
+				name: swatch.name,
+				token: swatch.token,
+				distance
+			};
+		}
+		return best ? {
+			name: best.name,
+			token: best.token
+		} : void 0;
+	};
+	const declared = /* @__PURE__ */ new WeakMap();
+	const indexed = /* @__PURE__ */ new WeakMap();
+	const siteAt = (component, key) => {
+		let index = indexed.get(component);
+		if (!index) {
+			index = /* @__PURE__ */ new Map();
+			for (const site of component.sites) {
+				if (site.modifiers.length > 0) continue;
+				index.set(`${site.when}|${site.layer}|${site.prop}`, site);
+			}
+			indexed.set(component, index);
+		}
+		return index.get(key);
+	};
+	const effective = (component, cell, layer, keys) => {
+		let bags = declared.get(cell);
+		if (!bags) {
+			bags = layerDeclarations(config, component.path, { ...cell });
+			declared.set(cell, bags);
+		}
+		for (const prop of keys) {
+			const winner = bags[layer]?.[prop];
+			if (!winner) continue;
+			const site = siteAt(component, `${winner.rule}|${layer}|${prop}`);
+			if (site) return site;
+		}
+	};
+	const resolved = /* @__PURE__ */ new WeakMap();
+	const value = (component, site) => {
+		const hit = resolved.get(site);
+		if (hit) return hit;
+		const perMode = (read) => {
+			const held = /* @__PURE__ */ new Map();
+			return (mode) => {
+				const at = mode?.condition ?? null;
+				if (!held.has(at)) held.set(at, read(at));
+				return held.get(at);
+			};
+		};
+		const made = {
+			component,
+			site,
+			get token() {
+				return values.tokenOf(site.prop, site.value);
+			},
+			bracketed: bracketedOf(site),
+			literal: perMode((at) => values.literal(site.prop, site.value, at)),
+			color: perMode((at) => colorIn(site.prop, site.value, at)),
+			px: perMode((at) => values.px(site.prop, site.value, at))
+		};
+		resolved.set(site, made);
+		return made;
+	};
+	const ink = values.keysFor("color");
+	const fill = values.keysFor("background-color", "background");
+	const tall = values.keysFor("height");
+	const wide = values.keysFor("width");
+	function* layers(component) {
+		const { json } = component;
+		const names = Object.keys(json.layers ?? {});
+		const [root] = rootLayerOf(json.layers ?? {});
+		const parents = layerParents(json);
+		const pressed = pressable(json);
+		const graphics = new Map(names.map((name) => [name, rendered(json.layers?.[name], drawsIcon)]));
+		for (const cell of component.cells) {
+			const looked = /* @__PURE__ */ new Map();
+			const at = (name, keys) => {
+				let byName = looked.get(keys);
+				if (!byName) {
+					byName = /* @__PURE__ */ new Map();
+					looked.set(keys, byName);
+				}
+				const hit = byName.get(name);
+				if (hit !== void 0) return hit ?? void 0;
+				const site = effective(component, cell, name, keys);
+				const found = site ? value(component, site) : void 0;
+				byName.set(name, found ?? null);
+				return found;
+			};
+			const once = (read) => {
+				let done = false;
+				let held;
+				return () => {
+					if (!done) {
+						held = read();
+						done = true;
+					}
+					return held;
+				};
+			};
+			const painted = once(() => names.some((name) => name !== root && at(name, fill) !== void 0));
+			const nearest = (name, keys) => {
+				if (!parents) {
+					if (name === root || keys === fill && painted()) return void 0;
+					return at(root, keys);
+				}
+				for (let up = parents.get(name); up; up = parents.get(up)) {
+					const found = at(up, keys);
+					if (found) return found;
+				}
+			};
+			const where = cellLabel(cell, json);
+			for (const name of names) {
+				const ownText = once(() => at(name, ink));
+				const ownFill = once(() => at(name, fill));
+				const text = once(() => ownText() ?? nearest(name, ink));
+				const background = once(() => ownFill() ?? nearest(name, fill));
+				yield {
+					component,
+					cell,
+					where,
+					name,
+					pressable: name === root && pressed,
+					graphic: graphics.get(name) ?? false,
+					get text() {
+						return text();
+					},
+					get ownText() {
+						return ownText() !== void 0;
+					},
+					get background() {
+						return background();
+					},
+					get ownBackground() {
+						return ownFill() !== void 0;
+					},
+					get height() {
+						return at(name, tall);
+					},
+					get width() {
+						return at(name, wide);
+					}
+				};
+			}
+		}
+	}
+	return {
+		config,
+		values,
+		modes,
+		own,
+		components,
+		effective,
+		value,
+		layers,
+		platform: values.native ? {
+			native: true,
+			minTarget: 44,
+			unit: "pt"
+		} : {
+			native: false,
+			minTarget: 24,
+			unit: "px"
+		},
+		runs: (rule) => rules.has(rule),
+		tokensFor,
+		tokenSpelled: (site) => {
+			const bracketed = bracketedOf(site);
+			if (!bracketed) return void 0;
+			return tokensFor(site.prop).find(({ literal }) => literal === bracketed.trim().toLowerCase());
+		},
+		pressable,
+		passingToken,
+		at: (component, site) => ({
+			component,
+			when: site.when,
+			whenProps: whenPropsOf(site.whenValue),
+			layer: site.layer,
+			prop: site.prop,
+			...site.modifiers.length > 0 ? { modifiers: site.modifiers } : {},
+			value: written(site.value)
+		})
+	};
+}
+//#endregion
+export { MIN_CONTRAST, SCALE_STEP, TRANSPARENT, configLintContext, ignoredBy, written };

package/dist/lint/edits.d.ts

@@ -0,0 +1,77 @@
+import { ConfigEdit } from "../framework/config-op.js";
+import { Config } from "../framework/Config.js";
+import { AuthoringLintGroup, AuthoringLintRule, AuthoringLintSeverity } from "./rules.js";
+import { ConfigLintFinding, LintIgnore } from "./context.js";
+
+//#region src/lint/edits.d.ts
+/** Where a finding is, as the config stores it, and the value it suggests. */
+interface LintFixSite {
+  readonly rule: AuthoringLintRule;
+  readonly component?: string;
+  readonly token?: string;
+  readonly when?: string;
+  readonly whenProps?: ConfigLintFinding['whenProps'];
+  readonly layer?: string;
+  readonly prop?: string;
+  readonly modifiers?: readonly string[];
+  readonly suggestion?: string;
+  /** Where the suggestion is written, when it isn't the finding's own place. */
+  readonly target?: ConfigLintFinding['target'];
+  /** The linked system the component or token comes from, which changes it there. */
+  readonly source?: string;
+}
+/** The system's `settings.lint.rules`. */
+declare const lintSeverities: (config: Config | null) => Readonly<Record<string, AuthoringLintSeverity>>;
+/** The system's `settings.lint.ignore`. */
+declare const lintIgnores: (config: Config | null) => readonly LintIgnore[];
+declare const rulesOf: (group: AuthoringLintGroup) => AuthoringLintRule[];
+/** A group's severity: its rules' when they agree, `mixed` when one is set apart. */
+declare function groupSeverity(group: AuthoringLintGroup, severities: Readonly<Record<string, AuthoringLintSeverity>>): AuthoringLintSeverity | 'mixed';
+/**
+ * The settings edit that sets a rule or a group to `off`, `warn` or `error`: its entry in
+ * `settings.lint.rules`, or none where the default already says it.
+ *
+ * - A rule's own entry wins over its group's, so a rule set to what its group gives it drops its own.
+ * - A group sets each rule that has no entry of its own. Setting it also clears its rules' own entries,
+ *   so the group's choice is the whole answer, the way a "select all" is.
+ * - An experimental group's rules are off until each is named, so that group sets each rule by name.
+ */
+declare function severityEdits({
+  config,
+  name,
+  severity
+}: {
+  config: Config;
+  name: string;
+  severity: AuthoringLintSeverity;
+}): ConfigEdit[];
+/** A finding's entry in `settings.lint.ignore`: as narrow as the finding says where it is. */
+declare function ignoreEntry(site: LintFixSite, reason: string): LintIgnore;
+/** The settings edit that keeps a finding, with why: `uds lint` and Create both leave it out. */
+declare function ignoreEdits({
+  config,
+  site,
+  reason
+}: {
+  config: Config;
+  site: LintFixSite;
+  reason: string;
+}): ConfigEdit[];
+/** The settings edit that puts an ignored finding back. */
+declare function restoreEdits({
+  config,
+  entry
+}: {
+  config: Config;
+  entry: LintIgnore;
+}): ConfigEdit[];
+/** Whether a finding has one value to write, which {@link fixEdits} writes. */
+declare const hasFix: (site: LintFixSite) => boolean;
+/**
+ * The edit that writes the suggestion of each finding that has one, where the finding's value was: in
+ * the same rule, layer and modifiers. Each component's changes go through one `styleSetEdits`, so two
+ * fixes on the same rule and layer write together rather than the second replacing the first.
+ */
+declare function fixEdits(sites: readonly LintFixSite[]): ConfigEdit[];
+//#endregion
+export { LintFixSite, fixEdits, groupSeverity, hasFix, ignoreEdits, ignoreEntry, lintIgnores, lintSeverities, restoreEdits, rulesOf, severityEdits };