1import { test } from"node:test";2importassertfrom"node:assert/strict";3import {4declaration,5example,6Stack,7Shelf,8Switcher,9typeComposition,10} from"../documentation/components/source/composition.ts";11import { atPath } from"../documentation/components/source/grouping.ts";12import { chooseMember } from"../documentation/components/source/composition-editing.ts";13import {14addText,15beginTextEdit,16cancelTextEdit,17commitEdit,18editsFor,19editText,20finishTextEdit,21newText,22releaseGroup,23removeMember,24restoreWorkingCopy,25restoreWorkingTree,26startWorkingCopy,27typeText,28undoEdit,29workingCopyLimits,30wrapMembers,31typeWorkingCopy,32} from"../documentation/components/source/working-copy.ts";3334conststored= (value:unknown):unknown=>JSON.parse(JSON.stringify(value));35consttext= (value:string):Composition=> ({ kind: "Text", text: value });36constheading= (value:string):Composition=> ({37kind: "Heading",38text: value,39});40const [a, b, c, d] = ["a", "b", "c", "d"].map(text) as [41Composition,42Composition,43Composition,44Composition,45];46/** A saved group as storage holds it: no promise that it is a composition. */47constgroup= (kind:string, ...children:unknown[]) => ({ kind, children });48functionat(tree:Composition, path:string):Composition {49constnode=atPath(tree, path);50if (!node) thrownewError(`Nothing at ${path}`);51returnnode;52}53constprinted= (tree:Composition) =>54declaration(tree)55 .map((line) =>line.tokens.map((token) =>token.text).join(""))56 .join("\n");57/** A chain of `levels` groups, the innermost empty. */58constnested= (levels:number):Composition=>59levels===1?Stack() :Stack(nested(levels-1));6061test("a working copy may hold any text, any number of members and any arrangement", () => {62consttree=Stack(63heading("Mine"),64Switcher(),65Shelf(text("only member")),66Stack(Switcher(text(""), text("two")), Stack()),67 );68assert.deepEqual(restoreWorkingTree(stored(tree)), tree);69assert.deepEqual(restoreWorkingTree(stored(Stack())), Stack(), "empty root");70// Nothing but the composition survives: the result is built afresh.71assert.deepEqual(72restoreWorkingTree({73kind: "Shelf",74text: "ignored",75extra: true,76children: [{ kind: "Meta", text: "m", children: [], onclick: "x" }],77 }),78Shelf({ kind: "Meta", text: "m" }),79 );80});8182test("a saved working copy is rejected unless it is a bounded composition under a root group", () => {83for (const [saved, why] of [84 [null, "nothing saved"],85 ["Stack()", "a string"],86 [[text("a")], "an array"],87 [text("a"), "the root is content"],88 [group("Grid", a), "an unknown arrangement"],89 [group("Stack", { kind: "Image", text: "a" }), "an unknown kind"],90 [group("Stack", { kind: "Text", text: 7 }), "text that is not a string"],91 [group("Stack", { kind: "Text" }), "content without text"],92 [{ kind: "Stack" }, "a group without members"],93 [{ kind: "Stack", children: { 0: a, length: 1 } }, "members not a list"],94 [group("Stack", a, null), "a missing member"],95 [nested(workingCopyLimits.ancestors+2), "nesting past the limit"],96 [97Stack(...Array.from({ length: workingCopyLimits.nodes }, () =>a)),98"more nodes than the limit",99 ],100 ] asconst)101assert.equal(restoreWorkingTree(stored(saved)), undefined, why);102assert.ok(restoreWorkingTree(nested(workingCopyLimits.ancestors+1)));103assert.ok(104restoreWorkingTree(105Stack(...Array.from({ length: workingCopyLimits.nodes-1 }, () =>a)),106 ),107 );108});109110test("a saved working copy restores its composition, selection and history, each validated", () => {111constmodel=Stack(Switcher(a, b), c);112constearlier=Stack(a, b, c);113constsaved=stored({114model,115chosen: ["0.0"],116undo: [117 { model: earlier, chosen: ["0.0", "0.1"] },118 { model: group("Grid", a), chosen: [] },119 { model: earlier, chosen: ["0.0", "0.2"] },120"not an entry",121 ],122width: 480,123 });124assert.deepEqual(restoreWorkingCopy(saved), {125model,126chosen: ["0.0"],127undo: [128 { model: earlier, chosen: ["0.0", "0.1"] },129// Members that are not neighbors are no selection in that composition.130 { model: earlier, chosen: [] },131 ],132 });133assert.equal(restoreWorkingCopy(stored({ model: a, undo: [] })), undefined);134assert.equal(restoreWorkingCopy(null), undefined);135assert.deepEqual(136restoreWorkingCopy(stored({ model, chosen: ["0.9"], undo: "none" })),137 { model, chosen: [], undo: [] },138"a stale selection and an unreadable history restore as none",139 );140constlong=Array.from(141 { length: workingCopyLimits.history+5 },142 (_, i) => ({143model: Stack(text(`${i}`)),144chosen: [],145 }),146 );147constrestored=restoreWorkingCopy(stored({ model, undo: long }))!;148assert.equal(restored.undo.length, workingCopyLimits.history);149assert.deepEqual(restored.undo.at(-1), long.at(-1), "the latest are kept");150});151152test("the selection decides which edits are offered", () => {153consttree=Stack(heading("h"), Switcher(a, b), Shelf(), c);154constoffered= (chosen:readonlystring[]) => {155constedits=editsFor(tree, chosen);156return {157text: edits.text?.path,158arrange: edits.arrange?.path,159inside: edits.inside&& [edits.inside.parent, edits.inside.index],160after: edits.after&& [edits.after.parent, edits.after.index],161wrap: edits.wrap,162release: edits.release,163remove: edits.remove,164 };165 };166constnone= {167text: undefined,168arrange: undefined,169inside: undefined,170after: undefined,171wrap: undefined,172release: undefined,173remove: undefined,174 };175assert.deepEqual(176offered([]),177 { ...none, inside: ["0", 4] },178"with nothing selected, new text joins the whole composition",179 );180assert.deepEqual(181offered(["0"]),182 { ...none, arrange: "0", inside: ["0", 4] },183"the root can be arranged and added to, never wrapped, released or removed",184 );185assert.deepEqual(offered(["0.0"]), {186...none,187text: "0.0",188after: ["0", 1],189wrap: ["0.0"],190remove: "0.0",191 });192assert.deepEqual(193offered(["0.1"]),194 {195...none,196arrange: "0.1",197inside: ["0.1", 2],198after: ["0", 2],199wrap: ["0.1"],200release: "0.1",201remove: "0.1",202 },203"an inner group is both a group and a member",204 );205assert.deepEqual(206offered(["0.2"]),207 {208...none,209arrange: "0.2",210inside: ["0.2", 0],211after: ["0", 3],212wrap: ["0.2"],213release: "0.2",214remove: "0.2",215 },216"an empty group offers everything a full one does",217 );218assert.deepEqual(219offered(["0.2", "0.1"]),220 { ...none, after: ["0", 3], wrap: ["0.1", "0.2"] },221"a run is wrapped in reading order and added after its last member",222 );223assert.deepEqual(224offered(["0.1.0", "0.1.1"]),225 { ...none, after: ["0.1", 2], wrap: ["0.1.0", "0.1.1"] },226"every member of a group may be wrapped together",227 );228assert.deepEqual(229offered(["0.9"]),230offered([]),231"a stale path selects nothing",232 );233assert.equal(editsFor(tree, ["0.1"]).full, false);234});235236test("edits that would pass the limits are withheld, and the reason is known", () => {237constcrowded=Stack(238Stack(a),239...Array.from({ length: workingCopyLimits.nodes-3 }, () =>b),240 );241constedits=editsFor(crowded, ["0.0"]);242assert.equal(edits.inside, undefined);243assert.equal(edits.after, undefined);244assert.equal(edits.wrap, undefined);245assert.equal(edits.full, true);246assert.equal(edits.remove, "0.0", "removing is how room is made");247assert.equal(editsFor(crowded, ["0"]).full, true);248249// The innermost group sits at the deepest level a working copy allows.250constdeep=nested(workingCopyLimits.ancestors+1);251constinnermost=`0${".0".repeat(workingCopyLimits.ancestors)}`;252assert.deepEqual(at(deep, innermost), Stack());253assert.equal(editsFor(deep, [innermost]).inside, undefined);254assert.equal(editsFor(deep, [innermost]).wrap, undefined);255assert.equal(editsFor(deep, [innermost]).full, true);256assert.ok(editsFor(deep, [innermost]).after, "a sibling adds no level");257assert.equal(258editsFor(deep, ["0.0"]).wrap,259undefined,260"its subtree is too deep",261 );262constshallower=nested(workingCopyLimits.ancestors);263constedited=addText(264shallower,265editsFor(shallower, [`0${".0".repeat(workingCopyLimits.ancestors-1)}`])266 .inside!,267 );268assert.ok(restoreWorkingTree(stored(edited.tree)));269});270271test("rewording keeps the kind, the place and everything else", () => {272consttree=Stack(heading("Before"), Switcher(a, b));273constnext=editText(tree, "0.0", "After");274assert.deepEqual(next, Stack(heading("After"), Switcher(a, b)));275assert.equal(at(next, "0.1"), at(tree, "0.1"), "untouched groups are shared");276assert.equal(editText(tree, "0.0", "Before"), tree, "nothing changed");277assert.deepEqual(at(editText(tree, "0.1.1", ""), "0.1.1"), text(""));278assert.throws(() =>editText(tree, "0.1", "group"));279assert.throws(() =>editText(tree, "0.7", "missing"));280});281282test("new text joins a group, even an empty one, or follows a member, and is selected", () => {283consttree=Stack(Switcher(), a, Shelf(b, c));284constinside=addText(tree, editsFor(tree, ["0.0"]).inside!);285assert.deepEqual(inside.tree, Stack(Switcher(text(newText)), a, Shelf(b, c)));286assert.deepEqual(inside.chosen, ["0.0.0"]);287288constafter=addText(tree, editsFor(tree, ["0.1"]).after!, "next");289assert.deepEqual(after.tree, Stack(Switcher(), a, text("next"), Shelf(b, c)));290assert.deepEqual(after.chosen, ["0.2"]);291assert.equal(292at(after.tree, "0.3"),293at(tree, "0.2"),294"later members move along",295 );296297// After a group, as its sibling: between it and whatever follows.298constbeside=addText(tree, editsFor(tree, ["0.0"]).after!);299assert.deepEqual(300beside.tree,301Stack(Switcher(), text(newText), a, Shelf(b, c)),302 );303constend=addText(tree, editsFor(tree, []).inside!);304assert.deepEqual(end.chosen, ["0.3"]);305assert.deepEqual(306addText(Stack(), editsFor(Stack(), []).inside!).tree,307Stack(text(newText)),308"an empty composition can be added to",309 );310assert.throws(() =>addText(tree, { parent: "0.1", index: 0 }));311assert.throws(() =>addText(tree, { parent: "0.0", index: 2 }));312});313314test("removing a member never dissolves its group", () => {315consttree=Stack(Switcher(a, b), Shelf(c), d);316constone=removeMember(tree, "0.0.1");317assert.deepEqual(one.tree, Stack(Switcher(a), Shelf(c), d));318assert.deepEqual(one.chosen, ["0.0.0"], "the member before, at the end");319320constnone=removeMember(one.tree, "0.0.0");321assert.deepEqual(none.tree, Stack(Switcher(), Shelf(c), d));322assert.deepEqual(none.chosen, ["0.0"], "the emptied group");323324constfirst=removeMember(tree, "0.0.0");325assert.deepEqual(first.chosen, ["0.0.0"], "the member now in that place");326assert.deepEqual(at(first.tree, "0.0.0"), b);327328// A group goes with everything in it; its own parent stays.329constwhole=removeMember(tree, "0.0");330assert.deepEqual(whole.tree, Stack(Shelf(c), d));331lettree2=whole.tree;332for (constpathof ["0.1", "0.0"]) tree2=removeMember(tree2, path).tree;333assert.deepEqual(tree2, Stack(), "the root may be emptied");334assert.deepEqual(removeMember(Stack(a), "0.0").chosen, ["0"]);335assert.throws(() =>removeMember(tree, "0"), "the root is not a member");336assert.throws(() =>removeMember(tree, "0.5"));337});338339test("grouping wraps one member, a run, or every member, in place", () => {340consttree=Stack(a, Switcher(b, c), d);341constsingle=wrapMembers(tree, ["0.0"]);342assert.deepEqual(single.tree, Stack(Stack(a), Switcher(b, c), d));343assert.deepEqual(single.chosen, ["0.0"]);344345construn=wrapMembers(tree, ["0.2", "0.1"]);346assert.deepEqual(run.tree, Stack(a, Stack(Switcher(b, c), d)));347assert.deepEqual(run.chosen, ["0.1"]);348assert.equal(349at(run.tree, "0.1.0"),350at(tree, "0.1"),351"members are not copied",352 );353354constall=wrapMembers(tree, ["0.1.0", "0.1.1"]);355assert.deepEqual(all.tree, Stack(a, Switcher(Stack(b, c)), d));356assert.equal(357at(all.tree, "0.1").kind,358"Switcher",359"the parent's arrangement stays",360 );361362assert.throws(363 () =>wrapMembers(tree, ["0"]),364"the root has no group to join",365 );366assert.throws(() =>wrapMembers(tree, ["0.0", "0.2"]), "not neighbors");367assert.throws(() =>wrapMembers(tree, []));368});369370test("ungrouping returns members to the parent; an empty group simply goes", () => {371consttree=Stack(a, Switcher(b, c), Shelf(), d);372constreleased=releaseGroup(tree, "0.1");373assert.deepEqual(released.tree, Stack(a, b, c, Shelf(), d));374assert.deepEqual(released.chosen, ["0.1", "0.2"]);375constempty=releaseGroup(tree, "0.2");376assert.deepEqual(empty.tree, Stack(a, Switcher(b, c), d));377assert.deepEqual(empty.chosen, ["0"]);378assert.throws(() =>releaseGroup(tree, "0"));379assert.throws(() =>releaseGroup(tree, "0.0"), "content has no members");380});381382test("each edit is one step for Undo, which also restores the selection", () => {383letcopy=startWorkingCopy(Stack(a, b));384assert.equal(undoEdit(copy), undefined);385copy= { ...copy, chosen: chooseMember(copy.model, copy.chosen, "0.1") };386constremoved=removeMember(copy.model, "0.1");387copy=commitEdit(copy, removed.tree, removed.chosen);388constwrapped=wrapMembers(copy.model, ["0.0"]);389copy=commitEdit(copy, wrapped.tree, wrapped.chosen);390assert.deepEqual(copy.model, Stack(Stack(a)));391assert.equal(copy.undo.length, 2);392393copy=undoEdit(copy)!;394assert.deepEqual(copy.model, Stack(a));395assert.deepEqual(copy.chosen, ["0.0"]);396copy=undoEdit(copy)!;397assert.deepEqual(copy.model, Stack(a, b), "the removed member is back");398assert.deepEqual(copy.chosen, ["0.1"], "and selected, as it was");399assert.equal(undoEdit(copy), undefined);400401// Replacing the whole composition is an edit like any other.402constmine=commitEdit(copy, Stack(text("mine")), []);403constreplaced=commitEdit(mine, example("investigation"), []);404assert.deepEqual(undoEdit(replaced)!.model, Stack(text("mine")));405406letlong=startWorkingCopy(Stack());407for (leti=0; i<=workingCopyLimits.history; i++)408long=commitEdit(long, Stack(text(`${i}`)), []);409assert.equal(long.undo.length, workingCopyLimits.history);410assert.deepEqual(411long.undo[0]!.model,412Stack(text("0")),413"the oldest is dropped",414 );415});416417test("one rewording, however many keystrokes, is one step for Undo", () => {418conststart:WorkingCopy= {419...startWorkingCopy(Stack(heading("Title"), a)),420chosen: ["0.0"],421 };422constedit=beginTextEdit(start, "0.0");423letcopy=start;424for (consttypedof ["T", "Th", "The", "The title"]) {425copy=typeText(copy, edit, typed);426assert.deepEqual(at(copy.model, "0.0"), heading(typed), "shown as typed");427assert.equal(copy.undo.length, 0, "history waits");428 }429copy=finishTextEdit(copy, edit);430assert.equal(copy.undo.length, 1);431constundone=undoEdit(copy)!;432assert.deepEqual(undone.model, start.model);433assert.deepEqual(undone.chosen, ["0.0"]);434435// Typing back to the original wording leaves nothing to undo.436letsame=typeText(start, edit, "Titles");437same=finishTextEdit(typeText(same, edit, "Title"), edit);438assert.equal(same.undo.length, 0);439assert.equal(finishTextEdit(start, edit), start);440441// Escape: the text from before the edit, and earlier history untouched.442constearlier=commitEdit(start, start.model, ["0.0"]);443constduring=typeText(earlier, beginTextEdit(earlier, "0.0"), "Abandoned");444constcancelled=cancelTextEdit(during, beginTextEdit(earlier, "0.0"));445assert.equal(cancelled.model, earlier.model);446assert.deepEqual(cancelled.chosen, ["0.0"]);447assert.equal(cancelled.undo, earlier.undo);448assert.throws(() =>beginTextEdit(start, "0"), "a group has no text");449});450451test("every state an author reaches can be saved and reopened", () => {452letcopy=startWorkingCopy(restoreWorkingTree(example("investigation"))!);453conststep= (454chosen:readonlystring[],455edit: (tree:Composition) => {456tree:Composition;457chosen:readonlystring[];458 },459 ) => {460copy= { ...copy, chosen };461constedited=edit(copy.model);462copy=commitEdit(copy, edited.tree, edited.chosen);463assert.deepEqual(464restoreWorkingCopy(stored(copy)),465copy,466printed(copy.model),467 );468 };469step(["0.1", "0.2"], (tree) =>wrapMembers(tree, ["0.1", "0.2"]));470step(["0.1"], (tree) =>addText(tree, editsFor(tree, ["0.1"]).inside!));471for (leti=0; i<3; i++)472step(["0.1.0"], (tree) =>removeMember(tree, "0.1.0"));473assert.deepEqual(at(copy.model, "0.1"), Stack(), "emptied, and still there");474step(["0.1"], (tree) =>wrapMembers(tree, ["0.1"]));475step(["0.1.0"], (tree) =>addText(tree, editsFor(tree, ["0.1.0"]).inside!));476for (constpathof ["0.4", "0.3", "0.2", "0.1", "0.0"])477step([path], (tree) =>removeMember(tree, path));478assert.deepEqual(copy.model, Stack());479assert.equal(copy.undo.length, 12);480});481482test("the declaration names every group, including one with no members", () => {483assert.equal(printed(Stack()), "Stack()");484assert.equal(485printed(Stack(Switcher(), Shelf(text("one")))),486'Stack(\n Switcher(),\n Shelf(Text("one"))\n)',487 );488constnames=declaration(Stack(Switcher(), a)).flatMap((line) =>489line.tokens.filter((token) =>token.kind).map((token) =>token.path),490 );491assert.deepEqual(names, ["0", "0.0", "0.1"], "each has a name to select");492});