@yahoo/uds-create-config 4.34.3 → 4.34.4

package/dist/entities/system/StyleProperty.js

@@ -2,6 +2,7 @@ import { isRef, kindOf, pathOf, ref, refSchema, sourceOf, splitRef } from "../..
 import { defineEntity } from "../../framework/defineEntity.js";
 import { cssValueIssue, isCssProperty } from "../../css/values.js";
 import { camelCase } from "./style-bag.js";
+import { createSliceMemo } from "../../framework/memo.js";
 import { isIdentifier } from "../../framework/utils/identifier.js";
 import { z } from "zod";
 //#region src/entities/system/StyleProperty.ts
@@ -289,11 +290,9 @@ function tokenRefOf(entry) {
 * `spacing/2` — since that is one value with two spellings, not two values.
 */
 const copiesNoToken = (config) => (ctx) => {
-	const tokens = /* @__PURE__ */ new Map();
-	for (const token of config.list("token")) {
-		const value = comparable(token.body.value);
-		if (value !== void 0 && !tokens.has(value)) tokens.set(value, token.path);
-	}
+	const literal = (entry) => typeof entry === "object" && entry !== null && "value" in entry;
+	if (!ctx.value.some(literal)) return;
+	const tokens = tokenPathsByValue(config);
 	ctx.value.forEach((entry, index) => {
 		if (typeof entry !== "object" || entry === null || !("value" in entry)) return;
 		const value = comparable(entry.value);
@@ -308,6 +307,19 @@ const copiesNoToken = (config) => (ctx) => {
 		});
 	});
 };
+/** Each token value, as `comparable` spells it, and the first token path that holds it. Kept per token
+*  slice, since a batch of style-property writes would otherwise list every token once per write. */
+const tokenPathsByValue = createSliceMemo({
+	kinds: ["token"],
+	compute: (config) => {
+		const tokens = /* @__PURE__ */ new Map();
+		for (const token of config.list("token")) {
+			const value = comparable(token.body.value);
+			if (value !== void 0 && !tokens.has(value)) tokens.set(value, token.path);
+		}
+		return tokens;
+	}
+});
 /** A check refusing a ref to a token or group nothing declares: it offers no values, and the prop
 *  paints nothing. */
 const namesDeclaredTokens = (config) => (ctx) => {

package/dist/framework/Config.js

@@ -1301,9 +1301,9 @@ var Config = class Config {
 			}
 		}
 		const land = (checked) => {
-			let config = this;
+			let config = checked ? this : this.derive({ snapshot: this.state.snapshot.drafting() });
 			for (const patch of patches) config = config.derive({ snapshot: config.computeApply(config.state.snapshot, patch, "write", checked) });
-			return config;
+			return checked ? config : config.derive({ snapshot: config.state.snapshot.sealed() });
 		};
 		const settle = () => {
 			try {

package/dist/framework/ref-graph.d.ts

@@ -56,16 +56,22 @@ interface RefIndexChange {
 }
 /** Index `entries` in both directions. Pure — callers memoize (see `Snapshot.refs`). */
 declare function buildRefIndex(entries: readonly RefGraphEntry[], linkKinds?: readonly string[], singletonKinds?: readonly string[]): RefIndex;
+/** The maps and sets a batch of snapshot writes has copied, which its later writes change in place. */
+interface SnapshotDraft {
+  readonly owned: WeakSet<object>;
+}
 /**
  * Re-index only the entities in `changes`, returning a new index that shares nothing mutable with
- * the old one. The top-level maps are copied per CALL (a batch), and only the edge sets actually
- * touched are copied — so the deep `collectRefs` walk, which is the expensive part, runs for the
- * changed entities alone rather than for the whole config.
+ * the old one. The top-level maps and each edge set a change touches are copied once, so the deep
+ * `collectRefs` walk runs for the changed entities alone rather than for the whole config. Once means
+ * once per call, or once per batch inside a `draft`, which then writes its own copies in place.
+ * Changes whose entities kept exactly the refs they had hand back the same index, since copying the
+ * top-level maps costs a walk of every node in the config.
  */
-declare function updateRefIndex(index: RefIndex, changes: readonly RefIndexChange[], linkKinds?: readonly string[], singletonKinds?: readonly string[]): RefIndex;
+declare function updateRefIndex(index: RefIndex, changes: readonly RefIndexChange[], linkKinds?: readonly string[], singletonKinds?: readonly string[], draft?: SnapshotDraft): RefIndex;
 /** The query facade over a built index — the shape every consumer asks questions through. */
 declare function refGraphOf(index: RefIndex): RefGraph;
 /** Build and query in one step — for a caller with no snapshot to carry the index on. */
 declare function buildRefGraph(entries: readonly RefGraphEntry[]): RefGraph;
 //#endregion
-export { RefGraph, RefGraphEntry, RefIndex, RefIndexChange, RefTarget, TraverseOptions, buildRefGraph, buildRefIndex, refGraphOf, updateRefIndex };
+export { RefGraph, RefGraphEntry, RefIndex, RefIndexChange, RefTarget, SnapshotDraft, TraverseOptions, buildRefGraph, buildRefIndex, refGraphOf, updateRefIndex };

package/dist/framework/ref-graph.js

@@ -59,32 +59,47 @@ function buildRefIndex(entries, linkKinds = [], singletonKinds = []) {
 }
 /**
 * Re-index only the entities in `changes`, returning a new index that shares nothing mutable with
-* the old one. The top-level maps are copied per CALL (a batch), and only the edge sets actually
-* touched are copied — so the deep `collectRefs` walk, which is the expensive part, runs for the
-* changed entities alone rather than for the whole config.
+* the old one. The top-level maps and each edge set a change touches are copied once, so the deep
+* `collectRefs` walk runs for the changed entities alone rather than for the whole config. Once means
+* once per call, or once per batch inside a `draft`, which then writes its own copies in place.
+* Changes whose entities kept exactly the refs they had hand back the same index, since copying the
+* top-level maps costs a walk of every node in the config.
 */
-function updateRefIndex(index, changes, linkKinds = [], singletonKinds = []) {
+function updateRefIndex(index, changes, linkKinds = [], singletonKinds = [], draft) {
 	if (changes.length === 0) return index;
-	const out = /* @__PURE__ */ new Map();
-	for (const [node, set] of index.out) out.set(node, set);
-	const incoming = /* @__PURE__ */ new Map();
-	for (const [node, set] of index.incoming) incoming.set(node, set);
-	/** Copy-on-write a single edge set, so sets shared with the previous index are never mutated. */
+	const next = changes.map(({ ref, data, extra }) => ({
+		ref,
+		targets: data === void 0 ? void 0 : edgesOf(ref, data, extra, linkKinds, singletonKinds)
+	}));
+	if (next.every(({ ref, targets }) => sameEdges(index.out.get(ref), targets))) return index;
+	const owned = draft?.owned ?? /* @__PURE__ */ new WeakSet();
+	const writable = (map) => {
+		if (owned.has(map)) return map;
+		const copy = /* @__PURE__ */ new Map();
+		for (const [node, set] of map) copy.set(node, set);
+		owned.add(copy);
+		return copy;
+	};
+	const out = writable(index.out);
+	const incoming = writable(index.incoming);
+	/** Copy-on-write a single edge set, so sets shared with an earlier index are never mutated. A target
+	*  many changes touch would otherwise be copied once per change. */
 	const mutable = (map, node) => {
-		const next = new Set(map.get(node));
+		const current = map.get(node);
+		if (current && owned.has(current)) return current;
+		const next = new Set(current);
+		owned.add(next);
 		map.set(node, next);
 		return next;
 	};
-	for (const { ref, data, extra } of changes) {
-		for (const target of index.out.get(ref) ?? []) {
+	for (const { ref, targets } of next) {
+		for (const target of out.get(ref) ?? []) {
 			const back = mutable(incoming, target);
 			back.delete(ref);
 			if (back.size === 0) incoming.delete(target);
 		}
 		out.delete(ref);
-		if (data === void 0) continue;
-		const targets = edgesOf(ref, data, extra, linkKinds, singletonKinds);
-		if (targets.size === 0) continue;
+		if (!targets || targets.size === 0) continue;
 		out.set(ref, targets);
 		for (const target of targets) mutable(incoming, target).add(ref);
 	}
@@ -93,6 +108,14 @@ function updateRefIndex(index, changes, linkKinds = [], singletonKinds = []) {
 		incoming
 	};
 }
+/** Whether an entity's edges are the ones it had, where no entry and an empty set both mean none. */
+function sameEdges(before, after) {
+	const size = before?.size ?? 0;
+	if (size !== (after?.size ?? 0)) return false;
+	if (size === 0) return true;
+	for (const target of before ?? []) if (!after?.has(target)) return false;
+	return true;
+}
 /** The query facade over a built index — the shape every consumer asks questions through. */
 function refGraphOf(index) {
 	const { out, incoming } = index;

package/dist/framework/snapshot.d.ts

@@ -1,5 +1,5 @@
 import { Entity } from "./Entity.js";
-import { RefGraph } from "./ref-graph.js";
+import { RefGraph, SnapshotDraft } from "./ref-graph.js";
 import { EntityKind } from "./registry.js";
 
 //#region src/framework/snapshot.d.ts
@@ -44,6 +44,18 @@ type EntityChange = {
 declare class Snapshot {
   #private;
   private constructor();
+  /**
+   * The same snapshot, starting a batch of writes. A store or index map is copied the first time the
+   * batch writes it and written in place after that, so a batch of N writes copies each once instead
+   * of N times. Every write still returns a new snapshot, with a new slice for each kind it wrote.
+   *
+   * The batch owns its copies, so the snapshots it produced share them: reading one written earlier
+   * in the batch shows the batch's later writes. The caller keeps only the last and {@link sealed}s it.
+   * Nothing from before the batch is ever written.
+   */
+  drafting(): Snapshot;
+  /** The same snapshot with its batch closed, so a later write copies again. */
+  sealed(): Snapshot;
   /**
    * The same snapshot, reading name-borne edges through `readers` from here on.
    *

package/dist/framework/snapshot.js

@@ -17,14 +17,36 @@ const emptySlice = () => Object.freeze({
 	groups: /* @__PURE__ */ new Map(),
 	overrides: /* @__PURE__ */ new Map()
 });
-/** Apply one change to a mutable draft of a slice. */
-function applyToSlice(draft, change) {
-	let store;
-	if (change.target === "item") store = draft.items;
-	else if (change.target === "group") store = draft.groups;
-	else store = draft.overrides;
-	if (change.value === void 0) store.delete(change.path);
-	else store.set(change.path, change.value);
+const STORE_OF = {
+	item: "items",
+	group: "groups",
+	override: "overrides"
+};
+/**
+* One kind's slice with `changes` applied. Only the stores a change touches are replaced. Outside a
+* draft each is copied once per call; inside one, a store the draft already copied is written in place,
+* so a batch copies each store once rather than once per patch.
+*/
+function changedSlice({ current, changes, draft }) {
+	const stores = {
+		items: current.items,
+		groups: current.groups,
+		overrides: current.overrides
+	};
+	const written = /* @__PURE__ */ new Set();
+	for (const change of changes) {
+		const name = STORE_OF[change.target];
+		if (!written.has(name) && !draft?.owned.has(stores[name])) {
+			const copy = new Map(stores[name]);
+			draft?.owned.add(copy);
+			stores[name] = copy;
+		}
+		written.add(name);
+		const store = stores[name];
+		if (change.value === void 0) store.delete(change.path);
+		else store.set(change.path, change.value);
+	}
+	return Object.freeze({ ...stores });
 }
 var Snapshot = class Snapshot {
 	#nameEdges;
@@ -41,14 +63,36 @@ var Snapshot = class Snapshot {
 	*  independent configs — a global singleton would make two unrelated configs that both lack a kind
 	*  collide on one memo key, and each would serve the other's cached result. */
 	#empties;
+	/** The batch this snapshot was written in, when it was — see {@link drafting}. */
+	#draft;
 	#graph;
-	constructor(slices, refIndex, empties, nameEdges = /* @__PURE__ */ new Map(), linkKinds = [], singletonKinds = []) {
+	constructor(slices, refIndex, empties, nameEdges = /* @__PURE__ */ new Map(), linkKinds = [], singletonKinds = [], draft = void 0) {
 		this.#slices = slices;
 		this.#refIndex = refIndex;
 		this.#empties = empties;
 		this.#nameEdges = nameEdges;
 		this.#linkKinds = linkKinds;
 		this.#singletonKinds = singletonKinds;
+		this.#draft = draft;
+	}
+	/**
+	* The same snapshot, starting a batch of writes. A store or index map is copied the first time the
+	* batch writes it and written in place after that, so a batch of N writes copies each once instead
+	* of N times. Every write still returns a new snapshot, with a new slice for each kind it wrote.
+	*
+	* The batch owns its copies, so the snapshots it produced share them: reading one written earlier
+	* in the batch shows the batch's later writes. The caller keeps only the last and {@link sealed}s it.
+	* Nothing from before the batch is ever written.
+	*/
+	drafting() {
+		return this.#with({ draft: { owned: /* @__PURE__ */ new WeakSet() } });
+	}
+	/** The same snapshot with its batch closed, so a later write copies again. */
+	sealed() {
+		return this.#draft ? this.#with({ draft: void 0 }) : this;
+	}
+	#with({ draft }) {
+		return new Snapshot(this.#slices, this.#refIndex, this.#empties, this.#nameEdges, this.#linkKinds, this.#singletonKinds, draft);
 	}
 	/**
 	* The same snapshot, reading name-borne edges through `readers` from here on.
@@ -145,17 +189,12 @@ var Snapshot = class Snapshot {
 			else byKind.set(change.kind, [change]);
 		}
 		const slices = new Map(this.#slices);
-		for (const [kind, kindChanges] of byKind) {
-			const current = this.slice(kind);
-			const draft = {
-				items: new Map(current.items),
-				groups: new Map(current.groups),
-				overrides: new Map(current.overrides)
-			};
-			for (const change of kindChanges) applyToSlice(draft, change);
-			slices.set(kind, Object.freeze(draft));
-		}
-		return new Snapshot(slices, updateRefIndex(this.#refIndex, refChanges(changes, this.#nameEdges), this.#linkKinds, this.#singletonKinds), this.#empties, this.#nameEdges, this.#linkKinds, this.#singletonKinds);
+		for (const [kind, kindChanges] of byKind) slices.set(kind, changedSlice({
+			current: this.slice(kind),
+			changes: kindChanges,
+			draft: this.#draft
+		}));
+		return new Snapshot(slices, updateRefIndex(this.#refIndex, refChanges(changes, this.#nameEdges), this.#linkKinds, this.#singletonKinds, this.#draft), this.#empties, this.#nameEdges, this.#linkKinds, this.#singletonKinds, this.#draft);
 	}
 	/**
 	* Move an entity to a new path, KEEPING ITS POSITION in the record.
@@ -176,6 +215,7 @@ var Snapshot = class Snapshot {
 		const rebuilt = /* @__PURE__ */ new Map();
 		for (const [path, entity] of store) if (path === from) rebuilt.set(to, value);
 		else if (path !== to) rebuilt.set(path, entity);
+		this.#draft?.owned.add(rebuilt);
 		const slices = new Map(this.#slices);
 		slices.set(kind, Object.freeze({
 			...current,
@@ -188,7 +228,7 @@ var Snapshot = class Snapshot {
 			ref: `${kind}:${to}`,
 			data: value.toJSON(),
 			extra: this.#nameEdges.get(kind)?.(value.toJSON())
-		}], this.#linkKinds, this.#singletonKinds), this.#empties, this.#nameEdges, this.#linkKinds, this.#singletonKinds);
+		}], this.#linkKinds, this.#singletonKinds, this.#draft), this.#empties, this.#nameEdges, this.#linkKinds, this.#singletonKinds, this.#draft);
 	}
 	/**
 	* Rearrange a record's keys — the operation that MOVES something, since order is key order.