@peter.prib/renderengine 0.2.6 → 0.2.7

package/src/charting/datamodel/StructuredType.js

@@ -0,0 +1,63 @@
+import { DataType } from './DataType.js';
+
+/**
+ * StructuredType — a data type made of named fields, each of a type (a plain
+ * type's name or another data type's): BIAN's Amount, Datetime, Identifier.
+ * `fields` as `[{ name, type?, description?, iso20022? }]`. Drawn as a box with
+ * a row per field, joined to the data types its fields are.
+ */
+export class StructuredType extends DataType {
+    static kind = 'structure';
+    static kindLabel = 'Structure';
+
+    /** @param {Object} spec - As DataType, plus `fields: [{ name, type?, description?, iso20022? }]` */
+    constructor({ fields = [], ...spec } = {}) {
+        super(spec);
+        this.fields = fields.map(f => ({
+            name: String(f.name),
+            ...(f.type && { type: String(f.type) }),
+            ...(f.description && { description: f.description }),
+            ...(f.iso20022 && { iso20022: f.iso20022 }),
+        }));
+    }
+
+    summary() {
+        return `${this.name}: ${this.fields.map(f => (f.type ? `${f.name} (${f.type})` : f.name)).join(', ')}`;
+    }
+
+    rows() {
+        return this.fields.map(f => ({ name: f.name, ...(f.type && { type: f.type }) }));
+    }
+
+    uses() {
+        return [...super.uses(), ...this.fields.map(f => f.type).filter(Boolean)];
+    }
+
+    toJSON() {
+        return { ...super.toJSON(), fields: this.fields.map(f => ({ ...f })) };
+    }
+
+    /** A plain type's fields, then its fields a line each: `name | type`. */
+    static fields(model, type = null) {
+        return [
+            ...DataType.fields(model, type),
+            {
+                key: 'fields', label: 'Fields', type: 'textarea', rows: 6,
+                value: (type?.fields ?? []).map(f => (f.type ? `${f.name} | ${f.type}` : f.name)).join('\n'),
+                hint: 'One a line: name | type (a plain type, or a data type by name)',
+            },
+        ];
+    }
+
+    static specFrom(values, model, type = null) {
+        return {
+            ...super.specFrom(values),
+            fields: DataType.lines(values.fields).map(([name, fieldType]) => {
+                const kept = type?.fields.find(f => f.name === name);
+                return { ...kept, name, ...(fieldType ? { type: fieldType } : { type: undefined }) };
+            }).map(f => JSON.parse(JSON.stringify(f))),
+        };
+    }
+}
+
+DataType.register(StructuredType);

package/src/charting/datamodel/index.js

@@ -1,5 +1,15 @@
 export { DataModel } from './DataModel.js';
 export { DataModelPerspective } from './DataModelPerspective.js';
 export { DataModelContext } from './DataModelContext.js';
+export { ServiceDomain } from './ServiceDomain.js';
+export { DataModelChecker } from './DataModelChecker.js';
+export { DataType } from './DataType.js';
+export { EnumerationType } from './EnumerationType.js';
+export { StructuredType } from './StructuredType.js';
+export { ServiceLandscape } from './ServiceLandscape.js';
+export { BianLandscapeReader } from './BianLandscapeReader.js';
+export { BianSemanticApiReader } from './BianSemanticApiReader.js';
 export { LevelSchema } from './LevelSchema.js';
 export { LevelMapping } from './LevelMapping.js';
+export { DataModelFileFormat } from './DataModelFileFormat.js';
+export { LevelEntitiesCompared, LevelRelationshipsCompared, MappingsCompared, ContextsCompared, PerspectivesCompared, DataTypesCompared } from './DataModelCompared.js';

package/src/charting/diagramModel/MergeModelCommand.js

@@ -1,37 +1,43 @@
-import { Command } from '../CommandHistory.js';
-
-/**
- * MergeModelCommand — things from another model brought into this one
- * (ModelComparison#mergeCommand): each step a ComparedKind's `bring`, in the
- * order given (what is needed first). One undo step; undo takes each back,
- * last first.
- */
-export class MergeModelCommand extends Command {
-    /** A merge is no edit on one view: undoing it shows no other. */
-    viewId = null;
-
-    /**
-     * @param {ViewSetModel} model - Merged into
-     * @param {ViewSetModel} from - Merged from
-     * @param {Array<{kind: ComparedKind, item: Object}>} steps
-     * @param {string} [label]
-     */
-    constructor(model, from, steps, label = `Merge ${steps.length} item${steps.length === 1 ? '' : 's'} from "${from.name || 'another model'}"`) {
-        super(label);
-        this.model = model;
-        this.from = from;
-        this.steps = steps;
-        this._undos = [];
-    }
-
-    execute() {
-        this._undos = this.steps.map(({ kind, item }) => kind.bring(this.model, item, this.from));
-        this.model._notify();
-    }
-
-    undo() {
-        for (const undo of [...this._undos].reverse()) undo();
-        this._undos = [];
-        this.model._notify();
-    }
-}
+import { Command } from '../CommandHistory.js';
+
+/**
+ * MergeModelCommand — things from another model brought into this one
+ * (ModelComparison#mergeCommand): each step a ComparedKind's `bring`, in the
+ * order given (what is needed first). One undo step; undo takes each back,
+ * last first.
+ */
+export class MergeModelCommand extends Command {
+    /** A merge is no edit on one view: undoing it shows no other. */
+    viewId = null;
+
+    /**
+     * @param {ViewSetModel} model - Merged into
+     * @param {ViewSetModel} from - Merged from
+     * @param {Array<{kind: ComparedKind, item: Object}>} steps
+     * @param {string} [label]
+     */
+    constructor(model, from, steps, label = `Merge ${steps.length} item${steps.length === 1 ? '' : 's'} from "${from.name || 'another model'}"`) {
+        super(label);
+        this.model = model;
+        this.from = from;
+        this.steps = steps;
+        this._undos = [];
+    }
+
+    execute() {
+        this._undos = this.steps.map(({ kind, item }) => kind.bring(this.model, item, this.from));
+        this._changed();
+    }
+
+    undo() {
+        for (const undo of [...this._undos].reverse()) undo();
+        this._undos = [];
+        this._changed();
+    }
+
+    /** The model changed: a view set tells its listeners; a model without views (a DataModel) says it was edited. @private */
+    _changed() {
+        this.model._notify?.();
+        this.model.edited?.();
+    }
+}

package/src/charting/diagramModel/OpenViewList.js

@@ -0,0 +1,75 @@
+/**
+ * OpenViewList — the views of a model that have a tab, in tab order, as a
+ * browser keeps its tabs: closing a tab leaves the view in the model, and a
+ * view is opened by going to it (from the tree, a search, a new view). It
+ * starts with the view in front only, so a model opened or imported with many
+ * views does not fill the tab strip.
+ *
+ * It follows the model: `sync()` drops views since deleted and opens the one in
+ * front, unless paused (`while`: a report passing through every view opens none).
+ */
+export class OpenViewList {
+    /**
+     * @param {ViewSetModel} model
+     * @param {Iterable<string>} [ids] - Those open to start with (default: the view in front)
+     */
+    constructor(model, ids = null) {
+        this.model = model;
+        this.ids = ids ? [...ids] : (model.currentViewId ? [model.currentViewId] : []);
+        this._paused = 0;
+        this.sync();
+    }
+
+    /** Follow the model: deleted views gone, the one in front open (last). Returns the open views. */
+    sync() {
+        this.ids = this.ids.filter(id => this.model.getView(id));
+        const current = this.model.currentViewId;
+        if (!this._paused && current && !this.ids.includes(current)) this.ids.push(current);
+        return this.views();
+    }
+
+    /** The open views, in tab order. */
+    views() {
+        return this.ids.map(id => this.model.getView(id)).filter(Boolean);
+    }
+
+    isOpen(id) {
+        return this.ids.includes(id);
+    }
+
+    /** Open a view's tab (if not open) and bring it to the front. */
+    open(id) {
+        if (!this.model.getView(id)) return false;
+        if (!this.ids.includes(id)) this.ids.push(id);
+        if (this.model.currentViewId !== id) this.model.switchTo(id);
+        return true;
+    }
+
+    /** Whether a tab may be closed: one always stays open. */
+    canClose(id) {
+        return this.ids.includes(id) && this.ids.length > 1;
+    }
+
+    /**
+     * Close a view's tab; the view stays in the model. Closing the tab in front
+     * brings its neighbour (the next, else the one before) to the front.
+     * @returns {boolean} whether it closed
+     */
+    close(id) {
+        if (!this.canClose(id)) return false;
+        const index = this.ids.indexOf(id);
+        this.ids.splice(index, 1);
+        if (this.model.currentViewId === id) this.model.switchTo(this.ids[Math.min(index, this.ids.length - 1)]);
+        return true;
+    }
+
+    /** Run `fn` with the list paused: going through views (a report's pictures) opens none. */
+    while(fn) {
+        this._paused++;
+        try { return fn(); } finally { this._paused--; }
+    }
+
+    toJSON() {
+        return [...this.ids];
+    }
+}

package/src/charting/diagramModel/ViewSetChecker.js

@@ -1,34 +1,22 @@
-/**
- * ViewSetChecker — checks over any ViewSetModel (a template editor's
- * DiagramModel, an ArchimateModel): what is wrong or worth a look across its
- * views. A notation adds its own checks in a subclass (ArchimateModelChecker).
- * DOM-free and advisory.
- *
- * Each finding: `{ code, severity: 'warning'|'info', message, kind, ids }`;
- * `kind` says what the ids name ('view' here; a subclass adds its own).
- * Each check is a method listed by `checks()`, so a subclass can add, drop or
- * reorder them.
- */
-export class ViewSetChecker {
-    /** @param {ViewSetModel} model */
-    constructor(model) {
-        this.model = model;
-    }
-
-    /** The checks to run, in the order their findings are listed. */
-    checks() {
-        return [this.emptyViews];
-    }
-
-    /** Every finding. @returns {Array<Object>} */
-    run() {
-        return this.checks().flatMap(check => check.call(this));
-    }
-
-    /** Views with nothing on them (a template is left out: an empty one is still a start). */
-    emptyViews() {
-        return this.model.views()
-            .filter(v => !v.template && v.isEmpty())
-            .map(v => ({ code: 'empty-view', severity: 'info', kind: 'view', ids: [v.id], message: `View "${v.title || v.name || v.id}" is empty` }));
-    }
-}
+import { ModelChecker } from '../ModelChecker.js';
+
+/**
+ * ViewSetChecker — checks over any ViewSetModel (a template editor's
+ * DiagramModel, an ArchimateModel): what is wrong or worth a look across its
+ * views (a ModelChecker: findings, checks listed by `checks()`). A notation
+ * adds its own checks in a subclass (ArchimateModelChecker). `kind` in a
+ * finding is 'view' here; a subclass adds its own.
+ */
+export class ViewSetChecker extends ModelChecker {
+    /** The checks to run, in the order their findings are listed. */
+    checks() {
+        return [this.emptyViews];
+    }
+
+    /** Views with nothing on them (a template is left out: an empty one is still a start). */
+    emptyViews() {
+        return this.model.views()
+            .filter(v => !v.template && v.isEmpty())
+            .map(v => ({ code: 'empty-view', severity: 'info', kind: 'view', ids: [v.id], message: `View "${v.title || v.name || v.id}" is empty` }));
+    }
+}

package/src/charting/diagrams/DataModelRelationshipStrategy.js

@@ -42,7 +42,7 @@ export class RelationshipAsNodeStrategy extends DataModelRelationshipStrategy {
     /**
      * Where a diamond between two places goes: their midpoint when it is clear
      * of everything in `occupied`, else the nearest clear spot stepping out
-     * across the line, one side then the other; the midpoint when none is clear.
+     * across the line, one side then the other; when none is clear, the least covered.
      * @returns {{x: number, y: number}}
      */
     static spotFor(from, to, occupied) {
@@ -50,14 +50,22 @@ export class RelationshipAsNodeStrategy extends DataModelRelationshipStrategy {
         const mid = { x: (from.x + to.x) / 2, y: (from.y + to.y) / 2 };
         const length = Math.hypot(to.x - from.x, to.y - from.y) || 1;
         const across = { x: -(to.y - from.y) / length, y: (to.x - from.x) / length };
-        const clear = ({ x, y }) => occupied.every(o => x + width / 2 <= o.x0 || o.x1 <= x - width / 2 || y + height / 2 <= o.y0 || o.y1 <= y - height / 2);
+        // How much of a diamond at a spot is covered by what is there (0: clear).
+        const covered = ({ x, y }) => occupied.reduce((sum, o) => {
+            const w = Math.min(x + width / 2, o.x1) - Math.max(x - width / 2, o.x0);
+            const h = Math.min(y + height / 2, o.y1) - Math.max(y - height / 2, o.y0);
+            return sum + (w > 0 && h > 0 ? w * h : 0);
+        }, 0);
+        let best = mid, least = Infinity;
         for (let k = 0; k <= RelationshipAsNodeStrategy.TRIES; k++) {
             for (const side of k ? [1, -1] : [0]) {
                 const at = { x: mid.x + across.x * side * k * RelationshipAsNodeStrategy.STEP, y: mid.y + across.y * side * k * RelationshipAsNodeStrategy.STEP };
-                if (clear(at)) return at;
+                const c = covered(at);
+                if (c === 0) return at;
+                if (c < least) { best = at; least = c; }
             }
         }
-        return mid;
+        return best;   // none clear: the least covered
     }
 
     apply(relationships, { notation, entity = () => undefined, occupied = [] }) {