@peter.prib/renderengine 0.4.0 → 0.7.0

package/src/charting/content/ContentSource.js

@@ -0,0 +1,129 @@
+/**
+ * ContentSource — models kept apart from the tools (modelengine, or any
+ * collection laid out the same way): a manifest listing items by domain, each
+ * a file in a format a modeller already reads (.archimate, .datamodel.json,
+ * .requirements.json …). A modeller depends on no collection: given a source,
+ * it offers the items its own file formats read (worked out from the files,
+ * not a list kept here) and opens one through that format, so a collection
+ * can grow, and be updated, without a change to the tools.
+ *
+ * A source is fetched (`url`: where its manifest.json is) or given whole
+ * (`bundle`: `{ manifest, files }`, what modelengine's dist/modelengine.js puts
+ * on `globalThis.ModelEngineContent`, for a page opened straight off disk).
+ *
+ * Manifest: `{ name, version?, domains?: [{id, name, description?}], items: [{ id,
+ * name, file, domain?, kind?, version?, description?, traces? }] }`.
+ */
+export class ContentSource {
+    /**
+     * @param {Object} options
+     * @param {string} [options.label] - What menus call it (else the manifest's name)
+     * @param {string} [options.url] - Where its manifest.json is (a folder, or the manifest itself)
+     * @param {{manifest: Object, files: Object<string, (string|{base64: string})>}} [options.bundle]
+     * @param {Function} [options.fetch] - For a `url` source (the page's fetch unless given)
+     */
+    constructor({ label = null, url = null, bundle = null, fetch = null } = {}) {
+        if (!url && !bundle) throw new TypeError('A content source needs a url or a bundle');
+        this._label = label;
+        this.url = url;
+        this.bundle = bundle;
+        this._fetch = fetch;
+        this._manifest = null;
+    }
+
+    /** The bundle a page loaded (dist/modelengine.js: globalThis.ModelEngineContent) as a source, or null when it has none. */
+    static fromPage(label = null, root = globalThis) {
+        const bundle = root?.ModelEngineContent;
+        return bundle?.manifest ? new ContentSource({ label, bundle }) : null;
+    }
+
+    /** What menus call it: its own label, else its manifest's name (a bundle's at once, a url's once read), else where it is. */
+    get label() {
+        return this._label ?? this._manifest?.name ?? this.bundle?.manifest?.name ?? this.url ?? 'Content';
+    }
+
+    /** Where a file of it is, for a `url` source. @private */
+    _resolve(file) {
+        const base = /\.json$/i.test(this.url) ? this.url : `${this.url.replace(/\/?$/, '/')}manifest.json`;
+        return new URL(file, new URL(base, globalThis.location?.href ?? 'http://localhost/')).href;
+    }
+
+    /** @private */
+    async _get(file, asBytes) {
+        const fetch = this._fetch ?? globalThis.fetch?.bind(globalThis);
+        if (!fetch) throw new Error(`Cannot read ${file}: no fetch here`);
+        const response = await fetch(this._resolve(file));
+        if (!response.ok) throw new Error(`Cannot read ${file} from ${this.label}: ${response.status ?? ''} ${response.statusText ?? ''}`.trim());
+        return asBytes ? new Uint8Array(await response.arrayBuffer()) : response.text();
+    }
+
+    /** Its manifest, read once (refresh: read again, for what was added or updated since). */
+    async manifest({ refresh = false } = {}) {
+        if (this._manifest && !refresh) return this._manifest;
+        const manifest = this.bundle ? this.bundle.manifest : JSON.parse(await this._get('manifest.json', false));
+        ContentSource.check(manifest);
+        this._manifest = manifest;
+        return manifest;
+    }
+
+    /** Throws when a manifest will not do: no items, or an item without an id or a file, or two with one id. */
+    static check(manifest) {
+        if (!manifest || !Array.isArray(manifest.items)) throw new Error('Not a content manifest: it lists no items');
+        const ids = new Set();
+        for (const item of manifest.items) {
+            if (!item?.id || !item.file) throw new Error(`A content item needs an id and a file: ${JSON.stringify(item)}`);
+            if (ids.has(item.id)) throw new Error(`Two content items are "${item.id}"`);
+            ids.add(item.id);
+        }
+        return manifest;
+    }
+
+    /**
+     * The format of `formats` that reads an item's file: the only one
+     * accepting its whole ending (all after the name's first dot) — so a
+     * name ending .requirements.json is that format's, not just any .json;
+     * null when none, or more than one, would.
+     */
+    static formatFor(item, formats) {
+        const file = String(item?.file ?? '').toLowerCase();
+        const readers = formats.filter(f => f.imports !== false);
+        const name = file.split('/').pop();
+        const ending = name.includes('.') ? name.slice(name.indexOf('.')) : '';
+        const accepting = readers.filter(f => String(f.accept ?? '').split(',').map(a => a.trim().toLowerCase()).includes(ending));
+        return accepting.length === 1 ? accepting[0] : null;
+    }
+
+    /** Its items, each with its domain's name; with `formats`, only those one of them reads (`format` set on each). */
+    async items({ formats = null } = {}) {
+        const manifest = await this.manifest();
+        const domains = new Map((manifest.domains ?? []).map(d => [d.id, d]));
+        return manifest.items
+            .map(item => ({ ...item, domainName: domains.get(item.domain)?.name ?? item.domain ?? '', ...(formats && { format: ContentSource.formatFor(item, formats) }) }))
+            .filter(item => !formats || item.format);
+    }
+
+    /** An item by its id, or null. */
+    async item(id) {
+        return (await this.manifest()).items.find(i => i.id === id) ?? null;
+    }
+
+    /** An item's file: text, or bytes for a format that reads bytes. */
+    async read(item, format = null) {
+        const asBytes = !!format?.readsBytes;
+        if (!this.bundle) return this._get(item.file, asBytes);
+        const kept = this.bundle.files?.[item.file];
+        if (kept == null) throw new Error(`${this.label} has no file ${item.file}`);
+        if (typeof kept === 'string') return asBytes ? new TextEncoder().encode(kept) : kept;
+        const bytes = Uint8Array.from(atob(kept.base64), c => c.charCodeAt(0));
+        return asBytes ? bytes : new TextDecoder().decode(bytes);
+    }
+
+    /** An item opened as a model, through the format of `formats` that reads it: `{ model, format, item }`. */
+    async open(item, formats) {
+        const format = ContentSource.formatFor(item, formats);
+        if (!format) throw new Error(`Nothing here reads ${item.file}`);
+        const model = format.import(await this.read(item, format));
+        if (!model.name && item.name) model.name = item.name;
+        return { model, format, item };
+    }
+}

package/src/charting/content/ContentSources.js

@@ -0,0 +1,77 @@
+import { ContentSource } from './ContentSource.js';
+import { LocalJsonStore } from '../storage/LocalJsonStore.js';
+
+/**
+ * ContentSources — the content sources a modeller offers (ContentSource):
+ * the bundle the page loaded (modelengine's dist/modelengine.js), those its
+ * host or spec names, and those the user added (kept in this browser). Each
+ * manifest is read once (`load`), so menus are made at once from `catalog`;
+ * a source that could not be read is listed with why, not dropped.
+ */
+export class ContentSources {
+    /** Where the sources the user added are kept. */
+    static STORE_KEY = 'model-content-sources';
+
+    /**
+     * @param {Object} [options]
+     * @param {Array<ContentSource|{label?, url?, bundle?}>} [options.sources] - The host's or spec's
+     * @param {boolean} [options.fromPage] - Offer the bundle the page loaded (globalThis.ModelEngineContent)
+     * @param {Object} [options.store] - Where added sources are kept (a LocalJsonStore; a test gives its own)
+     * @param {Function} [options.fetch]
+     */
+    constructor({ sources = [], fromPage = true, store = new LocalJsonStore(ContentSources.STORE_KEY), fetch = null } = {}) {
+        this.store = store;
+        this._fetch = fetch;
+        const made = (s) => (s instanceof ContentSource ? s : new ContentSource({ ...s, fetch: s.fetch ?? fetch }));
+        this.given = [
+            ...(fromPage ? [ContentSource.fromPage()].filter(Boolean) : []),
+            ...sources.map(made),
+        ];
+        /** Each source with its items, or the error reading it: `[{ source, items, error }]` (after load). */
+        this.catalog = [];
+    }
+
+    /** The sources the user added: `[{ label, url }]`. */
+    added() {
+        return this.store?.load([]) ?? [];
+    }
+
+    /** Every source: given, then added. */
+    sources() {
+        const fetch = this._fetch;
+        return [...this.given, ...this.added().map(s => new ContentSource({ ...s, fetch }))];
+    }
+
+    /** Read every source's manifest afresh (what was added or updated since). Resolves to the catalog. */
+    async load() {
+        this.catalog = await Promise.all(this.sources().map(async (source) => {
+            try {
+                await source.manifest({ refresh: true });
+                return { source, items: await source.items(), error: null };
+            } catch (err) {
+                return { source, items: [], error: err.message };
+            }
+        }));
+        return this.catalog;
+    }
+
+    /** Add a source by its url (its label, else the manifest's name, once read); kept in this browser. */
+    async add({ url, label = '' }) {
+        const text = String(url ?? '').trim();
+        if (!text) throw new Error('A content source needs a url');
+        const list = this.added().filter(s => s.url !== text);
+        this.store?.save([...list, { url: text, ...(label && { label }) }]);
+        return this.load();
+    }
+
+    /** Stop offering an added source. */
+    async remove(url) {
+        this.store?.save(this.added().filter(s => s.url !== url));
+        return this.load();
+    }
+
+    /** A source by what menus call it, or by url. */
+    find(key) {
+        return this.catalog.map(c => c.source).find(s => s.label === key || s.url === key) ?? null;
+    }
+}

package/src/charting/datamodel/DataModel.js

@@ -20,6 +20,8 @@ import {
 } from './DataModelCompared.js';
 
 /** The levels, outermost first: each realised by the next. */
+import { duplicateGroups } from '../diagrams/duplicates.js';
+
 const LEVELS = Object.freeze(['conceptual', 'logical', 'physical']);
 
 /**
@@ -475,6 +477,120 @@ export class DataModel extends EditableModel {
         });
     }
 
+    /**
+     * The entities at a level that look like one thing twice (duplicates.js:
+     * by their names, their definitions — `by: 'documentation'` — or their
+     * attributes' names, `by: 'attributes'`; with DUPLICATE_OPTIONS). Each
+     * group is a model-check finding (`possible-duplicate`, kind 'entity',
+     * with its `level`), so the check's dialog lists it.
+     */
+    duplicateEntities(level, options = {}) {
+        const noun = DataModelNotation.level(level)?.entityNoun?.toLowerCase() ?? 'entity';
+        const nouns = noun.endsWith('y') ? `${noun.slice(0, -1)}ies` : `${noun}s`;
+        const items = this.level(level).entities.map(e => ({
+            id: e.id, name: e.name, type: level, documentation: e.description, attributes: e.attributes ?? [], properties: e.properties,
+        }));
+        const why = { documentation: ' (by their definitions)', attributes: ' (by their attributes)' }[options.by] ?? '';
+        return duplicateGroups(items, options).map(g => {
+            const names = [...new Set(g.map(e => String(e.name ?? '').trim()))];
+            return {
+                code: 'possible-duplicate', severity: 'warning', kind: 'entity', level, ids: g.map(e => e.id),
+                message: names.length === 1
+                    ? `${g.length} ${nouns} are named "${names[0]}"${why}`
+                    : `${g.length} ${nouns} look the same${why}: ${names.map(n => `"${n}"`).join(', ')}`,
+            };
+        });
+    }
+
+    /**
+     * Some entities at a level side by side, for a merge (MergeCompareDialog's
+     * rows): their names, definitions, each attribute (by name, any case: its
+     * type, or ✓, where an entity has it), their relationships and what they
+     * are mapped to at the levels either side.
+     * @returns {Array<{label: string, values: string[]}>}
+     */
+    entityComparison(level, ids) {
+        const schema = this.level(level);
+        const entities = ids.map(id => schema.entity(id)).filter(Boolean);
+        const nameOf = (id) => schema.entity(id)?.name || id;
+        const attributeNames = [];
+        for (const e of entities) {
+            for (const a of e.attributes ?? []) {
+                if (!attributeNames.some(n => n.toLowerCase() === String(a.name ?? '').toLowerCase())) attributeNames.push(String(a.name ?? ''));
+            }
+        }
+        const attribute = (e, name) => {
+            const a = (e.attributes ?? []).find(x => String(x.name ?? '').toLowerCase() === name.toLowerCase());
+            return a ? [a.type || '✓', a.isPK && 'PK', a.isFK && 'FK'].filter(Boolean).join(' ') : '';
+        };
+        const lines = (e) => schema.relationships
+            .filter(r => r.source === e.id || r.target === e.id)
+            .map(r => (r.source === e.id ? `${r.name ?? ''} → ${nameOf(r.target)}` : `${r.name ?? ''} ← ${nameOf(r.source)}`).trim())
+            .sort().join('\n');
+        const mapped = (e) => this.mappings.flatMap(m => [
+            ...(m.from === level ? m.pairs.filter(([a]) => a === e.id).map(([, b]) => `→ ${this.level(m.to).entity(b)?.name ?? b} (${m.to})`) : []),
+            ...(m.to === level ? m.pairs.filter(([, b]) => b === e.id).map(([a]) => `← ${this.level(m.from).entity(a)?.name ?? a} (${m.from})`) : []),
+        ]).sort().join('\n');
+        return [
+            { label: 'Name', values: entities.map(e => e.name ?? '') },
+            { label: 'Definition', values: entities.map(e => String(e.description ?? '').trim()) },
+            ...attributeNames.map(name => ({ label: `${name} (attribute)`, values: entities.map(e => attribute(e, name)) })),
+            { label: 'Relationships', values: entities.map(lines) },
+            { label: 'Mapped', values: entities.map(mapped) },
+        ];
+    }
+
+    /**
+     * Make entities at a level that are one thing twice into one (one undo
+     * step): `keepId` takes the attributes it lacks (by name, any case), their
+     * relationships (one left joining it to itself, or the same as another,
+     * goes) and their mapping pairs; the others go, perspectives and contexts
+     * forgetting them. `description`: its definition (else its own, with the
+     * others' it lacks joined on).
+     */
+    mergeEntitiesCommand(level, keepId, otherIds, { description } = {}) {
+        const keepName = this.level(level).entity(keepId)?.name ?? keepId;
+        return this.editCommand(`Merge ${otherIds.length + 1} into "${keepName}"`, (model) => {
+            const schema = model.level(level);
+            const keep = schema.entity(keepId);
+            const others = otherIds.filter(id => id !== keepId).map(id => schema.entity(id)).filter(Boolean);
+            if (!keep || !others.length) return;
+            const merged = new Set(others.map(e => e.id));
+            const into = (id) => (merged.has(id) ? keepId : id);
+            for (const other of others) {
+                const has = new Set((keep.attributes ?? []).map(a => String(a.name ?? '').toLowerCase()));
+                const added = (other.attributes ?? []).filter(a => !has.has(String(a.name ?? '').toLowerCase()));
+                if (added.length) keep.attributes = [...(keep.attributes ?? []), ...added.map(a => ({ ...a }))];
+                const theirs = String(other.description ?? '').trim();
+                if (description === undefined && theirs && !String(keep.description ?? '').includes(theirs)) {
+                    keep.description = keep.description ? `${keep.description}
+
+${theirs}` : theirs;
+                }
+            }
+            if (description !== undefined) keep.description = description;
+            // Re-pointed, a relationship doubling one there (untouched, or re-pointed before it) goes; doubles there before stay.
+            const key = (r) => `${r.source} ${r.target} ${r.name ?? ''} ${r.kind ?? ''}`;
+            const touched = new Set(schema.relationships.filter(r => merged.has(r.source) || merged.has(r.target)));
+            const seen = new Set(schema.relationships.filter(r => !touched.has(r)).map(key));
+            schema.relationships = schema.relationships.filter(r => {
+                if (!touched.has(r)) return true;
+                r.source = into(r.source);
+                r.target = into(r.target);
+                if ((r.source === keepId && r.target === keepId) || seen.has(key(r))) return false;
+                seen.add(key(r));
+                return true;
+            });
+            for (const m of model.mappings) {
+                if (m.from !== level && m.to !== level) continue;
+                const pairs = m.pairs.map(([a, b]) => [m.from === level ? into(a) : a, m.to === level ? into(b) : b]);
+                m.pairs = pairs.filter(([a, b], i) => pairs.findIndex(([c, d]) => c === a && d === b) === i);
+            }
+            schema.entities = schema.entities.filter(e => !merged.has(e.id));
+            for (const id of merged) for (const holder of [...model.perspectives, ...model.contexts]) holder.forgetEntity(level, id);
+        });
+    }
+
     /**
      * Which of a level's relationships something drawn is (a line, or a
      * Chen diamond), by its id, the id a diamond is given, else its ends and

package/src/charting/diagrams/ArchimateModel.js

@@ -26,7 +26,7 @@ import { AddToViewCommand, DeleteElementCommand, AddRelationshipToViewCommand, R
  */
 
 export class ArchimateModel extends ViewSetModel {
-    constructor({ id = undefined, name = '', elements = [], relationships = [], folders = [], elementFolders = [], views = [], documentation = undefined, properties = [], archi = null } = {}) {
+    constructor({ id = undefined, name = '', elements = [], relationships = [], folders = [], elementFolders = [], views = [], documentation = undefined, properties = [], archi = null, emptyViewFolders = [] } = {}) {
         // Views (create, duplicate, rename, delete, switch, change listeners) come from ViewSetModel.
         super({ idPrefix: 'view', viewNoun: 'View' });
         this.name = name;
@@ -40,6 +40,8 @@ export class ArchimateModel extends ViewSetModel {
         this.properties = properties.map(p => ({ ...p }));
         /** What an Archi file said about the model that it does not use (profiles, ...), written back on export. */
         this.archi = archi;
+        /** The Views sub-folders that hold no view, each a path of folder steps ({id, name}) as a view's `archiFolder` is. */
+        this.emptyViewFolders = emptyViewFolders.map(path => path.map(step => ({ ...step })));
         this._elementFolder = new Map(); // elementId -> folderId (which folder contains this element)
 
         // Ingest elements
@@ -238,8 +240,8 @@ export class ArchimateModel extends ViewSetModel {
      * others' relationships, boxes, missing documentation and properties
      * (MergeElementsCommand, not yet executed; put it on `history`).
      */
-    mergeCommand(keepId, otherIds) {
-        return new MergeElementsCommand(this, keepId, otherIds);
+    mergeCommand(keepId, otherIds, choices = {}) {
+        return new MergeElementsCommand(this, keepId, otherIds, choices);
     }
 
     /** Two models are compared on, and merged by, their elements, relationships and views (in the order brought). */
@@ -758,6 +760,39 @@ export class ArchimateView extends DiagramEditorState {
             .filter(inst => inst.relationshipId === relationshipId);
     }
 
+    /**
+     * The boxes that only repeat another box of the same element here: the same
+     * label shown, in the same box (or none), with the same lines drawn (each
+     * relationship, or connection, to the same thing at the other end). The
+     * first such box of each stays; the ones after it are returned, to remove.
+     * A box holding other boxes is never one.
+     * @returns {string[]} box (instance) ids
+     */
+    repeatedBoxes() {
+        const boxes = [...this.elementInstances.values()].filter(i => i.elementId && this.model.getElement?.(i.elementId));
+        const all = [...this.elementInstances.values()];
+        const byVisual = new Map(all.filter(i => i.visualId).map(i => [i.visualId, i]));
+        const holds = (box) => box.visualId && all.some(i => i.nestedIn === box.visualId);
+        const thing = (instanceId) => { const i = this.elementInstances.get(instanceId); return i?.elementId ?? instanceId; };
+        const lines = (box) => [
+            ...[...this.relationshipInstances.values()].map(l => [`r:${l.relationshipId}`, l]),
+            ...[...this.viewConnections.values()].map(l => [`c:${l.label ?? ''}`, l]),
+        ].flatMap(([what, l]) => [
+            ...(l.sourceInstanceId === box.id ? [`${what}>${thing(l.targetInstanceId)}`] : []),
+            ...(l.targetInstanceId === box.id ? [`${what}<${thing(l.sourceInstanceId)}`] : []),
+        ]).sort();
+        const seen = new Set();
+        const repeats = [];
+        for (const box of boxes) {
+            if (holds(box)) continue;
+            const inside = byVisual.get(box.nestedIn)?.elementId ?? '';
+            const key = JSON.stringify([box.elementId, box.getDisplayName?.(this.model) ?? '', inside, lines(box)]);
+            if (seen.has(key)) repeats.push(box.id);
+            else seen.add(key);
+        }
+        return repeats;
+    }
+
     /**
      * Clear all element instances.
      */

package/src/charting/diagrams/ArchimateModelChecker.js

@@ -68,9 +68,16 @@ export class ArchimateModelChecker extends ViewSetChecker {
      * Elements of the same type whose names have the same words (ignoring
      * case, punctuation, word order and filler words: duplicates.js): likely
      * one thing twice. The finding names them all, so they can be merged.
+     * `options` (DUPLICATE_OPTIONS) compare otherwise: by documentation, by a
+     * property's value, with more noise left out, across types. `within`: only
+     * among these elements (by id: a view's, a selection's).
      */
-    possibleDuplicates() {
-        return duplicateGroups(this.model.elements()).map(g => {
+    possibleDuplicates(options = {}, { within = null } = {}) {
+        const { by = 'name', property } = options;
+        const why = { documentation: ' (by their documentation)', property: ` (by their ${property})` }[by] ?? '';
+        const among = within ? new Set(within) : null;
+        const elements = this.model.elements().filter(e => !among || among.has(e.id));
+        return duplicateGroups(elements, options).map(g => {
             // Names that differ only in case and spacing are one name to the reader.
             const byLook = new Map();
             for (const e of g) {
@@ -78,11 +85,13 @@ export class ArchimateModelChecker extends ViewSetChecker {
                 if (!byLook.has(look)) byLook.set(look, this._name(e).trim());
             }
             const names = [...byLook.values()];
+            const types = [...new Set(g.map(e => e.type))];
+            const what = types.length === 1 ? `${g.length} ${types[0]} elements` : `${g.length} elements (${types.join(', ')})`;
             return {
                 code: 'possible-duplicate', severity: 'warning', kind: 'element', ids: g.map(e => e.id),
                 message: names.length === 1
-                    ? `${g.length} ${g[0].type} elements are named "${names[0]}"`
-                    : `${g.length} ${g[0].type} elements look the same: ${names.map(n => `"${n}"`).join(', ')}`,
+                    ? `${what} are named "${names[0]}"${why}`
+                    : `${what} look the same${why}: ${names.map(n => `"${n}"`).join(', ')}`,
             };
         });
     }