@grida/svg-editor 1.0.0-alpha.16 → 1.0.0-alpha.18

package/dist/{model-D0nU_EkL.js → model-BLhMJZKJ.js}

@@ -154,10 +154,20 @@ const GEOMETRY_ATTRS = new Set([
 ]);
 /** `transform:` CSS property at the start of a declaration list or after `;`. */
 const CSS_TRANSFORM_PROPERTY = /(?:^|;)\s*transform\s*:/i;
+/** Trivia shape for editor-synthesized attribute tokens — parser-authored
+*  tokens carry their source trivia verbatim; tokens the editor appends get
+*  this one canonical shape (` name="value"`). */
+const SYNTH_ATTR_TRIVIA = {
+	pre: " ",
+	eq_trivia: "",
+	eq_trailing: "",
+	quote: "\""
+};
 var SvgDocument = class SvgDocument {
 	constructor(svg) {
 		this.listeners = /* @__PURE__ */ new Set();
 		this._structure_version = 0;
+		this._revision = 0;
 		this._geometry_version = 0;
 		if (typeof svg !== "string") throw new TypeError(`new SvgDocument(svg) requires a string source, got ${svg === null ? "null" : typeof svg}`);
 		this.source = svg;
@@ -205,6 +215,20 @@ var SvgDocument = class SvgDocument {
 	get structure_version() {
 		return this._structure_version;
 	}
+	/**
+	* Total mutation counter — advances on EVERY listener-visible mutation
+	* (attribute, style, text, topology, load/reset), unlike the selective
+	* `structure_version` / `geometry_version` channels. The single
+	* edit-version source: anything derived from this document — the
+	* editor's `content_version` / `dirty`, memoized reads, a rendered
+	* projection — answers "am I current?" by comparing values, with no
+	* event-ordering dependence. Advances BEFORE listeners fire, so a
+	* read issued from inside a change listener already sees the new
+	* value.
+	*/
+	get revision() {
+		return this._revision;
+	}
 	/** See `_geometry_version` for what this counter signals. */
 	get geometry_version() {
 		return this._geometry_version;
@@ -221,15 +245,15 @@ var SvgDocument = class SvgDocument {
 	* settled glyph metrics. See ../../docs/geometry.md §Limitations.
 	*
 	* Deliberately does NOT call `emit()`: this is not a document edit, so
-	* it must not bump `doc_version` / mark the doc dirty / touch undo
-	* (the editor's `on_change` handler does all three). The editor's
-	* `_internal.bump_geometry` advances `geometry_version` here and fans
-	* out the geometry listeners itself.
+	* `revision` must not advance — no dirty flag, no undo, no render
+	* flush. The editor's `_internal.bump_geometry` advances
+	* `geometry_version` here and fans out the geometry listeners itself.
 	*/
 	bump_geometry() {
 		this._geometry_version++;
 	}
 	emit() {
+		this._revision++;
 		for (const fn of this.listeners) fn();
 	}
 	/** Notify subscribers — for callers that mutate directly via setAttr/etc. */
@@ -380,9 +404,7 @@ var SvgDocument = class SvgDocument {
 				local: name,
 				ns,
 				value,
-				pre: " ",
-				eq_trivia: "",
-				quote: "\""
+				...SYNTH_ATTR_TRIVIA
 			});
 			if (structural) this._structure_version++;
 			if (geometry) this._geometry_version++;
@@ -638,9 +660,7 @@ var SvgDocument = class SvgDocument {
 			local: "d",
 			ns: null,
 			value: d,
-			pre: " ",
-			eq_trivia: "",
-			quote: "\""
+			...SYNTH_ATTR_TRIVIA
 		});
 		let added_fill_none = false;
 		if (prev_local === "line" && this.get_attr(id, "fill") === null && this.get_style(id, "fill") === null) {
@@ -650,9 +670,7 @@ var SvgDocument = class SvgDocument {
 				local: "fill",
 				ns: null,
 				value: "none",
-				pre: " ",
-				eq_trivia: "",
-				quote: "\""
+				...SYNTH_ATTR_TRIVIA
 			});
 			added_fill_none = true;
 		}
@@ -1019,7 +1037,7 @@ var SvgDocument = class SvgDocument {
 		}
 	}
 	emit_attr(a) {
-		return `${a.pre}${a.raw_name}${a.eq_trivia}=${a.quote}${(0, _grida_svg_parser.encode_attr_value)(a.value, a.quote)}${a.quote}`;
+		return `${a.pre}${a.raw_name}${a.eq_trivia}=${a.eq_trailing}${a.quote}${(0, _grida_svg_parser.encode_attr_value)(a.value, a.quote)}${a.quote}`;
 	}
 };
 function parse_inline_style(s) {
@@ -1037,6 +1055,131 @@ function parse_inline_style(s) {
 	}
 	return out;
 }
+/**
+* Namespace prefixes resolvable without a source declaration. ONE table,
+* shared by the paste-side hoist (`insert_fragment`'s xmlns plan) and the
+* copy-side shell repair (clipboard payload extraction) — the two sides
+* form a round-trip and must agree: a prefix only one side knows would
+* produce payloads the other can't honor.
+*/
+const WELL_KNOWN_NS_PREFIXES = new Map([["xlink", _grida_svg_parser.XLINK_NS]]);
+//#endregion
+//#region src/core/subtree.ts
+/**
+* The selection → subtree algebra the two extraction operations share,
+* plus the clone-specific member (`clone_plan`).
+*
+* The clipboard FRD
+* ([docs/wg/feat-svg-editor/clipboard.md](../../../../docs/wg/feat-svg-editor/clipboard.md)
+* §Two extraction operations) names two operations over a normalized
+* selection: **payload extraction** (copy — `core/clipboard.ts`) and
+* **subtree clone** (duplicate / clone-drag — this module; design note:
+* [docs/wg/feat-svg-editor/subtree-clone.md](../../../../docs/wg/feat-svg-editor/subtree-clone.md)).
+* They share exactly two things — selection normalization
+* ({@link subtree.normalize_roots}) and verbatim subtree serialization
+* (`SvgDocument.serialize_node`) — and nothing else.
+*
+* Unlike copy's payload, a clone carries **no reference closure and no
+* namespace shell**: the destination is the source document, every
+* `url(#…)` / `href` reference still resolves against it, and carrying
+* definitions would deposit duplicate defs on every duplicate.
+*
+* Consumers: `commands.duplicate` (⌘D) and the translate orchestrator's
+* Alt-drag clone session (gridaco/grida#817).
+*
+* Verbatim-id policy: authored `id=""` attributes are cloned verbatim,
+* NEVER rewritten — same stance as `insert_fragment`. A clone of a node
+* carrying `id="x"` yields a second `id="x"`; reference resolution follows
+* the host renderer's first-in-document-order rule (a cloned subtree's
+* internal self-reference resolves to the ORIGINAL), and deduplication is
+* the explicit Tidy command's job.
+*/
+let subtree;
+(function(_subtree) {
+	function by_document_order(doc) {
+		const index = /* @__PURE__ */ new Map();
+		let i = 0;
+		for (const id of doc.all_nodes()) index.set(id, i++);
+		return (a, b) => (index.get(a) ?? 0) - (index.get(b) ?? 0);
+	}
+	_subtree.by_document_order = by_document_order;
+	function normalize_roots(doc, selection, order) {
+		const live = [...new Set(selection)].filter((id) => doc.is_element(id) && doc.contains(doc.root, id));
+		const roots = doc.prune_nested_nodes(live);
+		if (roots.length > 1) roots.sort(order ?? by_document_order(doc));
+		return roots;
+	}
+	_subtree.normalize_roots = normalize_roots;
+	function clone_plan(doc, selection) {
+		const out = [];
+		for (const origin of normalize_roots(doc, selection)) {
+			const parent = doc.parent_of(origin);
+			if (parent === null) continue;
+			if (doc.tag_of(origin) === "svg") continue;
+			const { roots } = doc.create_fragment(doc.serialize_node(origin));
+			if (roots.length !== 1) throw new Error(`subtree.clone_plan: cloning ${JSON.stringify(origin)} yielded ${roots.length} roots`);
+			out.push({
+				origin,
+				clone: roots[0],
+				parent,
+				before: doc.next_sibling_of(origin)
+			});
+		}
+		return out;
+	}
+	_subtree.clone_plan = clone_plan;
+	function insert_plan(doc, plan) {
+		for (const p of plan) doc.insert(p.clone, p.parent, p.before);
+	}
+	_subtree.insert_plan = insert_plan;
+	function remove_plan(doc, plan) {
+		for (const p of plan) doc.remove(p.clone);
+	}
+	_subtree.remove_plan = remove_plan;
+	/** Per-member rigidity tolerance for the rigid-translate witness in
+	*  {@link repeat_delta} — position drift from the shared delta, and
+	*  size drift from the origin. Generous against float noise from
+	*  re-encoded path data / `getBBox`, far below anything a user would
+	*  call a move or a resize. */
+	const REPEAT_RIGID_EPSILON = .01;
+	function repeat_delta(record, targets, bounds_of) {
+		if (record === null) return null;
+		if (record.origins.length === 0) return null;
+		if (record.origins.length !== record.clones.length) return null;
+		if (!array_shallow_equal(record.clones, targets)) return null;
+		const origin_bounds = collect_bounds(record.origins, bounds_of);
+		if (origin_bounds === null) return null;
+		const clone_bounds = collect_bounds(record.clones, bounds_of);
+		if (clone_bounds === null) return null;
+		const a = _grida_cmath.default.rect.union(origin_bounds);
+		const b = _grida_cmath.default.rect.union(clone_bounds);
+		const dx = b.x - a.x;
+		const dy = b.y - a.y;
+		for (let i = 0; i < origin_bounds.length; i++) {
+			const o = origin_bounds[i];
+			const c = clone_bounds[i];
+			if (Math.abs(c.x - o.x - dx) > REPEAT_RIGID_EPSILON || Math.abs(c.y - o.y - dy) > REPEAT_RIGID_EPSILON || Math.abs(c.width - o.width) > REPEAT_RIGID_EPSILON || Math.abs(c.height - o.height) > REPEAT_RIGID_EPSILON) return null;
+		}
+		if (Math.abs(dx) <= REPEAT_RIGID_EPSILON && Math.abs(dy) <= REPEAT_RIGID_EPSILON) return null;
+		return {
+			x: dx,
+			y: dy
+		};
+	}
+	_subtree.repeat_delta = repeat_delta;
+	/** All-or-nothing bounds gather for {@link repeat_delta} — one
+	*  unmeasurable member and the record can't witness a rigid
+	*  translate. */
+	function collect_bounds(ids, bounds_of) {
+		const out = [];
+		for (const id of ids) {
+			const r = bounds_of(id);
+			if (r === null) return null;
+			out.push(r);
+		}
+		return out;
+	}
+})(subtree || (subtree = {}));
 //#endregion
 //#region src/core/transform.ts
 let transform;
@@ -1804,6 +1947,8 @@ let translate_pipeline;
 })(translate_pipeline || (translate_pipeline = {}));
 //#endregion
 //#region src/core/translate-pipeline/orchestrator.ts
+const movers = (s) => s.clone?.ids ?? s.ids;
+const mover_baselines = (s) => s.clone?.baselines ?? s.baselines;
 const PROVIDER_ID$2 = "svg-editor";
 var TranslateOrchestrator = class {
 	constructor(deps) {
@@ -1826,25 +1971,33 @@ var TranslateOrchestrator = class {
 	drive(input, modifiers, opts) {
 		if (this.active === null) this.active = this.open(input.ids, opts.snap, opts.label ?? "move");
 		const session = this.active;
+		this.reconcile_clone(session, modifiers);
 		const stages = opts.stages ?? translate_pipeline.stages.DEFAULT;
 		const result = this.run_pass(session, input.movement, modifiers, opts.policy, stages);
 		session.last_movement = input.movement;
 		session.last_policy = opts.policy;
 		session.last_stages = stages;
-		this.write_preview_delta(session, result.plan);
+		if (opts.phase === "commit" && session.clone !== null) this.write_commit_composite(session, result.plan);
+		else this.write_preview_delta(session, result.plan);
 		if (opts.phase === "commit") {
+			const cloned = session.clone;
 			session.preview.commit();
 			this.dispose_session();
+			if (cloned !== null) this.deps.on_clone_commit?.({
+				origins: cloned.plan.map((p) => p.origin),
+				clones: cloned.ids
+			});
 		}
 		return result;
 	}
 	/** Re-run the current preview frame with new modifiers, reusing the
 	*  last-known movement / policy / stages. Used when a modifier key
-	*  changes between pointer-move events (Shift down/up mid-drag).
-	*  No-op when no session is active. */
+	*  changes between pointer-move events (Shift down/up mid-drag,
+	*  Alt down/up → clone toggle). No-op when no session is active. */
 	redrive_modifiers(modifiers) {
 		if (!this.active) return null;
 		const session = this.active;
+		this.reconcile_clone(session, modifiers);
 		const result = this.run_pass(session, session.last_movement, modifiers, session.last_policy, session.last_stages);
 		this.write_preview_delta(session, result.plan);
 		return result;
@@ -1852,15 +2005,22 @@ var TranslateOrchestrator = class {
 	/** Cancel an in-flight gesture (Escape, programmatic abort). */
 	cancel() {
 		if (!this.active) return;
-		this.active.preview.discard();
+		const session = this.active;
+		session.preview.discard();
+		if (session.clone !== null) {
+			subtree.remove_plan(this.deps.get_doc(), session.clone.plan);
+			this.deps.set_selection?.(session.ids);
+			this.deps.emit();
+		}
 		this.dispose_session();
 	}
 	/** Build a plan + context, run the pipeline, stash guides. Pure
-	*  computation — does not touch the preview. */
+	*  computation — does not touch the preview. The context's modifiers
+	*  are the pipeline's own vocabulary: stages never see `clone`. */
 	run_pass(session, movement, modifiers, policy, stages) {
 		const plan0 = {
-			ids: session.ids,
-			baselines: session.baselines,
+			ids: movers(session),
+			baselines: mover_baselines(session),
 			delta: {
 				x: 0,
 				y: 0
@@ -1868,7 +2028,7 @@ var TranslateOrchestrator = class {
 		};
 		const ctx = {
 			input: {
-				ids: session.ids,
+				ids: plan0.ids,
 				movement
 			},
 			modifiers,
@@ -1880,6 +2040,69 @@ var TranslateOrchestrator = class {
 		this._last_guides = result.guides;
 		return result;
 	}
+	/**
+	* Clone-modifier state machine (Alt-drag translate-with-clone). Runs
+	* before each pipeline pass so a toggle takes effect on the very frame
+	* it happens — lazy clone on the first frame with the modifier held.
+	*
+	* Both edges and the composite commit below depend on one invariant:
+	* `translate_pipeline.*.revert` writes ABSOLUTE baseline values (incl.
+	* tspan's exact-attr restore), so re-reverting an already-reverted set
+	* is a no-op. A future relative-write baseline kind would break this.
+	*/
+	reconcile_clone(session, modifiers) {
+		const want = modifiers.clone === true;
+		const cloned = session.clone !== null;
+		if (want && !cloned) this.enter_clone(session);
+		else if (!want && cloned) this.exit_clone(session);
+	}
+	/** Enter the cloned state: origins back to rest, verbatim clones
+	*  inserted next to them, gesture + selection + snap retargeted to the
+	*  clones. The origin set stays untouched for the rest of the cloned
+	*  gesture — the CLONE moves, the origin stays (Figma convention). */
+	enter_clone(session) {
+		const doc = this.deps.get_doc();
+		translate_pipeline.revert(doc, {
+			ids: session.ids,
+			baselines: session.baselines,
+			delta: {
+				x: 0,
+				y: 0
+			}
+		});
+		const plan = subtree.clone_plan(doc, session.ids);
+		if (plan.length === 0) return;
+		subtree.insert_plan(doc, plan);
+		const baselines = /* @__PURE__ */ new Map();
+		for (const p of plan) baselines.set(p.clone, session.baselines.get(p.origin));
+		session.clone = {
+			plan,
+			ids: plan.map((p) => p.clone),
+			baselines
+		};
+		this.retarget(session, session.clone.ids);
+	}
+	/** Exit the cloned state: clones removed, gesture + selection + snap
+	*  retargeted back to the origins, which resume following the cursor
+	*  on the next pass. Removed clones stay in the document's id map
+	*  (standard removed-node policy) and are never serialized; a stale
+	*  preview delta auto-reverting onto them later is harmless. Re-press
+	*  = fresh enter with new clones. */
+	exit_clone(session) {
+		subtree.remove_plan(this.deps.get_doc(), session.clone.plan);
+		session.clone = null;
+		this.retarget(session, session.ids);
+	}
+	/** Point selection + snap at the new mover set. Selection + emit run
+	*  BEFORE the snap reopen: the surface re-renders on notify, so freshly
+	*  inserted clones are measurable when the new snap session captures
+	*  its neighborhood (where the origins are legitimate snap targets). */
+	retarget(session, ids) {
+		this.deps.set_selection?.(ids);
+		this.deps.emit();
+		session.snap?.dispose();
+		session.snap = session.snap_requested ? this.deps.open_snap(ids) : null;
+	}
 	open(ids, snap, label) {
 		const doc = this.deps.get_doc();
 		const filtered = doc.prune_nested_nodes(ids);
@@ -1887,10 +2110,12 @@ var TranslateOrchestrator = class {
 			ids: filtered,
 			baselines: translate_pipeline.intent.capture_baselines(doc, filtered),
 			snap: snap ? this.deps.open_snap(filtered) : null,
+			snap_requested: snap,
 			preview: this.deps.open_preview(label),
 			last_movement: [0, 0],
 			last_policy: "engine",
-			last_stages: translate_pipeline.stages.DEFAULT
+			last_stages: translate_pipeline.stages.DEFAULT,
+			clone: null
 		};
 	}
 	/** Bind a fresh apply/revert pair (closure over `plan`) into the
@@ -1912,6 +2137,43 @@ var TranslateOrchestrator = class {
 			}
 		});
 	}
+	/** Commit-time delta for a CLONED gesture. Per-frame deltas stay
+	*  translate-only; the structural insert happened at the toggle edge,
+	*  outside the preview. The one delta that gets committed must own the
+	*  whole outcome, so a single undo removes clone + move and a redo
+	*  restores both:
+	*    apply  = insert clones (idempotent reposition when live) +
+	*             translate + select clones
+	*    revert = un-translate + remove clones + select origins
+	*  `preview.set` reverts the previous translate-only delta first
+	*  (clones back to rest), then runs this apply — the document passes
+	*  through exactly the states the closures describe.
+	*  Captures locals only (not the session), so the committed delta
+	*  retains the minimum undo/redo needs. */
+	write_commit_composite(session, plan) {
+		const doc = this.deps.get_doc();
+		const emit = this.deps.emit;
+		const project = this.deps.project_delta;
+		const set_selection = this.deps.set_selection;
+		const clone_plan = session.clone.plan;
+		const clone_ids = session.clone.ids;
+		const origin_ids = session.ids;
+		session.preview.set({
+			providerId: PROVIDER_ID$2,
+			apply: () => {
+				subtree.insert_plan(doc, clone_plan);
+				translate_pipeline.apply(doc, plan, project);
+				set_selection?.(clone_ids);
+				emit();
+			},
+			revert: () => {
+				translate_pipeline.revert(doc, plan);
+				subtree.remove_plan(doc, clone_plan);
+				set_selection?.(origin_ids);
+				emit();
+			}
+		});
+	}
 	dispose_session() {
 		if (!this.active) return;
 		this.active.snap?.dispose();
@@ -2772,6 +3034,60 @@ function scale_path_d(d, origin, sx, sy) {
 	}
 }
 /**
+* `dispatch_resize`'s write surface as data: the attribute names each
+* handler may write, by tag. Capture-side snapshots (the resize
+* pipeline's `baseline.raw`) are built from this list so revert can
+* restore exactly what a handler may touch — when a handler starts
+* writing a new attribute, extend this table or undo will silently
+* miss it. Cross-checked against the live handlers by
+* `__tests__/resize-snapshot-coverage.test.ts`.
+*/
+const RESIZE_WRITE_ATTRS = {
+	rect: [
+		"x",
+		"y",
+		"width",
+		"height"
+	],
+	image: [
+		"x",
+		"y",
+		"width",
+		"height"
+	],
+	use: [
+		"x",
+		"y",
+		"width",
+		"height"
+	],
+	circle: [
+		"cx",
+		"cy",
+		"r"
+	],
+	ellipse: [
+		"cx",
+		"cy",
+		"rx",
+		"ry"
+	],
+	line: [
+		"x1",
+		"y1",
+		"x2",
+		"y2"
+	],
+	polyline: ["points"],
+	polygon: ["points"],
+	path: ["d"],
+	text: [
+		"x",
+		"y",
+		"font-size"
+	]
+};
+/**
 * VertexChain × resize — vertex transport in local space.
 * Line carries its own (x1, y1, x2, y2); polyline / polygon share `points`.
 * Result type is preserved.
@@ -3078,6 +3394,15 @@ let resize_pipeline;
 		function num(doc, id, name, fallback = 0) {
 			return _grida_svg_parse.svg_parse.parse_number(doc.get_attr(id, name), fallback);
 		}
+		/** Attribute names a resize gesture may write for `tag`: the
+		*  handler write surface (`RESIZE_WRITE_ATTRS`, owned next to the
+		*  handlers) plus `transform` — the pipeline's own write
+		*  (commit-phase `renormalize_rotate_pivot`). Drives the
+		*  `baseline.raw` snapshot that `restore` writes back. */
+		function writable_attrs(tag) {
+			const handler_writes = RESIZE_WRITE_ATTRS[tag];
+			return handler_writes ? [...handler_writes, "transform"] : [];
+		}
 		function is_resizable(tag) {
 			switch (tag) {
 				case "rect":
@@ -3179,12 +3504,21 @@ let resize_pipeline;
 					break;
 				default: attrs = { kind: "unsupported" };
 			}
+			const raw = writable_attrs(tag).map((name) => ({
+				name,
+				value: doc.get_attr(id, name)
+			}));
 			return {
 				bbox,
-				attrs
+				attrs,
+				raw
 			};
 		}
 		_intent.capture_baseline = capture_baseline;
+		function restore(doc, id, baseline) {
+			for (const a of baseline.raw) doc.set_attr(id, a.name, a.value);
+		}
+		_intent.restore = restore;
 		function compute_factors(baseline, dir, dx, dy, shift) {
 			const b = baseline.bbox;
 			let anchorX = 0;
@@ -3587,12 +3921,11 @@ let resize_pipeline;
 	}
 	_resize_pipeline.apply = apply;
 	function revert(doc, plan) {
-		const f = intent.compute_factors(plan.baseline, plan.direction, 0, 0, false);
 		const members = plan.members ?? [{
 			id: plan.id,
 			baseline: plan.baseline
 		}];
-		for (const m of members) intent.apply(doc, m.id, m.baseline, 1, 1, f.origin, "preview");
+		for (const m of members) intent.restore(doc, m.id, m.baseline);
 	}
 	_resize_pipeline.revert = revert;
 	function synthesize_group_baseline(union) {
@@ -3609,7 +3942,8 @@ let resize_pipeline;
 				y: union.y,
 				w: union.width,
 				h: union.height
-			}
+			},
+			raw: []
 		};
 	}
 	_resize_pipeline.synthesize_group_baseline = synthesize_group_baseline;
@@ -4915,6 +5249,12 @@ Object.defineProperty(exports, "TranslateOrchestrator", {
 		return TranslateOrchestrator;
 	}
 });
+Object.defineProperty(exports, "WELL_KNOWN_NS_PREFIXES", {
+	enumerable: true,
+	get: function() {
+		return WELL_KNOWN_NS_PREFIXES;
+	}
+});
 Object.defineProperty(exports, "__exportAll", {
 	enumerable: true,
 	get: function() {
@@ -4975,6 +5315,12 @@ Object.defineProperty(exports, "rotate_pipeline", {
 		return rotate_pipeline;
 	}
 });
+Object.defineProperty(exports, "subtree", {
+	enumerable: true,
+	get: function() {
+		return subtree;
+	}
+});
 Object.defineProperty(exports, "transform", {
 	enumerable: true,
 	get: function() {