@rohal12/spindle 0.59.4 → 0.59.5

package/dist/pkg/headless.js

@@ -13426,7 +13426,11 @@ function deepClone(value, options = {}) {
 		}
 		if (val instanceof Map) {
 			const copy = keep(obj, /* @__PURE__ */ new Map());
-			for (const [k, v] of val) copy.set(clone(k), clone(v));
+			for (const [k, v] of val) {
+				const key = clone(k);
+				const settle = options.mapKey;
+				copy.set(settle && isObjectValue(key) && isObjectValue(k) ? settle(key, k) : key, clone(v));
+			}
 			return copy;
 		}
 		if (val instanceof Set) {
@@ -13679,15 +13683,16 @@ function keyChanges(before, after, arrays) {
 /**
 * The property paths where `after` differs from `before`, two objects of
 * one class: objects that merge (see isMergeable) are compared property by
-* property, any other value as a whole.
+* property, any other value as a whole; with `arrays`, arrays are compared
+* by index too (see keyChanges).
 */
-function diffPaths(before, after) {
+function diffPaths(before, after, arrays = false) {
 	const changes = [];
 	const ancestors = /* @__PURE__ */ new Set();
 	(function walk(b, a, path) {
 		if (ancestors.has(a)) return;
 		ancestors.add(a);
-		for (const change of keyChanges(b, a, false)) {
+		for (const change of keyChanges(b, a, arrays)) {
 			const at = [...path, change.key];
 			if (change.kind === "nested") walk(change.before, change.after, at);
 			else changes.push(change.kind === "deleted" ? {
@@ -13696,7 +13701,8 @@ function diffPaths(before, after) {
 			} : {
 				path: at,
 				deleted: false,
-				value: change.after
+				value: change.after,
+				...change.kind === "added" && Array.isArray(a) ? { appended: true } : {}
 			});
 		}
 		ancestors.delete(a);
@@ -13709,35 +13715,57 @@ function underChange(path, keys) {
 	for (let n = 1; n <= path.length; n++) if (keys.has(pathKey(path.slice(0, n)))) return true;
 	return false;
 }
+/** The segment standing for the entry `index` of a Map or Set in a path. */
+var entryKey = (kind, index) => `\0${kind}${index}`;
 /**
 * Every path each object (or array, or other value) of `root` is at, the
 * first appearance first, in depth-first order. Plain objects and arrays are
 * entered, where first met only (an object held in an array is one object,
 * however it was reached); other values are leaves. A path at or below one
 * of `skip` is left out.
+*
+* With `entries`, the objects held in a Map or Set (as key, value or member)
+* are placed too, after everything else: one met nowhere else is at the path
+* of its Map or Set and the entry's segment (see entryKey), which is no path
+* a value can be read at, so only to tell where an object is from.
 */
-function objectPaths(root, skip = /* @__PURE__ */ new Set()) {
+function objectPaths(root, skip = /* @__PURE__ */ new Set(), entries = false) {
 	const all = /* @__PURE__ */ new Map();
-	(function walk(node, path) {
+	const collections = [];
+	function place(value, at) {
+		const known = all.get(value);
+		if (known) {
+			known.push(at);
+			return;
+		}
+		all.set(value, [at]);
+		if (isMergeable(value) || Array.isArray(value)) walk(value, at);
+		else if (entries && (value instanceof Map || value instanceof Set)) collections.push([value, at]);
+	}
+	function walk(node, path) {
 		for (const key of Object.keys(node)) {
 			const value = node[key];
 			if (!isObjectValue(value)) continue;
 			const at = [...path, key];
 			if (skip.has(pathKey(at))) continue;
-			const known = all.get(value);
-			if (known) {
-				known.push(at);
-				continue;
-			}
-			all.set(value, [at]);
-			if (isMergeable(value) || Array.isArray(value)) walk(value, at);
+			place(value, at);
 		}
-	})(root, []);
+	}
+	walk(root, []);
+	for (const [collection, path] of collections) {
+		let index = 0;
+		for (const entry of collection.entries()) {
+			const [k, v] = entry;
+			const parts = collection instanceof Set ? [[k, entryKey("s", index)]] : [[k, entryKey("k", index)], [v, entryKey("v", index)]];
+			for (const [value, segment] of parts) if (isObjectValue(value) && !all.has(value)) place(value, [...path, segment]);
+			index++;
+		}
+	}
 	return all;
 }
 /** Where each object of `root` first appears (see objectPaths). */
-function firstPaths(root, skip) {
-	return new Map([...objectPaths(root, skip)].map(([object, paths]) => [object, paths[0]]));
+function firstPaths(root, skip, entries) {
+	return new Map([...objectPaths(root, skip, entries)].map(([object, paths]) => [object, paths[0]]));
 }
 /**
 * The objects `root` holds at more than one path (an object two variables
@@ -13748,6 +13776,26 @@ function sharedPaths(root) {
 	return [...objectPaths(root).values()].filter((paths) => paths.length > 1);
 }
 /**
+* Whether the Map or Set `y` holds, at the position of an entry of `x`, another
+* object than `x` did (as to where its first appearance is, see aliasChanges):
+* `$map.set("k", $a)` over an equal object. Entries are compared by position,
+* and only when both hold as many; other differences are changes of content.
+*/
+function entryAliasChanged(x, y, earlier, later) {
+	const isSet = x instanceof Set && y instanceof Set;
+	if (!isSet && !(x instanceof Map && y instanceof Map)) return false;
+	if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y)) return false;
+	if (x.size !== y.size) return false;
+	const moved = (a, b) => isObjectValue(a) && isObjectValue(b) && pathKey(earlier.get(a)) !== pathKey(later.get(b));
+	const ys = [...y.entries()];
+	let index = 0;
+	for (const [k, v] of x.entries()) {
+		const [k2, v2] = ys[index++];
+		if (moved(k, k2) || !isSet && moved(v, v2)) return true;
+	}
+	return false;
+}
+/**
 * The paths whose object is another one in the references of `after` than in
 * `before`, as to where its first appearance is: `$a = $b` makes `a` another
 * name for the object of `b` even where both hold equal content, and a
@@ -13756,8 +13804,8 @@ function sharedPaths(root) {
 * `after` holds.
 */
 function aliasChanges(before, after) {
-	const earlier = firstPaths(before);
-	const later = firstPaths(after);
+	const earlier = firstPaths(before, void 0, true);
+	const later = firstPaths(after, void 0, true);
 	const changes = [];
 	(function walk(b, a, path) {
 		for (const key of Object.keys(a)) {
@@ -13775,12 +13823,36 @@ function aliasChanges(before, after) {
 				value: y,
 				alias: true
 			});
+			else if (pathKey(isAt) === k && entryAliasChanged(x, y, earlier, later)) changes.push({
+				path: at,
+				deleted: false,
+				value: y,
+				alias: true
+			});
 			if ((isMergeable(x) || Array.isArray(x)) && mergesWith(x, y, true) && pathKey(isAt) === k && pathKey(wasAt) === k) walk(x, y, at);
 		}
 	})(before, after, []);
 	return changes;
 }
 /**
+* The changes from `before` to `after`, as paths below them: the property
+* paths that differ (see diffPaths), and those that hold equal content but
+* another object than they did (see aliasChanges), those first. Compared as
+* one object, so an object that two of their keys share is one object,
+* whichever of them it is reached through.
+*/
+function changesBetween(before, after, arrays = false) {
+	const written = diffPaths(before, after, arrays);
+	const keys = new Set(written.map((c) => pathKey(c.path)));
+	const aliases = [];
+	for (const change of aliasChanges(before, after)) {
+		if (underChange(change.path, keys)) continue;
+		keys.add(pathKey(change.path));
+		aliases.push(change);
+	}
+	return [...aliases, ...written];
+}
+/**
 * Where the objects of `source` are, other than at or below the paths of
 * `changes` (which write something new there), for `existingObjects`.
 */
@@ -14600,9 +14672,18 @@ var cloneValue = (value) => deepClone(value, { keepUnregistered: true });
 */
 function clonerFor(target, paths) {
 	const seen = paths ? existingObjects(paths, target) : /* @__PURE__ */ new Map();
+	const mapKey = (copy, original) => {
+		const path = paths?.get(original);
+		if (!path || !isDraft(copy)) return copy;
+		const plain = current(copy);
+		setByPath(target, path, plain);
+		seen.set(original, plain);
+		return plain;
+	};
 	return (value) => deepClone(value, {
 		keepUnregistered: true,
-		seen
+		seen,
+		mapKey
 	});
 }
 /** One cloner per target copy, made when first used. */
@@ -14751,7 +14832,8 @@ function routeStoreUpdate(recipe) {
 			path: [ns, ...change.path]
 		})) : [];
 	});
-	const cloners = clonersFor();
+	const held = locateObjects(namespacesOf(inner.work), changes);
+	const cloners = clonersFor(() => held);
 	const owned = (change, target) => change.deleted ? change : {
 		...change,
 		value: cloners(target)(change.value)
@@ -14806,6 +14888,12 @@ function cloneNamespaces(from) {
 		transient: deepClone(from.transient, { seen })
 	};
 }
+/** The three variable namespaces of `state`, as an object to walk. */
+var namespacesOf = (state) => ({
+	variables: state.variables,
+	temporary: state.temporary,
+	transient: state.transient
+});
 /**
 * Commit the property paths each mutation's code changed (work vs base) on
 * top of the current store state, so writes made elsewhere during execution
@@ -14870,24 +14958,9 @@ function commitScopes(commits) {
 }
 /**
 * The changes of the code to the namespaces, as paths below them (`['variables',
-* 'a']`): the property paths that differ (see diffPaths), and those that hold
-* equal content but another object than they did (see aliasChanges), those
-* first. Compared as one object, so an object the namespaces share is one
-* object, whichever of them it is reached through.
-*/
-function changesOf(base, work) {
-	const before = base;
-	const after = work;
-	const written = diffPaths(before, after);
-	const keys = new Set(written.map((c) => pathKey(c.path)));
-	const aliases = [];
-	for (const change of aliasChanges(before, after)) {
-		if (underChange(change.path, keys)) continue;
-		keys.add(pathKey(change.path));
-		aliases.push(change);
-	}
-	return [...aliases, ...written];
-}
+* 'a']`; see changesBetween).
+*/
+var changesOf = (base, work) => changesBetween(base, work);
 /** Every running mutation, to commit with its code going on. */
 var running = () => activeScopes.map((scope) => ({
 	scope,
@@ -14930,9 +15003,11 @@ function runWithCommittedMutations(action) {
 */
 function mutateState(run) {
 	commitScopes(running());
+	const held = locateObjects(namespacesOf(getActiveMutationScope() ?? useStoryStore.getState()), []);
 	const scope = startScope();
+	const adopt = clonerFor(scope.work, held);
 	try {
-		run(scope.work);
+		run(scope.work, adopt);
 	} finally {
 		activeScopes.pop();
 	}
@@ -15687,35 +15762,60 @@ function loadedEntryMoment(payload) {
 * the `beforesave` hooks) into the payload's snapshot of the saved moment. A
 * load restores that snapshot, the state on entering the passage, and runs
 * the passage again, so data a hook adds to a save would otherwise be lost
-* on load (#227). Only the property paths the hooks changed are written (into
-* copies of the objects on those paths, the rest staying shared): a
-* whole variable would bring along what the passage did to the rest of it,
-* which the passage then does again on load (#232). Only the payload's copy
-* changes: the live history keeps the recorded snapshot (#159).
+* on load (#227). Only the property paths the hooks changed are written (see
+* changesBetween): a whole variable would bring along what the passage did
+* to the rest of it, which the passage then does again on load (#232). The
+* references the hooks made stay: an object they put in two variables is one
+* object in the snapshot, and one they made another variable refer to is the
+* snapshot's own object of it (#302). Only the payload's copy changes: the
+* live history keeps the recorded snapshot (#159).
 */
 function keepHookWrites(payload, before, after) {
 	const moment = payload.history[payload.historyIndex];
 	if (!moment) return;
-	mergeHookWrites(moment.variables, before, after, /* @__PURE__ */ new Set());
-}
-/**
-* Apply the hooks' changes between `before` and `after`, two objects or two
-* arrays, to the snapshot's copy of them, `target` (see mergeKeys: array
-* elements merge by index). A changed value is merged key by key where the
-* snapshot holds the same kind of value. Where it lacks the key or holds
-* another kind (the passage created or replaced it), the hooks' whole value
-* is written.
-*/
-function mergeHookWrites(target, before, after, ancestors) {
-	ancestors.add(after);
-	mergeKeys(target, before, after, (key, b, a) => {
-		if (!hasOwn(target, key) || !mergesWith(a, target[key], true) || ancestors.has(a)) return false;
-		const copy = shallowCopy(target[key]);
-		target[key] = copy;
-		mergeHookWrites(copy, b, a, ancestors);
-		return true;
-	});
-	ancestors.delete(after);
+	const changes = changesBetween(before, after, true);
+	if (changes.length === 0) return;
+	const work = deepClone(moment.variables);
+	const seen = existingObjects(locateObjects(after, changes), work);
+	const own = (value) => deepClone(value, { seen });
+	for (const change of changes) writeHookChange(work, after, change, own);
+	moment.variables = shareEqual(moment.variables, work);
+}
+/**
+* Write `change` (of the hooks, to `after`) into `work`. The value goes in at
+* the first place `work` lacks the objects on the path of one of the kind
+* `after` holds (the passage created or replaced it): there, the hooks' whole
+* value of it is written. Into an array, elements removed from the end are
+* removed at the same indices and elements added are appended; changes at
+* indices the array lacks are dropped (it was resized, so its indices do not
+* line up with the live ones).
+*/
+function writeHookChange(work, after, change, own) {
+	const { path } = change;
+	let holder = work;
+	let depth = 0;
+	for (; depth < path.length - 1; depth++) {
+		const key = path[depth];
+		const child = hasOwn(holder, key) ? holder[key] : void 0;
+		const held = getByPath(after, path.slice(0, depth + 1));
+		if (!mergesWith(child, held, true)) {
+			writeKey(holder, key, false, own(held));
+			return;
+		}
+		holder = child;
+	}
+	const key = path[depth];
+	if (change.deleted) writeKey(holder, key, true, void 0);
+	else writeKey(holder, key, false, own(change.value), change.appended);
+}
+function writeKey(holder, key, deleted, value, appended) {
+	if (Array.isArray(holder)) {
+		const index = Number(key);
+		if (deleted) holder.length = Math.min(holder.length, index);
+		else if (appended) holder.push(value);
+		else if (index < holder.length) holder[index] = value;
+	} else if (deleted) delete holder[key];
+	else setOwn(holder, key, value);
 }
 /** Restore the PRNG from a snapshot, or reset it without one. */
 function restorePRNGFrom(prng) {
@@ -17289,8 +17389,8 @@ function defineMacro(config, source = "builtin") {
 			ctx.value = useStoryStore((s) => getByPath(s.variables, segments));
 			ctx.getValue = () => getByPath(readState().variables, segments);
 			ctx.setValue = (value) => {
-				useStoryStore.setState((state) => {
-					setByPath(state.variables, segments, value, { createMissing: true });
+				mutateState((work, adopt) => {
+					setByPath(work.variables, segments, adopt(value), { createMissing: true });
 				});
 			};
 		}
@@ -17432,8 +17532,8 @@ function createStoryAPI() {
 				warnIfUndeclared(isTransient, key);
 			}
 			if (entries.some(([k]) => k.includes("."))) {
-				mutateState((work) => {
-					for (const [k, v] of entries) setOne(work, k, v);
+				mutateState((work, adopt) => {
+					for (const [k, v] of entries) setOne(work, k, adopt(v));
 				});
 				return;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohal12/spindle",
-  "version": "0.59.4",
+  "version": "0.59.5",
   "type": "module",
   "description": "A Preact-based story format for Twine 2.",
   "license": "Unlicense",

package/src/define-macro.ts

@@ -18,7 +18,7 @@ import {
   renderInlineNodes,
 } from './markup/render';
 import type { ASTNode } from './markup/ast';
-import { executeMutation, readState } from './execute-mutation';
+import { executeMutation, mutateState, readState } from './execute-mutation';
 import { evaluate } from './expression';
 import { useStoryStore } from './store';
 import { getByPath, setByPath } from './utils/object-path';
@@ -228,8 +228,11 @@ export function defineMacro<const P extends readonly ParameterDef[] = []>(
       // In program order, also when mutation code performs the input
       ctx.getValue = () => getByPath(readState().variables, segments);
       ctx.setValue = (value: unknown) => {
-        useStoryStore.setState((state) => {
-          setByPath(state.variables, segments, value, {
+        // The commit mutation code uses, which keeps the references among
+        // variables: a write to a draft copies only the path written, and
+        // other variables sharing the object would keep the old one.
+        mutateState((work, adopt) => {
+          setByPath(work.variables, segments, adopt(value), {
             createMissing: true,
           });
         });

package/src/execute-mutation.ts

@@ -10,11 +10,10 @@ import { useStoryStore } from './store';
 import type { StoryState, VariableNamespaces } from './store';
 import { execute } from './expression';
 import {
-  aliasChanges,
+  changesBetween,
   applyChange,
   deepClone,
   deepEqual,
-  diffPaths,
   existingObjects,
   isApplied,
   isMergeable,
@@ -22,7 +21,6 @@ import {
   mergeKeys,
   pathKey,
   sharedPaths,
-  underChange,
   type PathChange,
 } from './structural';
 import { getByPath, setByPath } from './utils/object-path';
@@ -96,7 +94,18 @@ function clonerFor(
   paths?: ReadonlyMap<object, string[]>,
 ): Cloner {
   const seen = paths ? existingObjects(paths, target) : new Map();
-  return (value) => deepClone(value, { keepUnregistered: true, seen });
+  // Immer does not finalize a draft held as a Map key, so an existing object
+  // met there is put in the draft as the object itself: its base while the
+  // code did not change it, which other references to it then agree with.
+  const mapKey = (copy: object, original: object): object => {
+    const path = paths?.get(original);
+    if (!path || !isDraft(copy)) return copy;
+    const plain = currentDraft(copy) as object;
+    setByPath(target as Record<string, unknown>, path, plain);
+    seen.set(original, plain);
+    return plain;
+  };
+  return (value) => deepClone(value, { keepUnregistered: true, seen, mapKey });
 }
 
 /** One cloner per target copy, made when first used. */
@@ -292,8 +301,10 @@ export function routeStoreUpdate<S extends VariableNamespaces>(
         )
       : [];
   });
-  // Each target takes its own copies, which share what the written values do
-  const cloners = clonersFor();
+  // Each target takes its own copies, which share what the written values do,
+  // and an object the code holds elsewhere stays that one (`Story.set('b', $a)`)
+  const held = locateObjects(namespacesOf(inner.work), changes);
+  const cloners = clonersFor(() => held);
   const owned = (change: PathChange, target: object): PathChange =>
     change.deleted
       ? change
@@ -370,6 +381,13 @@ function cloneNamespaces(from: VariableNamespaces): VariableNamespaces {
   };
 }
 
+/** The three variable namespaces of `state`, as an object to walk. */
+const namespacesOf = (state: VariableNamespaces): VariableNamespaces => ({
+  variables: state.variables,
+  temporary: state.temporary,
+  transient: state.transient,
+});
+
 /** A mutation to commit, and whether its code goes on running after. */
 interface Commit {
   scope: MutationScope;
@@ -470,28 +488,16 @@ function commitScopes(commits: readonly Commit[]): void {
 
 /**
  * The changes of the code to the namespaces, as paths below them (`['variables',
- * 'a']`): the property paths that differ (see diffPaths), and those that hold
- * equal content but another object than they did (see aliasChanges), those
- * first. Compared as one object, so an object the namespaces share is one
- * object, whichever of them it is reached through.
+ * 'a']`; see changesBetween).
  */
-function changesOf(
+const changesOf = (
   base: VariableNamespaces,
   work: VariableNamespaces,
-): PathChange[] {
-  const before = base as unknown as Record<string, unknown>;
-  const after = work as unknown as Record<string, unknown>;
-  const written = diffPaths(before, after);
-  const keys = new Set(written.map((c) => pathKey(c.path)));
-  const aliases: PathChange[] = [];
-  for (const change of aliasChanges(before, after)) {
-    // Written whole by a change at it or above it
-    if (underChange(change.path, keys)) continue;
-    keys.add(pathKey(change.path));
-    aliases.push(change);
-  }
-  return [...aliases, ...written];
-}
+): PathChange[] =>
+  changesBetween(
+    base as unknown as Record<string, unknown>,
+    work as unknown as Record<string, unknown>,
+  );
 
 /** Every running mutation, to commit with its code going on. */
 const running = (): Commit[] =>
@@ -537,13 +543,23 @@ export function runWithCommittedMutations<T>(action: () => T): T {
  * between values are kept, which a store update made on a draft does not do.
  * Nothing is committed when `run` throws.
  */
-export function mutateState(run: (work: VariableNamespaces) => void): void {
+export function mutateState(
+  run: (work: VariableNamespaces, adopt: Cloner) => void,
+): void {
   // The writes of the code this runs inside come first, and stay even if
   // `run` throws
   commitScopes(running());
+  // Where the objects `run` may be handed are: in the state it continues from
+  const held = locateObjects(
+    namespacesOf(getActiveMutationScope() ?? useStoryStore.getState()),
+    [],
+  );
   const scope = startScope();
+  // Copies values into the working copy, an object it holds already staying
+  // that one, and what the values share staying shared
+  const adopt = clonerFor(scope.work, held);
   try {
-    run(scope.work);
+    run(scope.work, adopt);
   } finally {
     activeScopes.pop();
   }