@peter.prib/renderengine 0.2.3 → 0.2.5

package/src/charting/diagramModel/ModelComparison.js

@@ -0,0 +1,100 @@
+import { MergeModelCommand } from './MergeModelCommand.js';
+
+/**
+ * ModelComparison — how one model differs from another, kind by kind (the
+ * model's `comparedKinds()`: views, and a notation's elements and
+ * relationships), matched by id: what only the other has ('added'), what both
+ * have but not alike ('changed', with the fields that differ), and what only
+ * this one has ('removed'). It can merge (`mergeCommand`): bring what only the
+ * other has, and the other's version of what changed, into this model, with
+ * whatever those need that this model lacks.
+ */
+export class ModelComparison {
+    /**
+     * @param {ViewSetModel} mine - The model compared, and merged into
+     * @param {ViewSetModel} theirs - The model it is compared with
+     */
+    constructor(mine, theirs) {
+        this.mine = mine;
+        this.theirs = theirs;
+        /** The kinds compared, in the order things are brought (what is needed first). */
+        this.kinds = mine.comparedKinds();
+        this._differences = null;
+    }
+
+    /**
+     * Every difference: `{key, kind, id, name, change, fields?}`; `change` is
+     * 'added' (only theirs), 'changed' (both; `fields` say which differ) or
+     * 'removed' (only mine). Kind by kind, in each model's order.
+     */
+    differences() {
+        if (this._differences) return this._differences;
+        const out = [];
+        for (const kind of this.kinds) {
+            const mine = new Map(kind.items(this.mine).map(item => [kind.idOf(item), item]));
+            const theirs = new Map(kind.items(this.theirs).map(item => [kind.idOf(item), item]));
+            const entry = (id, item, change, extra = {}) => ({ key: `${kind.key}:${id}`, kind, id, name: kind.nameOf(item), change, ...extra });
+            for (const [id, item] of theirs) {
+                if (!mine.has(id)) { out.push(entry(id, item, 'added')); continue; }
+                const fields = kind.changedFields(mine.get(id), item);
+                if (fields.length) out.push(entry(id, item, 'changed', { fields }));
+            }
+            for (const [id, item] of mine) if (!theirs.has(id)) out.push(entry(id, item, 'removed'));
+        }
+        return (this._differences = out);
+    }
+
+    /** Whether the two models are alike in everything compared. */
+    get same() {
+        return !this.differences().length;
+    }
+
+    /** How many differences of each change there are, kind by kind: [{kind, added, changed, removed}]. */
+    summary() {
+        return this.kinds.map(kind => {
+            const of = this.differences().filter(d => d.kind === kind);
+            const count = (change) => of.filter(d => d.change === change).length;
+            return { kind, added: count('added'), changed: count('changed'), removed: count('removed') };
+        });
+    }
+
+    /** The differences a merge can bring: what only theirs has, and what changed. */
+    mergeable() {
+        return this.differences().filter(d => d.change !== 'removed');
+    }
+
+    /**
+     * Bring some differences (by key; default every mergeable one) into this
+     * model, with what they need that it lacks (a view's elements, a
+     * relationship's ends): a MergeModelCommand, not yet run, or null when
+     * there is nothing to bring.
+     * @param {Iterable<string>} [keys]
+     * @returns {MergeModelCommand|null}
+     */
+    mergeCommand(keys = this.mergeable().map(d => d.key)) {
+        const byKey = new Map(this.mergeable().map(d => [d.key, d]));
+        const kindOf = new Map(this.kinds.map(kind => [kind.key, kind]));
+        const chosen = new Set();
+        const take = (kind, id) => {
+            const key = `${kind.key}:${id}`;
+            if (chosen.has(key)) return;
+            // Something needed is brought when only theirs has it; what both have stays as chosen.
+            if (!byKey.has(key)) return;
+            chosen.add(key);
+            const item = kind.get(this.theirs, id);
+            for (const [needKind, needId] of kind.requires(item, this.theirs)) {
+                const need = kindOf.get(needKind);
+                if (need && !need.get(this.mine, needId)) take(need, needId);
+            }
+        };
+        for (const key of keys) {
+            const d = byKey.get(key);
+            if (d) take(d.kind, d.id);
+        }
+        if (!chosen.size) return null;
+        const steps = this.kinds.flatMap(kind => this.mergeable()
+            .filter(d => d.kind === kind && chosen.has(d.key))
+            .map(d => ({ kind, item: kind.get(this.theirs, d.id) })));
+        return new MergeModelCommand(this.mine, this.theirs, steps);
+    }
+}

package/src/charting/diagramModel/ViewSetModel.js

@@ -1,243 +1,260 @@
-import { ViewSetChecker } from './ViewSetChecker.js';
-import { ModelReport } from './ModelReport.js';
-import { ModelSearch } from './ModelSearch.js';
-import { ModelHistory } from './ModelHistory.js';
-import { AddViewCommand } from './AddViewCommand.js';
-import { RemoveViewCommand } from './RemoveViewCommand.js';
-import { RenameViewCommand } from './RenameViewCommand.js';
-
-/**
- * ViewSetModel — a model edited as several views (diagrams), with one current.
- * Owns what every such model does with its views: create, duplicate, rename,
- * delete, switch, and telling listeners after each change, so a UI only has to
- * re-render on notification. It has one undo history (`history`, a
- * ModelHistory, as Archi has one command stack per model) that every view of
- * it shares: adding, renaming and deleting views are undoable steps on it too.
- *
- * Subclasses make their own kind of view through `_newView(id, title)`; a view
- * has an `id`, a `title`, and `copy(id, title)` for duplication. DiagramModel
- * (the template editor) and ArchimateModel extend it.
- */
-export class ViewSetModel {
-    /**
-     * @param {Object} [options]
-     * @param {string} [options.idPrefix] - Prefix for generated view ids
-     * @param {string} [options.viewNoun] - What a view is called in default titles ('Diagram', 'View')
-     */
-    constructor({ idPrefix = 'view', viewNoun = 'View' } = {}) {
-        if (new.target === ViewSetModel) throw new TypeError('ViewSetModel is abstract — subclass it');
-        /** @type {Map<string, Object>} in tab order */
-        this._views = new Map();
-        this.currentViewId = null;
-        this.idPrefix = idPrefix;
-        this.viewNoun = viewNoun;
-        this._nextId = 1;
-        this._listeners = [];
-        /** Bumped by every change to the set of views (new, duplicated, renamed, deleted). */
-        this._structure = 0;
-        this._saved = null;
-        this._editListeners = [];
-        this._watched = new WeakSet();
-    }
-
-    /** The model's one undo history, which every view of it shares (ModelHistory). */
-    get history() {
-        return (this._history ??= new ModelHistory(this, this.historyOptions ?? {}));
-    }
-
-    /** Make a view one of this model's: its edits go on the model's history. @protected */
-    _adopt(view) {
-        view.history = this.history;
-        return view;
-    }
-
-    // ===== Saved or not =====
-
-    /** Remember this state as the saved one (after opening or saving a file). */
-    markSaved() {
-        this._saved = { structure: this._structure, token: this.history.stateToken };
-        this._emitEdit();
-    }
-
-    /**
-     * Whether anything changed since markSaved: an edit on the model's history
-     * (any view's, or to the views themselves) not undone back again.
-     */
-    isDirty() {
-        const saved = this._saved ?? { structure: 0, token: 0 };
-        return this._structure !== saved.structure || this.history.stateToken !== saved.token;
-    }
-
-    /** Call `fn(model)` after every edit (any view's history, or the set of views). Returns an unsubscribe function. */
-    onEdit(fn) {
-        this._editListeners.push(fn);
-        this._watchHistories();
-        return () => { this._editListeners = this._editListeners.filter(l => l !== fn); };
-    }
-
-    /** Listen to the model's history (and any view's own, for one not adopted). @private */
-    _watchHistories() {
-        for (const history of [this.history, ...this.views().map(v => v.history)]) {
-            if (!history?.onChange || this._watched.has(history)) continue;
-            this._watched.add(history);
-            history.onChange(() => this._emitEdit());
-        }
-    }
-
-    /** @private */
-    _emitEdit() {
-        for (const fn of this._editListeners) fn(this);
-    }
-
-    /** A new, empty view of this model's kind. @protected */
-    _newView(id, title) {
-        throw new Error(`${this.constructor.name} must implement _newView()`);
-    }
-
-    /** Subscribe to changes; returns an unsubscribe function. */
-    onChange(fn) {
-        this._listeners.push(fn);
-        return () => { this._listeners = this._listeners.filter(l => l !== fn); };
-    }
-
-    /** All views, in order. */
-    views() {
-        return [...this._views.values()];
-    }
-
-    get viewCount() {
-        return this._views.size;
-    }
-
-    get currentView() {
-        return this._views.get(this.currentViewId) ?? null;
-    }
-
-    getView(id) {
-        return this._views.get(id) ?? null;
-    }
-
-    /** Title offered for the next new view. */
-    nextViewTitle() {
-        return `${this.viewNoun} ${this._views.size + 1}`;
-    }
-
-    /** Add an empty view and make it current. */
-    createView(title = this.nextViewTitle()) {
-        return this._add(this._newView(this._newId(), title));
-    }
-
-    /** Add an independent copy of a view and make it current. */
-    duplicateView(id) {
-        const original = this._views.get(id);
-        if (!original) return null;
-        return this._add(original.copy(this._newId(), `${original.title} (copy)`));
-    }
-
-    /** Give a view a new title (not an empty one). One undo step. */
-    renameView(id, title) {
-        const view = this._views.get(id);
-        if (!view || !title || title === view.title) return false;
-        this.history.execute(new RenameViewCommand(this, view, title));
-        return true;
-    }
-
-    /** A view's title set, as RenameViewCommand and replace do it (not undoable by itself). @protected */
-    _retitle(id, title) {
-        const view = this._views.get(id);
-        if (!view) return;
-        view.title = title;
-        this._notify();
-    }
-
-    /** The checks this model is held to (ViewSetChecker; a notation's model returns its own). */
-    checker() {
-        return new ViewSetChecker(this);
-    }
-
-    /** Find and replace over the model's texts (ModelSearch; a notation's model returns its own). */
-    search() {
-        return new ModelSearch(this);
-    }
-
-    /** The model's report (ModelReport; a notation's model returns its own), for reportHtml. */
-    report(options) {
-        return new ModelReport(this, options);
-    }
-
-    /** Whether a view may be deleted: the last one stays. */
-    canDeleteView(id) {
-        return this._views.has(id) && this._views.size > 1;
-    }
-
-    /** Remove a view; the last one cannot be removed. The neighbour becomes current. One undo step. */
-    deleteView(id) {
-        if (!this.canDeleteView(id)) return false;
-        this.history.execute(new RemoveViewCommand(this, this._views.get(id)));
-        return true;
-    }
-
-    switchTo(id) {
-        if (!this._views.has(id) || id === this.currentViewId) return false;
-        this.currentViewId = id;
-        this._notify();
-        return true;
-    }
-
-    /**
-     * Add a view (last), shown unless `current` is false: one undo step on the
-     * model's history (AddViewCommand).
-     * @protected
-     */
-    _add(view, { current = true } = {}) {
-        this.history.execute(new AddViewCommand(this, this._adopt(view), { current }));
-        return view;
-    }
-
-    /**
-     * Put a view in the model at `index` (default last), current if asked; as
-     * AddViewCommand and RemoveViewCommand's undo do it.
-     * @protected
-     */
-    _insertView(view, { index = this._views.size, current = true } = {}) {
-        const entries = [...this._views].filter(([id]) => id !== view.id);
-        entries.splice(Math.min(index, entries.length), 0, [view.id, view]);
-        this._views = new Map(entries);
-        if (current || !this.currentViewId) this.currentViewId = view.id;
-        this._notify();
-    }
-
-    /**
-     * Take a view out of the model; the one in front becomes `next` (if given
-     * and still there) or, when it was this one, its neighbour.
-     * @returns {{index: number, current: boolean}} where it was, and whether it was in front
-     * @protected
-     */
-    _removeView(id, { next = null } = {}) {
-        const ids = [...this._views.keys()];
-        const index = ids.indexOf(id);
-        const current = this.currentViewId === id;
-        this._views.delete(id);
-        if (next && this._views.has(next)) this.currentViewId = next;
-        else if (current) this.currentViewId = ids[index + 1] ?? ids[index - 1] ?? null;
-        this._notify();
-        return { index, current };
-    }
-
-    _newId() {
-        let id;
-        do { id = `${this.idPrefix}-${this._nextId++}`; } while (this._views.has(id));
-        return id;
-    }
-
-    _notify() {
-        for (const fn of this._listeners) fn(this);
-        this._watchHistories();
-    }
-
-    /** A change to the set of views: the model is no longer as saved. @protected */
-    _changedStructure() {
-        this._structure++;
-        this._emitEdit();
-    }
-}
+import { ViewSetChecker } from './ViewSetChecker.js';
+import { ModelReport } from './ModelReport.js';
+import { ModelSearch } from './ModelSearch.js';
+import { ModelHistory } from './ModelHistory.js';
+import { AddViewCommand } from './AddViewCommand.js';
+import { RemoveViewCommand } from './RemoveViewCommand.js';
+import { RenameViewCommand } from './RenameViewCommand.js';
+import { ModelComparison } from './ModelComparison.js';
+import { ViewsCompared } from './ViewsCompared.js';
+
+/**
+ * ViewSetModel — a model edited as several views (diagrams), with one current.
+ * Owns what every such model does with its views: create, duplicate, rename,
+ * delete, switch, and telling listeners after each change, so a UI only has to
+ * re-render on notification. It has one undo history (`history`, a
+ * ModelHistory, as Archi has one command stack per model) that every view of
+ * it shares: adding, renaming and deleting views are undoable steps on it too.
+ *
+ * Subclasses make their own kind of view through `_newView(id, title)`; a view
+ * has an `id`, a `title`, and `copy(id, title)` for duplication. DiagramModel
+ * (the template editor) and ArchimateModel extend it.
+ */
+export class ViewSetModel {
+    /**
+     * @param {Object} [options]
+     * @param {string} [options.idPrefix] - Prefix for generated view ids
+     * @param {string} [options.viewNoun] - What a view is called in default titles ('Diagram', 'View')
+     */
+    constructor({ idPrefix = 'view', viewNoun = 'View' } = {}) {
+        if (new.target === ViewSetModel) throw new TypeError('ViewSetModel is abstract — subclass it');
+        /** @type {Map<string, Object>} in tab order */
+        this._views = new Map();
+        this.currentViewId = null;
+        this.idPrefix = idPrefix;
+        this.viewNoun = viewNoun;
+        this._nextId = 1;
+        this._listeners = [];
+        /** Bumped by every change to the set of views (new, duplicated, renamed, deleted). */
+        this._structure = 0;
+        this._saved = null;
+        this._editListeners = [];
+        this._watched = new WeakSet();
+    }
+
+    /** The model's one undo history, which every view of it shares (ModelHistory). */
+    get history() {
+        return (this._history ??= new ModelHistory(this, this.historyOptions ?? {}));
+    }
+
+    /** Make a view one of this model's: its edits go on the model's history. @protected */
+    _adopt(view) {
+        view.history = this.history;
+        return view;
+    }
+
+    // ===== Saved or not =====
+
+    /** Remember this state as the saved one (after opening or saving a file). */
+    markSaved() {
+        this._saved = { structure: this._structure, token: this.history.stateToken };
+        this._emitEdit();
+    }
+
+    /**
+     * Whether anything changed since markSaved: an edit on the model's history
+     * (any view's, or to the views themselves) not undone back again.
+     */
+    isDirty() {
+        const saved = this._saved ?? { structure: 0, token: 0 };
+        return this._structure !== saved.structure || this.history.stateToken !== saved.token;
+    }
+
+    /** Call `fn(model)` after every edit (any view's history, or the set of views). Returns an unsubscribe function. */
+    onEdit(fn) {
+        this._editListeners.push(fn);
+        this._watchHistories();
+        return () => { this._editListeners = this._editListeners.filter(l => l !== fn); };
+    }
+
+    /** Listen to the model's history (and any view's own, for one not adopted). @private */
+    _watchHistories() {
+        for (const history of [this.history, ...this.views().map(v => v.history)]) {
+            if (!history?.onChange || this._watched.has(history)) continue;
+            this._watched.add(history);
+            history.onChange(() => this._emitEdit());
+        }
+    }
+
+    /** @private */
+    _emitEdit() {
+        for (const fn of this._editListeners) fn(this);
+    }
+
+    /** A new, empty view of this model's kind. @protected */
+    _newView(id, title) {
+        throw new Error(`${this.constructor.name} must implement _newView()`);
+    }
+
+    /** Subscribe to changes; returns an unsubscribe function. */
+    onChange(fn) {
+        this._listeners.push(fn);
+        return () => { this._listeners = this._listeners.filter(l => l !== fn); };
+    }
+
+    /** All views, in order. */
+    views() {
+        return [...this._views.values()];
+    }
+
+    get viewCount() {
+        return this._views.size;
+    }
+
+    get currentView() {
+        return this._views.get(this.currentViewId) ?? null;
+    }
+
+    getView(id) {
+        return this._views.get(id) ?? null;
+    }
+
+    /** Title offered for the next new view. */
+    nextViewTitle() {
+        return `${this.viewNoun} ${this._views.size + 1}`;
+    }
+
+    /** Add an empty view and make it current. */
+    createView(title = this.nextViewTitle()) {
+        return this._add(this._newView(this._newId(), title));
+    }
+
+    /** Add an independent copy of a view and make it current. */
+    duplicateView(id) {
+        const original = this._views.get(id);
+        if (!original) return null;
+        return this._add(original.copy(this._newId(), `${original.title} (copy)`));
+    }
+
+    /** Give a view a new title (not an empty one). One undo step. */
+    renameView(id, title) {
+        const view = this._views.get(id);
+        if (!view || !title || title === view.title) return false;
+        this.history.execute(new RenameViewCommand(this, view, title));
+        return true;
+    }
+
+    /** A view's title set, as RenameViewCommand and replace do it (not undoable by itself). @protected */
+    _retitle(id, title) {
+        const view = this._views.get(id);
+        if (!view) return;
+        view.title = title;
+        this._notify();
+    }
+
+    /** The checks this model is held to (ViewSetChecker; a notation's model returns its own). */
+    checker() {
+        return new ViewSetChecker(this);
+    }
+
+    /** Find and replace over the model's texts (ModelSearch; a notation's model returns its own). */
+    search() {
+        return new ModelSearch(this);
+    }
+
+    /** The model's report (ModelReport; a notation's model returns its own), for reportHtml. */
+    report(options) {
+        return new ModelReport(this, options);
+    }
+
+    /** What two such models are compared on and merged by (ComparedKind), what is needed first: their views here. */
+    comparedKinds() {
+        return [new ViewsCompared()];
+    }
+
+    /** How this model differs from another (ModelComparison), which can merge the other's into it. */
+    compareWith(other) {
+        return new ModelComparison(this, other);
+    }
+
+    /** A copy of another model's view, as one of this model's, under the same id (a merge brings it). @protected */
+    _viewFrom(view) {
+        return this._adopt(view.copy(view.id, view.title));
+    }
+
+    /** Whether a view may be deleted: the last one stays. */
+    canDeleteView(id) {
+        return this._views.has(id) && this._views.size > 1;
+    }
+
+    /** Remove a view; the last one cannot be removed. The neighbour becomes current. One undo step. */
+    deleteView(id) {
+        if (!this.canDeleteView(id)) return false;
+        this.history.execute(new RemoveViewCommand(this, this._views.get(id)));
+        return true;
+    }
+
+    switchTo(id) {
+        if (!this._views.has(id) || id === this.currentViewId) return false;
+        this.currentViewId = id;
+        this._notify();
+        return true;
+    }
+
+    /**
+     * Add a view (last), shown unless `current` is false: one undo step on the
+     * model's history (AddViewCommand).
+     * @protected
+     */
+    _add(view, { current = true } = {}) {
+        this.history.execute(new AddViewCommand(this, this._adopt(view), { current }));
+        return view;
+    }
+
+    /**
+     * Put a view in the model at `index` (default last), current if asked; as
+     * AddViewCommand and RemoveViewCommand's undo do it.
+     * @protected
+     */
+    _insertView(view, { index = this._views.size, current = true } = {}) {
+        const entries = [...this._views].filter(([id]) => id !== view.id);
+        entries.splice(Math.min(index, entries.length), 0, [view.id, view]);
+        this._views = new Map(entries);
+        if (current || !this.currentViewId) this.currentViewId = view.id;
+        this._notify();
+    }
+
+    /**
+     * Take a view out of the model; the one in front becomes `next` (if given
+     * and still there) or, when it was this one, its neighbour.
+     * @returns {{index: number, current: boolean}} where it was, and whether it was in front
+     * @protected
+     */
+    _removeView(id, { next = null } = {}) {
+        const ids = [...this._views.keys()];
+        const index = ids.indexOf(id);
+        const current = this.currentViewId === id;
+        this._views.delete(id);
+        if (next && this._views.has(next)) this.currentViewId = next;
+        else if (current) this.currentViewId = ids[index + 1] ?? ids[index - 1] ?? null;
+        this._notify();
+        return { index, current };
+    }
+
+    _newId() {
+        let id;
+        do { id = `${this.idPrefix}-${this._nextId++}`; } while (this._views.has(id));
+        return id;
+    }
+
+    _notify() {
+        for (const fn of this._listeners) fn(this);
+        this._watchHistories();
+    }
+
+    /** A change to the set of views: the model is no longer as saved. @protected */
+    _changedStructure() {
+        this._structure++;
+        this._emitEdit();
+    }
+}

package/src/charting/diagramModel/ViewsCompared.js

@@ -0,0 +1,39 @@
+import { ComparedKind } from './ComparedKind.js';
+
+/**
+ * ViewsCompared — the views of two models (any ViewSetModel): a view's
+ * content is its JSON (`toJSON`); bringing one copies it into the model
+ * (`ViewSetModel#_viewFrom`) under its own id, in place of the view with that
+ * id, else last.
+ */
+export class ViewsCompared extends ComparedKind {
+    get key() { return 'view'; }
+    get label() { return 'Views'; }
+
+    items(model) {
+        return model.views();
+    }
+
+    get(model, id) {
+        return model.getView(id);
+    }
+
+    content(view) {
+        return view.toJSON();
+    }
+
+    bring(model, view, from) {
+        const twin = model._viewFrom(view);
+        const old = model.getView(twin.id);
+        if (!old) {
+            model._insertView(twin, { current: false });
+            return () => model._removeView(twin.id);
+        }
+        const { index, current } = model._removeView(old.id);
+        model._insertView(twin, { index, current });
+        return () => {
+            model._removeView(twin.id);
+            model._insertView(old, { index, current });
+        };
+    }
+}