@dou-ui/gantt 0.0.0-stage → 0.1.0-alpha.0

package/dist/core/transaction.js

@@ -0,0 +1,371 @@
+import { MINUTES_PER_DAY, parseTime } from "./time.js";
+import { writeSpan } from "./model.js";
+import { buildTree } from "./tree.js";
+import { isOrderKey, orderBetween, orderKeys } from "./order.js";
+// src/core/transaction.ts
+/** An empty document, the chart's `v-model` when none is bound. */
+var emptyDocument = () => ({
+	version: 1,
+	tasks: [],
+	links: []
+});
+function patched(item, patch) {
+	const next = { ...item };
+	for (const key of Object.keys(patch)) {
+		const value = patch[key];
+		if (value === void 0) delete next[key];
+		else next[key] = value;
+	}
+	return next;
+}
+/** The values `patch` would replace, so applying them restores `item`. */
+function previous(item, patch) {
+	const old = {};
+	for (const key of Object.keys(patch)) old[key] = item[key];
+	return old;
+}
+/** A time as minutes; a date-only end counts its whole day. */
+function minutesOf(time, end) {
+	if (typeof time === "number") return time;
+	const parsed = parseTime(time);
+	if (!parsed) throw new RangeError(`[@dou-ui/gantt] can't read the time "${time}"`);
+	return parsed.at + (end && parsed.dateOnly ? MINUTES_PER_DAY : 0);
+}
+var clampIndex = (index, length) => index == null ? length : Math.max(0, Math.min(length, index));
+/**
+* A batch of changes. Steps apply as they are added, so later calls see
+* earlier ones; `doc` is the result.
+*/
+var GanttTransaction = class {
+	before;
+	steps = [];
+	/** The steps that undo this transaction, in the order to apply them. */
+	inverse = [];
+	meta = {};
+	tasks;
+	links;
+	copied = {
+		tasks: false,
+		links: false
+	};
+	/** Where each task and link is in its list; built on first use, dropped when a list changes length. */
+	at = {
+		tasks: null,
+		links: null
+	};
+	constructor(before) {
+		this.before = before;
+		this.tasks = before.tasks;
+		this.links = before.links;
+	}
+	get doc() {
+		if (!this.steps.length) return this.before;
+		return {
+			...this.before,
+			tasks: this.tasks,
+			links: this.links
+		};
+	}
+	/** Whether the change makes any change: it has steps and wasn't cancelled. */
+	get changed() {
+		return this.steps.length > 0 && !this.stopped;
+	}
+	stopped = null;
+	/**
+	* Stops the change: none of it is applied or kept for undo, and the
+	* editor fires `transactionCancel` and says why. For an extension's `transaction`
+	* hook, e.g. to keep people from changing what they may not; hooks after
+	* it don't run. A change kept out of the history (`meta.history: false`),
+	* such as undo, redo or another person's, can't be cancelled and goes ahead.
+	*/
+	cancel(reason) {
+		if (this.meta.history !== false) this.stopped = { reason };
+		else warnUncancellable();
+		return this;
+	}
+	/** Whether `cancel` stopped it. */
+	get cancelled() {
+		return this.stopped !== null;
+	}
+	/** What `cancel` was given, to tell people why. */
+	get cancelReason() {
+		return this.stopped?.reason;
+	}
+	/** Whether the tasks, or the links, changed. */
+	touches(kind) {
+		return this.copied[kind];
+	}
+	getTask(id) {
+		return this.tasks[this.indexOf("tasks", id)];
+	}
+	getLink(id) {
+		return this.links[this.indexOf("links", id)];
+	}
+	/**
+	* A task's or link's position in its list, `-1` when there is none. The
+	* positions are kept as tasks and links come and go, and checked when
+	* read: one that moved since is found again with the rest.
+	*/
+	indexOf(kind, id) {
+		const list = kind === "tasks" ? this.tasks : this.links;
+		let at = this.at[kind];
+		const known = at?.get(id);
+		if (at && (known === void 0 || list[known]?.id === id)) return known ?? -1;
+		at = /* @__PURE__ */ new Map();
+		for (let i = list.length - 1; i >= 0; i--) at.set(list[i].id, i);
+		this.at[kind] = at;
+		return at.get(id) ?? -1;
+	}
+	/** Links into or out of a task. */
+	linksOf(id) {
+		return this.links.filter((link) => link.from === id || link.to === id);
+	}
+	setMeta(meta) {
+		Object.assign(this.meta, meta);
+		return this;
+	}
+	step(step) {
+		const inverse = this.apply(step);
+		if (inverse) {
+			this.steps.push(step);
+			this.inverse.unshift(inverse);
+		}
+		return this;
+	}
+	addTask(task, index) {
+		return this.step({
+			type: "addTask",
+			task,
+			index
+		});
+	}
+	/** Removes a task with its subtasks and every link attached to them. */
+	removeTask(id) {
+		for (const child of this.tasks.filter((task) => task.parent === id)) this.removeTask(child.id);
+		for (const link of this.linksOf(id)) this.removeLink(link.id);
+		return this.step({
+			type: "removeTask",
+			id
+		});
+	}
+	updateTask(id, patch) {
+		return this.step({
+			type: "updateTask",
+			id,
+			patch
+		});
+	}
+	/**
+	* Sets a task's dates, written back in the task's own style. Takes
+	* minutes, or strings read like the task's own: a date-only `end` is the
+	* last day of the task.
+	*/
+	setSpan(id, start, end) {
+		const task = this.getTask(id);
+		if (!task) return this;
+		return this.updateTask(id, writeSpan(task, minutesOf(start, false), minutesOf(end, true)));
+	}
+	/**
+	* Moves a task, with its subtasks, under `parent` (or to the top level)
+	* at `index` among its new siblings, the end by default. Only the task's
+	* `parent` and `order` change, unless its new siblings have no room
+	* between them: then they all get new `order` keys. Links between the
+	* task's subtasks and its new parents go, since a task can't depend on
+	* its own parent. A move into the task itself is ignored.
+	*/
+	moveTask(id, parent, index) {
+		if (!this.getTask(id)) return this;
+		if (parent != null && !this.getTask(parent)) return this;
+		const ancestors = /* @__PURE__ */ new Set();
+		for (let up = parent; up != null && !ancestors.has(up); up = this.getTask(up)?.parent) {
+			if (up === id) return this;
+			ancestors.add(up);
+		}
+		const tree = buildTree(this.tasks);
+		const siblings = (tree.childrenOf.get(parent) ?? []).filter((task) => task.id !== id);
+		const at = clampIndex(index, siblings.length);
+		const keys = siblings.map((task) => task.order);
+		const ordered = keys.every((key, i) => key != null && isOrderKey(key) && (i === 0 || keys[i - 1] < key));
+		let order;
+		if (ordered) order = orderBetween(keys[at - 1], keys[at]);
+		else {
+			const fresh = orderKeys(siblings.length + 1);
+			order = fresh[at];
+			siblings.forEach((task, i) => this.updateTask(task.id, { order: fresh[i < at ? i : i + 1] }));
+		}
+		this.updateTask(id, {
+			parent,
+			order
+		});
+		const moved = /* @__PURE__ */ new Set([id]);
+		const stack = [id];
+		while (stack.length) for (const child of tree.childrenOf.get(stack.pop()) ?? []) {
+			moved.add(child.id);
+			stack.push(child.id);
+		}
+		for (const link of this.links.slice()) if (moved.has(link.from) && ancestors.has(link.to) || moved.has(link.to) && ancestors.has(link.from)) this.removeLink(link.id);
+		return this;
+	}
+	/** Merges `patch` into the task's `data`. */
+	updateData(id, patch) {
+		const task = this.getTask(id);
+		if (!task) return this;
+		return this.updateTask(id, { data: {
+			...task.data,
+			...patch
+		} });
+	}
+	addLink(link, index) {
+		return this.step({
+			type: "addLink",
+			link,
+			index
+		});
+	}
+	removeLink(id) {
+		return this.step({
+			type: "removeLink",
+			id
+		});
+	}
+	updateLink(id, patch) {
+		return this.step({
+			type: "updateLink",
+			id,
+			patch
+		});
+	}
+	writable(kind) {
+		if (!this.copied[kind]) {
+			this.copied[kind] = true;
+			if (kind === "tasks") this.tasks = this.tasks.slice();
+			else this.links = this.links.slice();
+		}
+		return kind === "tasks" ? this.tasks : this.links;
+	}
+	/** Applies a step and returns its inverse, or `null` when it changes nothing. */
+	apply(step) {
+		switch (step.type) {
+			case "addTask": {
+				if (this.getTask(step.task.id)) return null;
+				const list = this.writable("tasks");
+				const at = clampIndex(step.index, list.length);
+				list.splice(at, 0, step.task);
+				this.at.tasks?.set(step.task.id, at);
+				return {
+					type: "removeTask",
+					id: step.task.id
+				};
+			}
+			case "removeTask": {
+				const index = this.indexOf("tasks", step.id);
+				if (index < 0) return null;
+				const [task] = this.writable("tasks").splice(index, 1);
+				return {
+					type: "addTask",
+					task,
+					index
+				};
+			}
+			case "updateTask": {
+				const index = this.indexOf("tasks", step.id);
+				if (index < 0) return null;
+				const task = this.tasks[index];
+				if (Object.keys(step.patch).every((key) => task[key] === step.patch[key])) return null;
+				this.writable("tasks")[index] = patched(task, step.patch);
+				return {
+					type: "updateTask",
+					id: step.id,
+					patch: previous(task, step.patch)
+				};
+			}
+			case "addLink": {
+				if (this.getLink(step.link.id)) return null;
+				const list = this.writable("links");
+				const at = clampIndex(step.index, list.length);
+				list.splice(at, 0, step.link);
+				this.at.links?.set(step.link.id, at);
+				return {
+					type: "removeLink",
+					id: step.link.id
+				};
+			}
+			case "removeLink": {
+				const index = this.indexOf("links", step.id);
+				if (index < 0) return null;
+				const [link] = this.writable("links").splice(index, 1);
+				return {
+					type: "addLink",
+					link,
+					index
+				};
+			}
+			case "updateLink": {
+				const index = this.indexOf("links", step.id);
+				if (index < 0) return null;
+				const link = this.links[index];
+				if (Object.keys(step.patch).every((key) => link[key] === step.patch[key])) return null;
+				this.writable("links")[index] = patched(link, step.patch);
+				return {
+					type: "updateLink",
+					id: step.id,
+					patch: previous(link, step.patch)
+				};
+			}
+		}
+	}
+};
+/** Applies steps to a document; steps that no longer apply are skipped. */
+function applyGanttSteps(doc, steps) {
+	const tr = new GanttTransaction(doc);
+	for (const step of steps) tr.step(step);
+	return tr;
+}
+var targetOf = (step) => {
+	switch (step.type) {
+		case "addTask": return `t:${step.task.id}`;
+		case "addLink": return `l:${step.link.id}`;
+		case "removeTask":
+		case "updateTask": return `t:${step.id}`;
+		case "removeLink":
+		case "updateLink": return `l:${step.id}`;
+	}
+};
+/**
+* Folds updates of the same task or link into one, as long as nothing
+* adds or removes it in between.
+*/
+function compactSteps(steps) {
+	const out = [];
+	const lastUpdate = /* @__PURE__ */ new Map();
+	for (const step of steps) {
+		const target = targetOf(step);
+		if (step.type === "updateTask" || step.type === "updateLink") {
+			const at = lastUpdate.get(target);
+			if (at != null) {
+				const prev = out[at];
+				out[at] = {
+					...prev,
+					patch: {
+						...prev.patch,
+						...step.patch
+					}
+				};
+				continue;
+			}
+			lastUpdate.set(target, out.length);
+		} else lastUpdate.delete(target);
+		out.push(step);
+	}
+	return out;
+}
+var warnedUncancellable = false;
+/** Says once that cancelling a change kept out of the history does nothing. */
+function warnUncancellable() {
+	if (process.env.NODE_ENV === "production" || warnedUncancellable) return;
+	warnedUncancellable = true;
+	console.warn("[@dou-ui/gantt] a change kept out of the history (undo, redo or another person's) can't be cancelled; it goes ahead");
+}
+export { GanttTransaction, applyGanttSteps, compactSteps, emptyDocument };
+
+//# sourceMappingURL=transaction.js.map

package/dist/core/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","names":[],"sources":["../../src/core/transaction.ts"],"sourcesContent":["import { writeSpan, type GanttLink, type GanttTask } from './model'\nimport { isOrderKey, orderBetween, orderKeys } from './order'\nimport { MINUTES_PER_DAY, parseTime } from './time'\nimport { buildTree } from './tree'\n\n/*\n * Every change to the tasks and links is a list of steps. Applying a step\n * also gives the step that undoes it, so history, collaboration and the\n * `transaction` event all work on the same small vocabulary.\n */\n\n/** An empty document, the chart's `v-model` when none is bound. */\nexport const emptyDocument = (): GanttDocument => ({ version: 1, tasks: [], links: [] })\n\ntype Patch<T> = { [K in keyof T]?: T[K] | undefined }\n\n/** The tasks and links together, as a transaction sees them. */\nexport interface GanttDocument {\n  /** The version of the format; see `migrateDocument`. */\n  version: 1\n  tasks: GanttTask[]\n  links: GanttLink[]\n}\n\nexport type GanttStep =\n  | { type: 'addTask'; task: GanttTask; index?: number }\n  | { type: 'removeTask'; id: string }\n  | { type: 'updateTask'; id: string; patch: Patch<GanttTask> }\n  | { type: 'addLink'; link: GanttLink; index?: number }\n  | { type: 'removeLink'; id: string }\n  | { type: 'updateLink'; id: string; patch: Patch<GanttLink> }\n\nexport interface GanttTransactionMeta {\n  /** Keep out of the undo history, e.g. folding a summary or a change from another client. */\n  history?: boolean\n  /**\n   * Consecutive transactions in the same group within a second undo as\n   * one, e.g. repeated arrow key nudges.\n   */\n  group?: string\n  /**\n   * With `scheduling=\"auto\"`, set to `false` to leave the waiting tasks\n   * where they are, e.g. for a change from another client.\n   */\n  schedule?: boolean\n  /** Who made the change, passed on to the `transaction` event. */\n  origin?: string\n}\n\nfunction patched<T extends object>(item: T, patch: Patch<T>): T {\n  const next = { ...item } as Record<string, unknown>\n  for (const key of Object.keys(patch)) {\n    const value = (patch as Record<string, unknown>)[key]\n    if (value === undefined) delete next[key]\n    else next[key] = value\n  }\n  return next as T\n}\n\n/** The values `patch` would replace, so applying them restores `item`. */\nfunction previous<T extends object>(item: T, patch: Patch<T>): Patch<T> {\n  const old: Record<string, unknown> = {}\n  for (const key of Object.keys(patch)) old[key] = (item as Record<string, unknown>)[key]\n  return old as Patch<T>\n}\n\n/** A time as minutes; a date-only end counts its whole day. */\nfunction minutesOf(time: number | string, end: boolean) {\n  if (typeof time === 'number') return time\n  const parsed = parseTime(time)\n  if (!parsed) throw new RangeError(`[@dou-ui/gantt] can't read the time \"${time}\"`)\n  return parsed.at + (end && parsed.dateOnly ? MINUTES_PER_DAY : 0)\n}\n\nconst clampIndex = (index: number | undefined, length: number) =>\n  index == null ? length : Math.max(0, Math.min(length, index))\n\n/**\n * A batch of changes. Steps apply as they are added, so later calls see\n * earlier ones; `doc` is the result.\n */\nexport class GanttTransaction {\n  readonly steps: GanttStep[] = []\n  /** The steps that undo this transaction, in the order to apply them. */\n  readonly inverse: GanttStep[] = []\n  meta: GanttTransactionMeta = {}\n  private tasks: GanttTask[]\n  private links: GanttLink[]\n  private copied = { tasks: false, links: false }\n  /** Where each task and link is in its list; built on first use, dropped when a list changes length. */\n  private at: { tasks: Map<string, number> | null; links: Map<string, number> | null } = {\n    tasks: null,\n    links: null,\n  }\n\n  constructor(readonly before: GanttDocument) {\n    this.tasks = before.tasks\n    this.links = before.links\n  }\n\n  get doc(): GanttDocument {\n    if (!this.steps.length) return this.before\n    return { ...this.before, tasks: this.tasks, links: this.links }\n  }\n\n  /** Whether the change makes any change: it has steps and wasn't cancelled. */\n  get changed() {\n    return this.steps.length > 0 && !this.stopped\n  }\n\n  private stopped: { reason?: string } | null = null\n\n  /**\n   * Stops the change: none of it is applied or kept for undo, and the\n   * editor fires `transactionCancel` and says why. For an extension's `transaction`\n   * hook, e.g. to keep people from changing what they may not; hooks after\n   * it don't run. A change kept out of the history (`meta.history: false`),\n   * such as undo, redo or another person's, can't be cancelled and goes ahead.\n   */\n  cancel(reason?: string) {\n    if (this.meta.history !== false) this.stopped = { reason }\n    else warnUncancellable()\n    return this\n  }\n\n  /** Whether `cancel` stopped it. */\n  get cancelled() {\n    return this.stopped !== null\n  }\n\n  /** What `cancel` was given, to tell people why. */\n  get cancelReason() {\n    return this.stopped?.reason\n  }\n\n  /** Whether the tasks, or the links, changed. */\n  touches(kind: 'tasks' | 'links') {\n    return this.copied[kind]\n  }\n\n  getTask(id: string) {\n    return this.tasks[this.indexOf('tasks', id)]\n  }\n\n  getLink(id: string) {\n    return this.links[this.indexOf('links', id)]\n  }\n\n  /**\n   * A task's or link's position in its list, `-1` when there is none. The\n   * positions are kept as tasks and links come and go, and checked when\n   * read: one that moved since is found again with the rest.\n   */\n  private indexOf(kind: 'tasks' | 'links', id: string) {\n    const list: readonly { id: string }[] = kind === 'tasks' ? this.tasks : this.links\n    let at = this.at[kind]\n    const known = at?.get(id)\n    if (at && (known === undefined || list[known]?.id === id)) return known ?? -1\n    at = new Map()\n    // the first one wins, as with `find`\n    for (let i = list.length - 1; i >= 0; i--) at.set(list[i]!.id, i)\n    this.at[kind] = at\n    return at.get(id) ?? -1\n  }\n\n  /** Links into or out of a task. */\n  linksOf(id: string) {\n    return this.links.filter((link) => link.from === id || link.to === id)\n  }\n\n  setMeta(meta: GanttTransactionMeta) {\n    Object.assign(this.meta, meta)\n    return this\n  }\n\n  step(step: GanttStep) {\n    const inverse = this.apply(step)\n    if (inverse) {\n      this.steps.push(step)\n      this.inverse.unshift(inverse)\n    }\n    return this\n  }\n\n  addTask(task: GanttTask, index?: number) {\n    return this.step({ type: 'addTask', task, index })\n  }\n\n  /** Removes a task with its subtasks and every link attached to them. */\n  removeTask(id: string) {\n    for (const child of this.tasks.filter((task) => task.parent === id)) this.removeTask(child.id)\n    for (const link of this.linksOf(id)) this.removeLink(link.id)\n    return this.step({ type: 'removeTask', id })\n  }\n\n  updateTask(id: string, patch: Patch<GanttTask>) {\n    return this.step({ type: 'updateTask', id, patch })\n  }\n\n  /**\n   * Sets a task's dates, written back in the task's own style. Takes\n   * minutes, or strings read like the task's own: a date-only `end` is the\n   * last day of the task.\n   */\n  setSpan(id: string, start: number | string, end: number | string) {\n    const task = this.getTask(id)\n    if (!task) return this\n    return this.updateTask(id, writeSpan(task, minutesOf(start, false), minutesOf(end, true)))\n  }\n\n  /**\n   * Moves a task, with its subtasks, under `parent` (or to the top level)\n   * at `index` among its new siblings, the end by default. Only the task's\n   * `parent` and `order` change, unless its new siblings have no room\n   * between them: then they all get new `order` keys. Links between the\n   * task's subtasks and its new parents go, since a task can't depend on\n   * its own parent. A move into the task itself is ignored.\n   */\n  moveTask(id: string, parent: string | undefined, index?: number) {\n    if (!this.getTask(id)) return this\n    if (parent != null && !this.getTask(parent)) return this\n    const ancestors = new Set<string>()\n    for (let up = parent; up != null && !ancestors.has(up); up = this.getTask(up)?.parent) {\n      if (up === id) return this\n      ancestors.add(up)\n    }\n    const tree = buildTree(this.tasks)\n    const siblings = (tree.childrenOf.get(parent) ?? []).filter((task) => task.id !== id)\n    const at = clampIndex(index, siblings.length)\n    const keys = siblings.map((task) => task.order)\n    const ordered = keys.every(\n      (key, i) => key != null && isOrderKey(key) && (i === 0 || keys[i - 1]! < key),\n    )\n    let order: string\n    if (ordered) order = orderBetween(keys[at - 1], keys[at])\n    else {\n      const fresh = orderKeys(siblings.length + 1)\n      order = fresh[at]!\n      siblings.forEach((task, i) => this.updateTask(task.id, { order: fresh[i < at ? i : i + 1] }))\n    }\n    this.updateTask(id, { parent, order })\n\n    // the task and everything under it\n    const moved = new Set([id])\n    const stack = [id]\n    while (stack.length) {\n      for (const child of tree.childrenOf.get(stack.pop()) ?? []) {\n        moved.add(child.id)\n        stack.push(child.id)\n      }\n    }\n    for (const link of this.links.slice()) {\n      if (\n        (moved.has(link.from) && ancestors.has(link.to)) ||\n        (moved.has(link.to) && ancestors.has(link.from))\n      )\n        this.removeLink(link.id)\n    }\n    return this\n  }\n\n  /** Merges `patch` into the task's `data`. */\n  updateData(id: string, patch: Record<string, unknown>) {\n    const task = this.getTask(id)\n    if (!task) return this\n    return this.updateTask(id, { data: { ...task.data, ...patch } })\n  }\n\n  addLink(link: GanttLink, index?: number) {\n    return this.step({ type: 'addLink', link, index })\n  }\n\n  removeLink(id: string) {\n    return this.step({ type: 'removeLink', id })\n  }\n\n  updateLink(id: string, patch: Patch<GanttLink>) {\n    return this.step({ type: 'updateLink', id, patch })\n  }\n\n  private writable<K extends 'tasks' | 'links'>(kind: K): GanttDocument[K] {\n    if (!this.copied[kind]) {\n      this.copied[kind] = true\n      if (kind === 'tasks') this.tasks = this.tasks.slice()\n      else this.links = this.links.slice()\n    }\n    return (kind === 'tasks' ? this.tasks : this.links) as GanttDocument[K]\n  }\n\n  /** Applies a step and returns its inverse, or `null` when it changes nothing. */\n  private apply(step: GanttStep): GanttStep | null {\n    switch (step.type) {\n      case 'addTask': {\n        if (this.getTask(step.task.id)) return null\n        const list = this.writable('tasks')\n        const at = clampIndex(step.index, list.length)\n        list.splice(at, 0, step.task)\n        // the rest may have moved by one: `indexOf` checks the positions it reads\n        this.at.tasks?.set(step.task.id, at)\n        return { type: 'removeTask', id: step.task.id }\n      }\n      case 'removeTask': {\n        const index = this.indexOf('tasks', step.id)\n        if (index < 0) return null\n        const [task] = this.writable('tasks').splice(index, 1)\n        return { type: 'addTask', task: task!, index }\n      }\n      case 'updateTask': {\n        const index = this.indexOf('tasks', step.id)\n        if (index < 0) return null\n        const task = this.tasks[index]!\n        const keys = Object.keys(step.patch) as (keyof GanttTask)[]\n        if (keys.every((key) => task[key] === step.patch[key])) return null\n        this.writable('tasks')[index] = patched(task, step.patch)\n        return { type: 'updateTask', id: step.id, patch: previous(task, step.patch) }\n      }\n      case 'addLink': {\n        if (this.getLink(step.link.id)) return null\n        const list = this.writable('links')\n        const at = clampIndex(step.index, list.length)\n        list.splice(at, 0, step.link)\n        // the rest may have moved by one: `indexOf` checks the positions it reads\n        this.at.links?.set(step.link.id, at)\n        return { type: 'removeLink', id: step.link.id }\n      }\n      case 'removeLink': {\n        const index = this.indexOf('links', step.id)\n        if (index < 0) return null\n        const [link] = this.writable('links').splice(index, 1)\n        return { type: 'addLink', link: link!, index }\n      }\n      case 'updateLink': {\n        const index = this.indexOf('links', step.id)\n        if (index < 0) return null\n        const link = this.links[index]!\n        const keys = Object.keys(step.patch) as (keyof GanttLink)[]\n        if (keys.every((key) => link[key] === step.patch[key])) return null\n        this.writable('links')[index] = patched(link, step.patch)\n        return { type: 'updateLink', id: step.id, patch: previous(link, step.patch) }\n      }\n    }\n  }\n}\n\n/** Applies steps to a document; steps that no longer apply are skipped. */\nexport function applyGanttSteps(doc: GanttDocument, steps: readonly GanttStep[]) {\n  const tr = new GanttTransaction(doc)\n  for (const step of steps) tr.step(step)\n  return tr\n}\n\nconst targetOf = (step: GanttStep) => {\n  switch (step.type) {\n    case 'addTask':\n      return `t:${step.task.id}`\n    case 'addLink':\n      return `l:${step.link.id}`\n    case 'removeTask':\n    case 'updateTask':\n      return `t:${step.id}`\n    case 'removeLink':\n    case 'updateLink':\n      return `l:${step.id}`\n  }\n}\n\n/**\n * Folds updates of the same task or link into one, as long as nothing\n * adds or removes it in between.\n */\nexport function compactSteps(steps: readonly GanttStep[]): GanttStep[] {\n  const out: GanttStep[] = []\n  const lastUpdate = new Map<string, number>()\n  for (const step of steps) {\n    const target = targetOf(step)\n    if (step.type === 'updateTask' || step.type === 'updateLink') {\n      const at = lastUpdate.get(target)\n      if (at != null) {\n        const prev = out[at] as typeof step\n        out[at] = { ...prev, patch: { ...prev.patch, ...step.patch } } as GanttStep\n        continue\n      }\n      lastUpdate.set(target, out.length)\n    } else {\n      lastUpdate.delete(target)\n    }\n    out.push(step)\n  }\n  return out\n}\n\nlet warnedUncancellable = false\n/** Says once that cancelling a change kept out of the history does nothing. */\nfunction warnUncancellable() {\n  // the app's bundler replaces this, as for Vue's own warnings\n  if (process.env.NODE_ENV === 'production' || warnedUncancellable) return\n  warnedUncancellable = true\n  console.warn(\n    \"[@dou-ui/gantt] a change kept out of the history (undo, redo or another person's) can't be cancelled; it goes ahead\",\n  )\n}\n"],"mappings":"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"}

package/dist/core/tree.js

@@ -0,0 +1,114 @@
+import { clampProgress, spanOf } from "./model.js";
+// src/core/tree.ts
+/** Between two siblings given the same `order`: by id. */
+var sameOrder = (a, b) => a.order == null || b.order == null || a.id === b.id ? 0 : a.id < b.id ? -1 : 1;
+/**
+* Orders siblings: by `order` where given, otherwise as in the array. A
+* sibling without `order` sorts right after the one before it in the array.
+* Two siblings given the same `order` (two people inserting at the same
+* place) sort by id, so every client shows them alike.
+*/
+function sortSiblings(list) {
+	let key = "";
+	const keyed = list.map((item) => {
+		if (item.task.order != null) key = item.task.order;
+		return {
+			...item,
+			key
+		};
+	});
+	keyed.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : sameOrder(a.task, b.task) || a.index - b.index);
+	return keyed.map((item) => item.task);
+}
+/**
+* Lays the flat task list out as a tree: rows in display order, summaries
+* worked out from their children. A `parent` that doesn't exist, or that
+* would make a loop, is ignored and the task becomes a root.
+*/
+function buildTree(tasks) {
+	const ids = new Map(tasks.map((task) => [task.id, task]));
+	const parentOf = /* @__PURE__ */ new Map();
+	for (const task of tasks) {
+		let parent = task.parent != null && ids.has(task.parent) ? task.parent : void 0;
+		const seen = /* @__PURE__ */ new Set([task.id]);
+		for (let up = parent; up != null;) {
+			if (seen.has(up)) {
+				parent = void 0;
+				break;
+			}
+			seen.add(up);
+			const next = ids.get(up).parent;
+			up = next != null && ids.has(next) ? next : void 0;
+		}
+		parentOf.set(task.id, parent);
+	}
+	const groups = /* @__PURE__ */ new Map();
+	tasks.forEach((task, index) => {
+		const parent = parentOf.get(task.id);
+		const list = groups.get(parent);
+		if (list) list.push({
+			task,
+			index
+		});
+		else groups.set(parent, [{
+			task,
+			index
+		}]);
+	});
+	const childrenOf = /* @__PURE__ */ new Map();
+	for (const [parent, list] of groups) childrenOf.set(parent, sortSiblings(list));
+	const byId = /* @__PURE__ */ new Map();
+	const rows = [];
+	const visit = (task, depth, shown) => {
+		const kids = childrenOf.get(task.id) ?? [];
+		const row = {
+			task,
+			depth,
+			index: shown ? rows.length : -1,
+			children: kids.length,
+			summary: kids.length > 0,
+			milestone: kids.length === 0 && task.type === "milestone",
+			span: null,
+			progress: 0
+		};
+		byId.set(task.id, row);
+		if (shown) rows.push(row);
+		if (!kids.length) {
+			row.span = spanOf(task);
+			row.progress = clampProgress(task.progress);
+			return row;
+		}
+		let start = Infinity;
+		let end = -Infinity;
+		let dateOnly = true;
+		let weighted = 0;
+		let weight = 0;
+		for (const child of kids) {
+			const sub = visit(child, depth + 1, shown && !task.collapsed);
+			if (!sub.span) continue;
+			start = Math.min(start, sub.span.start);
+			end = Math.max(end, sub.span.end);
+			dateOnly &&= sub.span.dateOnly;
+			if (sub.milestone) continue;
+			const length = sub.span.end - sub.span.start;
+			weighted += sub.progress * length;
+			weight += length;
+		}
+		if (start <= end) row.span = {
+			start,
+			end,
+			dateOnly
+		};
+		row.progress = weight ? weighted / weight : 0;
+		return row;
+	};
+	for (const task of childrenOf.get(void 0) ?? []) visit(task, 0, true);
+	return {
+		rows,
+		byId,
+		childrenOf
+	};
+}
+export { buildTree };
+
+//# sourceMappingURL=tree.js.map

package/dist/core/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","names":[],"sources":["../../src/core/tree.ts"],"sourcesContent":["import { clampProgress, spanOf, type GanttTask, type TaskSpan } from './model'\n\nexport interface GanttRow {\n  task: GanttTask\n  /** Nesting level, from 0. */\n  depth: number\n  /** Position among the shown rows; `-1` when a collapsed parent hides it. */\n  index: number\n  /** Number of direct children. */\n  children: number\n  /** Has children, so its dates and progress come from them. */\n  summary: boolean\n  milestone: boolean\n  /** Its own dates, or for a summary the dates its children cover. */\n  span: TaskSpan | null\n  progress: number\n}\n\nexport interface GanttTree {\n  /** The rows to show, top to bottom. */\n  rows: GanttRow[]\n  /** Every task's row, shown or not. */\n  byId: Map<string, GanttRow>\n  /** Children in display order; roots under `undefined`. */\n  childrenOf: Map<string | undefined, GanttTask[]>\n}\n\n/** Between two siblings given the same `order`: by id. */\nconst sameOrder = (a: GanttTask, b: GanttTask) =>\n  a.order == null || b.order == null || a.id === b.id ? 0 : a.id < b.id ? -1 : 1\n\n/**\n * Orders siblings: by `order` where given, otherwise as in the array. A\n * sibling without `order` sorts right after the one before it in the array.\n * Two siblings given the same `order` (two people inserting at the same\n * place) sort by id, so every client shows them alike.\n */\nfunction sortSiblings(list: { task: GanttTask; index: number }[]) {\n  let key = ''\n  const keyed = list.map((item) => {\n    if (item.task.order != null) key = item.task.order\n    return { ...item, key }\n  })\n  // oxlint-disable-next-line unicorn/no-array-sort -- sorts a fresh array\n  keyed.sort((a, b) =>\n    a.key < b.key ? -1 : a.key > b.key ? 1 : sameOrder(a.task, b.task) || a.index - b.index,\n  )\n  return keyed.map((item) => item.task)\n}\n\n/**\n * Lays the flat task list out as a tree: rows in display order, summaries\n * worked out from their children. A `parent` that doesn't exist, or that\n * would make a loop, is ignored and the task becomes a root.\n */\nexport function buildTree(tasks: readonly GanttTask[]): GanttTree {\n  const ids = new Map(tasks.map((task) => [task.id, task]))\n\n  // follow each parent chain; a chain that comes back to itself is cut\n  const parentOf = new Map<string, string | undefined>()\n  for (const task of tasks) {\n    let parent = task.parent != null && ids.has(task.parent) ? task.parent : undefined\n    const seen = new Set([task.id])\n    for (let up = parent; up != null;) {\n      if (seen.has(up)) {\n        parent = undefined\n        break\n      }\n      seen.add(up)\n      const next = ids.get(up)!.parent\n      up = next != null && ids.has(next) ? next : undefined\n    }\n    parentOf.set(task.id, parent)\n  }\n\n  const groups = new Map<string | undefined, { task: GanttTask; index: number }[]>()\n  tasks.forEach((task, index) => {\n    const parent = parentOf.get(task.id)\n    const list = groups.get(parent)\n    if (list) list.push({ task, index })\n    else groups.set(parent, [{ task, index }])\n  })\n  const childrenOf = new Map<string | undefined, GanttTask[]>()\n  for (const [parent, list] of groups) childrenOf.set(parent, sortSiblings(list))\n\n  const byId = new Map<string, GanttRow>()\n  const rows: GanttRow[] = []\n\n  const visit = (task: GanttTask, depth: number, shown: boolean): GanttRow => {\n    const kids = childrenOf.get(task.id) ?? []\n    const row: GanttRow = {\n      task,\n      depth,\n      index: shown ? rows.length : -1,\n      children: kids.length,\n      summary: kids.length > 0,\n      milestone: kids.length === 0 && task.type === 'milestone',\n      span: null,\n      progress: 0,\n    }\n    byId.set(task.id, row)\n    if (shown) rows.push(row)\n\n    if (!kids.length) {\n      row.span = spanOf(task)\n      row.progress = clampProgress(task.progress)\n      return row\n    }\n    let start = Infinity\n    let end = -Infinity\n    let dateOnly = true\n    let weighted = 0\n    let weight = 0\n    for (const child of kids) {\n      const sub = visit(child, depth + 1, shown && !task.collapsed)\n      if (!sub.span) continue\n      start = Math.min(start, sub.span.start)\n      end = Math.max(end, sub.span.end)\n      dateOnly &&= sub.span.dateOnly\n      if (sub.milestone) continue\n      const length = sub.span.end - sub.span.start\n      weighted += sub.progress * length\n      weight += length\n    }\n    if (start <= end) row.span = { start, end, dateOnly }\n    row.progress = weight ? weighted / weight : 0\n    return row\n  }\n\n  for (const task of childrenOf.get(undefined) ?? []) visit(task, 0, true)\n  return { rows, byId, childrenOf }\n}\n"],"mappings":"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"}