@peter.prib/renderengine 0.2.2 → 0.2.4

package/src/charting/diagrams/ArchimateViewsCompared.js

@@ -0,0 +1,70 @@
+import { ViewsCompared } from '../diagramModel/ViewsCompared.js';
+
+/** The lists of a view's JSON whose items have ids made anew each time a model is read. */
+const INSTANCE_LISTS = ['elementInstances', 'relationshipInstances', 'viewConnections'];
+
+/**
+ * ArchimateViewsCompared — an ArchimateModel's views (ArchiMate diagrams,
+ * sketches, canvases, templates). A view's content is what it draws and
+ * says (toJSON), its Archi type, folder and viewpoint, with its boxes and
+ * lines known by their place in it rather than by their ids, which reading
+ * a file makes anew, and without Archi's ids for them, which a copy drops.
+ * A view needs the elements and relationships it draws.
+ */
+export class ArchimateViewsCompared extends ViewsCompared {
+    content(view) {
+        const { elements, relationships, ...json } = view.toJSON();
+        return ArchimateViewsCompared.stableIds({
+            ...json,
+            archiViewType: view.archiViewType,
+            folder: (view.archiFolder ?? []).map(step => step.name),
+            viewpoint: view.viewpoint ?? null,
+            template: !!view.template,
+        });
+    }
+
+    requires(view) {
+        const json = view.toJSON();
+        return [
+            ...json.elements.map(el => ['element', el.id]),
+            ...json.relationships.map(rel => ['relationship', rel.id]),
+        ];
+    }
+
+    /**
+     * A view's JSON with each box's and line's id (wherever it appears, as a
+     * value or a key) replaced by its list and place ('elementInstances#3'),
+     * a parent box named by place too (`archi.parent`), and Archi's ids
+     * (`archi.id`) left out.
+     */
+    static stableIds(json) {
+        const ids = new Map();
+        // A box inside another names it (archi.parent) by its Archi id, or in a copy as diag-<its id>.
+        const parents = new Map();
+        for (const list of INSTANCE_LISTS) {
+            (json[list] ?? []).forEach((item, i) => {
+                if (item?.id == null) return;
+                const label = `${list}#${i}`;
+                ids.set(item.id, label);
+                parents.set(`diag-${item.id}`, label);
+                if (item.archi?.id != null) parents.set(item.archi.id, label);
+            });
+        }
+        const walk = (value) => {
+            if (Array.isArray(value)) return value.map(walk);
+            if (typeof value === 'string') return ids.get(value) ?? value;
+            if (!value || typeof value !== 'object') return value;
+            const out = {};
+            for (const [k, v] of Object.entries(value)) {
+                const walked = walk(v);
+                if (k === 'archi' && walked && typeof walked === 'object') {
+                    delete walked.id;
+                    if (parents.has(walked.parent)) walked.parent = parents.get(walked.parent);
+                }
+                out[ids.get(k) ?? k] = walked;
+            }
+            return out;
+        };
+        return walk(json);
+    }
+}

package/src/charting/diagrams/ConceptsCompared.js

@@ -0,0 +1,76 @@
+import { ComparedKind } from '../diagramModel/ComparedKind.js';
+import { structuredCopy } from './ElementInstance.js';
+
+/**
+ * ConceptsCompared — an ArchimateModel's elements, or its relationships, as
+ * two models are compared on them: one's content is all it holds (name, type,
+ * documentation, properties, ends); bringing one adds a copy, or puts the
+ * copy's fields in place of those of the one with its id. ElementsCompared
+ * and RelationshipsCompared say which model collection it is.
+ */
+export class ConceptsCompared extends ComparedKind {
+    constructor() {
+        super();
+        if (new.target === ConceptsCompared) throw new TypeError('ConceptsCompared is abstract — subclass it');
+    }
+
+    content(item) {
+        return structuredCopy(item);
+    }
+
+    /** Its name, else its type and id. */
+    nameOf(item) {
+        return item.name || `${item.type ?? item.kind ?? ''} ${item.id}`.trim();
+    }
+
+    bring(model, item) {
+        const copy = structuredCopy(item);
+        const old = this.get(model, item.id);
+        if (!old) {
+            this._add(model, copy);
+            return () => this._remove(model, item.id);
+        }
+        const before = structuredCopy(old);
+        const become = (fields) => {
+            for (const k of Object.keys(old)) delete old[k];
+            Object.assign(old, structuredCopy(fields));
+        };
+        become(copy);
+        return () => become(before);
+    }
+
+    /** Add one to the model. @abstract @protected */
+    _add(model, item) {
+        throw new Error(`${this.constructor.name} must implement _add()`);
+    }
+
+    /** Take one out of the model. @abstract @protected */
+    _remove(model, id) {
+        throw new Error(`${this.constructor.name} must implement _remove()`);
+    }
+}
+
+/** An ArchimateModel's elements. */
+export class ElementsCompared extends ConceptsCompared {
+    get key() { return 'element'; }
+    get label() { return 'Elements'; }
+    items(model) { return model.elements(); }
+    get(model, id) { return model.getElement(id) ?? null; }
+    _add(model, item) { model.addElement(item); }
+    _remove(model, id) { model.removeElement(id); }
+}
+
+/** An ArchimateModel's relationships: each needs its ends (an element, or another relationship). */
+export class RelationshipsCompared extends ConceptsCompared {
+    get key() { return 'relationship'; }
+    get label() { return 'Relationships'; }
+    items(model) { return model.relationships(); }
+    get(model, id) { return model.getRelationship(id) ?? null; }
+    _add(model, item) { model.addRelationship(item); }
+    _remove(model, id) { model.removeRelationship(id); }
+
+    requires(rel, from) {
+        return [rel.source, rel.target].filter(Boolean)
+            .map(id => [from.getRelationship(id) ? 'relationship' : 'element', id]);
+    }
+}