@peter.prib/renderengine 0.13.0 → 0.15.0

package/src/charting/datamodel/SqlDdl.js

@@ -1,85 +1,110 @@
-/** Words SQL keeps for itself that a name may not be left bare as. */
-const RESERVED = new Set(['user', 'order', 'group', 'table', 'select', 'from', 'where', 'by', 'to', 'key', 'check', 'default', 'index', 'primary', 'foreign', 'references', 'unique', 'column', 'constraint', 'value', 'values', 'date', 'time', 'timestamp', 'level', 'position', 'role']);
-
-/**
- * SqlDdl — a model's physical level as SQL DDL (DMBOK2's data integration: the
- * design handed to a database): a CREATE TABLE per table, its columns with
- * their types (`defaultType` where a column has none) and NOT NULL where
- * required, its primary key and UNIQUE columns; a FOREIGN KEY per column that
- * references another (`references`: a table, or `table.column`, by id or name;
- * a table alone: its primary key); and COMMENT ONs for definitions. Names are
- * quoted where SQL would not take them bare. ANSI SQL, as PostgreSQL reads it.
- */
-export class SqlDdl {
-    /**
-     * @param {Object} [options]
-     * @param {string} [options.defaultType] - A column's type when it names none
-     * @param {boolean} [options.comments] - Whether definitions become COMMENT ONs
-     */
-    constructor({ defaultType = 'VARCHAR(255)', comments = true } = {}) {
-        this.defaultType = defaultType;
-        this.comments = comments;
-    }
-
-    /** A name as SQL takes it: bare when it can be, else double-quoted. */
-    static name(text) {
-        const s = String(text);
-        return /^[a-z_][a-z0-9_]*$/.test(s) && !RESERVED.has(s) ? s : `"${s.replace(/"/g, '""')}"`;
-    }
-
-    /**
-     * A table's name as SQL takes it: a schema-qualified one (`sales.customer`)
-     * each part as name() has it, so it names the table in its schema rather
-     * than one table called "sales.customer".
-     */
-    static tableName(text) {
-        return String(text).split('.').map(SqlDdl.name).join('.');
-    }
-
-    /** A text as an SQL string literal. */
-    static literal(text) {
-        return `'${String(text).replace(/'/g, "''")}'`;
-    }
-
-    /** The DDL for a model's physical level. @returns {string} */
-    write(model) {
-        const schema = model.level('physical');
-        const tables = schema.entities;
-        const table = SqlDdl.tableName;
-        const out = [`-- ${model.name || 'Data model'}: the physical level, ${tables.length} table${tables.length === 1 ? '' : 's'}`, ''];
-        for (const t of tables) {
-            const columns = t.attributes ?? [];
-            const keys = columns.filter(c => c.isPK).map(c => SqlDdl.name(c.name));
-            const lines = [
-                ...columns.map(c => `    ${SqlDdl.name(c.name)} ${c.type || this.defaultType}${c.required || c.isPK ? ' NOT NULL' : ''}`),
-                ...(keys.length ? [`    PRIMARY KEY (${keys.join(', ')})`] : []),
-                ...columns.filter(c => c.isUnique && !c.isPK).map(c => `    UNIQUE (${SqlDdl.name(c.name)})`),
-            ];
-            out.push(`CREATE TABLE ${table(t.name)} (`, lines.join(',\n'), ');', '');
-        }
-        for (const t of tables) {
-            for (const c of (t.attributes ?? []).filter(a => a.isFK && a.references)) {
-                const ref = schema.resolveReference(c.references);
-                if (!ref) {
-                    out.push(`-- ${t.name}.${c.name} references ${c.references}, which is not a table here`);
-                    continue;
-                }
-                const theirs = ref.column ? [ref.column] : (ref.entity.attributes ?? []).filter(a => a.isPK).map(a => a.name);
-                if (!theirs.length) {
-                    out.push(`-- ${t.name}.${c.name} references ${ref.entity.name}, which has no primary key`);
-                    continue;
-                }
-                out.push(`ALTER TABLE ${table(t.name)} ADD CONSTRAINT ${SqlDdl.name(`fk_${t.name}_${c.name}`.toLowerCase().replace(/[^a-z0-9_]+/g, '_'))}`
-                    + ` FOREIGN KEY (${SqlDdl.name(c.name)}) REFERENCES ${table(ref.entity.name)} (${theirs.map(SqlDdl.name).join(', ')});`);
-            }
-        }
-        if (this.comments) {
-            const notes = tables.flatMap(t => [
-                ...(t.description ? [`COMMENT ON TABLE ${table(t.name)} IS ${SqlDdl.literal(t.description)};`] : []),
-                ...(t.attributes ?? []).filter(c => c.description).map(c => `COMMENT ON COLUMN ${table(t.name)}.${SqlDdl.name(c.name)} IS ${SqlDdl.literal(c.description)};`),
-            ]);
-            if (notes.length) out.push('', ...notes);
-        }
-        return `${out.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
-    }
-}
+/** Words SQL keeps for itself that a name may not be left bare as. */
+const RESERVED = new Set(['user', 'order', 'group', 'table', 'select', 'from', 'where', 'by', 'to', 'key', 'check', 'default', 'index', 'primary', 'foreign', 'references', 'unique', 'column', 'constraint', 'value', 'values', 'date', 'time', 'timestamp', 'level', 'position', 'role']);
+
+/**
+ * SqlDdl — a model's physical level as SQL DDL (DMBOK2's data integration: the
+ * design handed to a database): a CREATE TABLE per table, its columns with
+ * their types (`defaultType` where a column has none) and NOT NULL where
+ * required, its primary key and UNIQUE columns; a FOREIGN KEY per column that
+ * references another (`references`: a table, or `table.column`, by id or name;
+ * a table alone: its primary key); and COMMENT ONs for definitions. Names are
+ * quoted where SQL would not take them bare. ANSI SQL, as PostgreSQL reads it.
+ */
+export class SqlDdl {
+    /**
+     * @param {Object} [options]
+     * @param {string} [options.defaultType] - A column's type when it names none
+     * @param {boolean} [options.comments] - Whether definitions become COMMENT ONs
+     * @param {boolean|Array<string>|Set<string>|Object} [options.external] - Trust foreign keys to tables outside the model
+     */
+    constructor({ defaultType = 'VARCHAR(255)', comments = true, external = false } = {}) {
+        this.defaultType = defaultType;
+        this.comments = comments;
+        this.external = external;
+    }
+
+    /** A name as SQL takes it: bare when it can be, else double-quoted. */
+    static name(text) {
+        const s = String(text);
+        return /^[a-z_][a-z0-9_]*$/.test(s) && !RESERVED.has(s) ? s : `"${s.replace(/"/g, '""')}"`;
+    }
+
+    /**
+     * A table's name as SQL takes it: a schema-qualified one (`sales.customer`)
+     * each part as name() has it, so it names the table in its schema rather
+     * than one table called "sales.customer".
+     */
+    static tableName(text) {
+        return String(text).split('.').map(SqlDdl.name).join('.');
+    }
+
+    /** A text as an SQL string literal. */
+    static literal(text) {
+        return `'${String(text).replace(/'/g, "''")}'`;
+    }
+
+    /** The DDL for a model's physical level. @returns {string} */
+    write(model, { external = this.external } = {}) {
+        const schema = model.level('physical');
+        const tables = schema.entities;
+        const table = SqlDdl.tableName;
+        const out = [`-- ${model.name || 'Data model'}: the physical level, ${tables.length} table${tables.length === 1 ? '' : 's'}`, ''];
+        for (const t of tables) {
+            const columns = t.attributes ?? [];
+            const keys = columns.filter(c => c.isPK).map(c => SqlDdl.name(c.name));
+            const lines = [
+                ...columns.map(c => `    ${SqlDdl.name(c.name)} ${c.type || this.defaultType}${c.required || c.isPK ? ' NOT NULL' : ''}`),
+                ...(keys.length ? [`    PRIMARY KEY (${keys.join(', ')})`] : []),
+                ...columns.filter(c => c.isUnique && !c.isPK).map(c => `    UNIQUE (${SqlDdl.name(c.name)})`),
+            ];
+            out.push(`CREATE TABLE ${table(t.name)} (`, lines.join(',\n'), ');', '');
+        }
+
+        const isExternalTrusted = (tableName) => {
+            if (external === true) return true;
+            if (external instanceof Set) return external.has(tableName);
+            if (Array.isArray(external)) return external.includes(tableName);
+            if (external && typeof external === 'object') return !!external[tableName];
+            return false;
+        };
+
+        for (const t of tables) {
+            for (const c of (t.attributes ?? []).filter(a => a.isFK && a.references)) {
+                const ref = schema.resolveReference(c.references);
+                if (!ref) {
+                    const raw = String(c.references).trim();
+                    const dot = raw.lastIndexOf('.');
+                    let targetTable = raw;
+                    let targetCol = null;
+                    if (dot > 0) {
+                        targetTable = raw.slice(0, dot);
+                        targetCol = raw.slice(dot + 1);
+                    }
+                    if (isExternalTrusted(targetTable)) {
+                        const colRef = targetCol ? ` (${SqlDdl.name(targetCol)})` : '';
+                        out.push(`ALTER TABLE ${table(t.name)} ADD CONSTRAINT ${SqlDdl.name(`fk_${t.name}_${c.name}`.toLowerCase().replace(/[^a-z0-9_]+/g, '_'))}`
+                            + ` FOREIGN KEY (${SqlDdl.name(c.name)}) REFERENCES ${table(targetTable)}${colRef};`);
+                    } else {
+                        out.push(`-- ${t.name}.${c.name} references ${c.references}, which is not a table here`);
+                    }
+                    continue;
+                }
+                const theirs = ref.column ? [ref.column] : (ref.entity.attributes ?? []).filter(a => a.isPK).map(a => a.name);
+                if (!theirs.length) {
+                    out.push(`-- ${t.name}.${c.name} references ${ref.entity.name}, which has no primary key`);
+                    continue;
+                }
+                out.push(`ALTER TABLE ${table(t.name)} ADD CONSTRAINT ${SqlDdl.name(`fk_${t.name}_${c.name}`.toLowerCase().replace(/[^a-z0-9_]+/g, '_'))}`
+                    + ` FOREIGN KEY (${SqlDdl.name(c.name)}) REFERENCES ${table(ref.entity.name)} (${theirs.map(SqlDdl.name).join(', ')});`);
+            }
+        }
+        if (this.comments) {
+            const notes = tables.flatMap(t => [
+                ...(t.description ? [`COMMENT ON TABLE ${table(t.name)} IS ${SqlDdl.literal(t.description)};`] : []),
+                ...(t.attributes ?? []).filter(c => c.description).map(c => `COMMENT ON COLUMN ${table(t.name)}.${SqlDdl.name(c.name)} IS ${SqlDdl.literal(c.description)};`),
+            ]);
+            if (notes.length) out.push('', ...notes);
+        }
+        return `${out.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+    }
+}

package/src/charting/datamodel/index.js

@@ -19,3 +19,6 @@ export { DataModelFileFormat } from './DataModelFileFormat.js';
 export { SqlDdl } from './SqlDdl.js';
 export { SqlDdlFileFormat } from './SqlDdlFileFormat.js';
 export { LevelEntitiesCompared, LevelRelationshipsCompared, MappingsCompared, ContextsCompared, PerspectivesCompared, DataTypesCompared } from './DataModelCompared.js';
+export { ModelMapping } from './ModelMapping.js';
+export { DataLineage } from './DataLineage.js';
+export { ArchimateDataLink } from './ArchimateDataLink.js';

package/src/charting/decision/DecisionWorkbench.js

@@ -0,0 +1,295 @@
+// Copyright 2026 Jaroslav Peter Prib, Purveyor of Excellence
+/**
+ * DecisionWorkbench — the Decision Workbench's views of a SADIS recommendation
+ * (decisionengine), as chart specs this library draws.
+ *
+ * It reads decisionengine's JSON, not decisionengine: a workbench document
+ *
+ *   { kind: 'sadis-workbench', report, plan?, before? }
+ *
+ * holds a report's `toJSON()` (the ranked candidates, each with its score's
+ * parts), optionally a delivery plan's `toJSON()` and an earlier report to
+ * replay against. Each view is a `WorkbenchView` subclass naming the charts it
+ * shows (`{ title, chartType, data, options }`, `chartType` a CHART_CATALOG key)
+ * and notes for what a chart cannot show; a view needing what the document
+ * lacks (a plan, perspectives, an earlier report) is not offered.
+ *
+ * DOM-free: a workspace page puts each chart in a ChartPart.
+ */
+
+const KIND = 'sadis-workbench';
+const DAY = 24 * 60 * 60 * 1000;
+const pct = (share) => Math.round(share * 1000) / 10;
+const round = (n) => Math.round(n * 1000) / 1000;
+
+/** One view of the workbench: what it is called, whether the document can fill it, its charts and notes. */
+export class WorkbenchView {
+    static id = 'view';
+    static title = 'View';
+
+    constructor(workbench) { this.workbench = workbench; }
+
+    get id() { return this.constructor.id; }
+    get title() { return this.constructor.title; }
+
+    /** Whether the document holds what this view needs. */
+    available() { return true; }
+
+    /** @returns {Array<{title: string, chartType: string, data: *, options?: object}>} */
+    charts() { return []; }
+
+    /** Plain lines for what the charts cannot show. */
+    notes() { return []; }
+
+    toJSON() {
+        return { id: this.id, title: this.title, charts: this.charts(), notes: this.notes() };
+    }
+}
+
+/** What to build next, how the scores are made up, how fast value arrives. */
+export class ExecutiveView extends WorkbenchView {
+    static id = 'executive';
+    static title = 'Executive';
+
+    charts() {
+        const { entries, plan } = this.workbench;
+        const top = entries[0];
+        const charts = [{ title: `Build next: ${top.name}`, chartType: 'kpi-tile', data: { value: round(top.score) } }];
+        if (plan) {
+            const half = plan.value.find((v) => v.share >= 0.5);
+            const last = plan.value[plan.value.length - 1];
+            charts.push(half
+                ? { title: `Half the recommended value delivered by period ${half.period} (%)`, chartType: 'kpi-tile', data: { value: pct(half.share) } }
+                : { title: `Value delivered by period ${last?.period ?? 0} (%)`, chartType: 'kpi-tile', data: { value: pct(last?.share ?? 0) } });
+        }
+        charts.push({
+            title: 'Score, part by part',
+            chartType: 'stackedBar',
+            data: ['basin', 'unlock', 'influence'].map((part) => ({
+                name: { basin: 'rating', unlock: 'unlock', influence: 'influence' }[part],
+                values: entries.map((e) => ({ label: e.name, value: round(e.flow[part]) })),
+            })),
+        });
+        if (plan) {
+            charts.push({
+                title: 'Value delivered by the end of each period (%)',
+                chartType: 'line',
+                data: plan.value.map((v) => ({ label: `P${v.period}`, value: pct(v.share) })),
+            });
+        }
+        return charts;
+    }
+
+    notes() {
+        const top = this.workbench.entries[0];
+        return [`#1 ${top.name} (${top.type}): score ${round(top.score)}`];
+    }
+}
+
+/** Where value hides: the rating each candidate shows against what it unlocks and reaches. */
+export class ArchitectureView extends WorkbenchView {
+    static id = 'architecture';
+    static title = 'Architecture';
+
+    charts() {
+        const { entries } = this.workbench;
+        return [
+            {
+                title: 'Visible rating against basin position (unlock + influence): foundations sit high and left',
+                chartType: 'scatter',
+                data: entries.map((e) => ({ label: e.name, x: round(e.flow.basin), y: round(e.flow.unlock + e.flow.influence), type: e.type })),
+                options: { colorCol: 'type' },
+            },
+            {
+                title: 'Share of other candidates each one frees (%)',
+                chartType: 'lollipop',
+                data: [...entries].sort((a, b) => b.basin.unlock - a.basin.unlock).map((e) => ({ label: e.name, value: pct(e.basin.unlock) })),
+            },
+        ];
+    }
+
+    notes() {
+        return this.workbench.entries
+            .filter((e) => e.basin.unlocked.length)
+            .map((e) => `${e.name} frees ${e.basin.unlocked.join(', ')}`);
+    }
+}
+
+/** The delivery plan: when each candidate is worked on, and how full each period is. */
+export class DeliveryView extends WorkbenchView {
+    static id = 'delivery';
+    static title = 'Delivery';
+
+    available() { return Boolean(this.workbench.plan); }
+
+    /** Period `p` (from 1) as the date it starts: the workbench's calendar. */
+    periodStart(p) {
+        const { start, periodDays } = this.workbench.calendar;
+        return new Date(start + (p - 1) * periodDays * DAY).toISOString().slice(0, 10);
+    }
+
+    /** Each planned candidate's first period worked and the period it is finished in. */
+    spans() {
+        const { plan } = this.workbench;
+        const start = new Map();
+        const end = new Map();
+        for (const p of plan.periods) {
+            for (const id of p.working ?? p.items) if (!start.has(id)) start.set(id, p.period);
+            for (const id of p.items) end.set(id, p.period);
+        }
+        return [...end].map(([id, finished]) => ({ id, start: start.get(id) ?? finished, end: finished }));
+    }
+
+    charts() {
+        const { plan } = this.workbench;
+        const name = (id) => this.workbench.entry(id)?.name ?? id;
+        const { periodDays } = this.workbench.calendar;
+        const charts = [{
+            title: `Delivery plan (${plan.order} order${plan.search?.swaps ? `, searched: ${plan.search.swaps} swaps` : ''}): ${periodDays}-day periods from ${this.periodStart(1)}`,
+            chartType: 'gantt',
+            data: this.spans().map((s) => ({ label: name(s.id), start: this.periodStart(s.start), end: this.periodStart(s.end + 1), category: this.workbench.entry(s.id)?.type })),
+            options: { dateFormat: 'iso', showToday: false },
+        }];
+        const teams = plan.periods[0]?.teams ? Object.keys(plan.periods[0].teams) : null;
+        charts.push({
+            title: 'Capacity used per period',
+            chartType: 'stackedBar',
+            data: teams
+                ? teams.map((team) => ({ name: team, values: plan.periods.map((p) => ({ label: `P${p.period}`, value: p.teams[team].used })) }))
+                : [
+                    { name: 'used', values: plan.periods.map((p) => ({ label: `P${p.period}`, value: p.used })) },
+                    { name: 'free', values: plan.periods.map((p) => ({ label: `P${p.period}`, value: p.capacity - p.used })) },
+                ],
+        });
+        return charts;
+    }
+
+    notes() {
+        const name = (id) => this.workbench.entry(id)?.name ?? id;
+        return this.workbench.plan.excluded.map((x) => `Not planned: ${name(x.id)} (${x.why})`);
+    }
+}
+
+/** Where the stakeholders' perspectives agree and where they pull apart. */
+export class PortfolioView extends WorkbenchView {
+    static id = 'portfolio';
+    static title = 'Portfolio';
+
+    available() { return Boolean(this.workbench.report.perspectives); }
+
+    charts() {
+        const { entries } = this.workbench;
+        const n = entries.length;
+        const contested = entries.filter((e) => e.spread > 0).sort((a, b) => b.spread - a.spread || a.rank - b.rank);
+        return [
+            {
+                title: 'Rank by perspective (darker: ranked higher)',
+                chartType: 'heatmap',
+                data: entries.flatMap((e) => e.perspectives.map((p) => ({ x: p.id, y: e.name, value: n - p.rank + 1 }))),
+            },
+            {
+                title: 'Best and worst rank across perspectives, most contested first',
+                chartType: 'dumbbell',
+                data: contested.map((e) => {
+                    const ranks = e.perspectives.filter((p) => p.weight > 0).map((p) => p.rank);
+                    return { label: e.name, start: Math.min(...ranks), end: Math.max(...ranks) };
+                }),
+            },
+        ];
+    }
+
+    notes() {
+        return Object.entries(this.workbench.report.perspectives).map(([id, weight]) => `${id}: weight ${weight}`);
+    }
+}
+
+/** What changed since the earlier report: ranks then and now, what entered and what left. */
+export class ReplayView extends WorkbenchView {
+    static id = 'replay';
+    static title = 'Replay';
+
+    available() { return Boolean(this.workbench.before); }
+
+    /** Each candidate's rank before and now; those only now, and those only before. */
+    change() {
+        const was = new Map(this.workbench.before.entries.map((e) => [e.id, e]));
+        const now = this.workbench.entries;
+        return {
+            moved: now.filter((e) => was.has(e.id)).map((e) => ({ id: e.id, name: e.name, from: was.get(e.id).rank, to: e.rank })),
+            entered: now.filter((e) => !was.has(e.id)),
+            left: this.workbench.before.entries.filter((e) => !this.workbench.entry(e.id)),
+        };
+    }
+
+    charts() {
+        const { moved } = this.change();
+        const when = (report) => report.asOf?.businessTime?.slice(0, 10);
+        const then = when(this.workbench.before) ?? 'then';
+        const now = when(this.workbench.report) ?? 'now';
+        return [{
+            title: `Rank ${then} → ${now} (1 = first)`,
+            chartType: 'slopegraph',
+            data: moved.map((m) => ({ label: m.name, start: m.from, end: m.to })),
+        }];
+    }
+
+    notes() {
+        const { moved, entered, left } = this.change();
+        const superseded = new Map((this.workbench.report.superseded ?? []).map((s) => [s.id, s.by]));
+        return [
+            ...entered.map((e) => `${e.name} entered (#${e.rank})`),
+            ...left.map((e) => `${e.name} left${superseded.has(e.id) ? ` (superseded by ${superseded.get(e.id).join(', ')})` : ''}`),
+            ...moved.filter((m) => m.from !== m.to).sort((a, b) => Math.abs(b.from - b.to) - Math.abs(a.from - a.to))
+                .map((m) => `${m.name} ${m.to < m.from ? 'up' : 'down'} ${Math.abs(m.from - m.to)} (#${m.from} → #${m.to})`),
+        ];
+    }
+}
+
+export const WORKBENCH_VIEWS = Object.freeze([ExecutiveView, ArchitectureView, DeliveryView, PortfolioView, ReplayView]);
+
+export class DecisionWorkbench {
+    static KIND = KIND;
+
+    /** A workbench from a workbench document, checked; refused with why when it is not one. */
+    static from(doc, calendar) {
+        if (!doc || typeof doc !== 'object') throw new Error('Not a decision workbench document');
+        if (doc.kind !== KIND) throw new Error(`Not a decision workbench document: kind is ${JSON.stringify(doc.kind)}, not "${KIND}"`);
+        const isReport = (r) => r && Array.isArray(r.entries) && r.entries.every((e) => e && e.id && e.flow && e.basin && Number.isFinite(e.rank));
+        if (!isReport(doc.report)) throw new Error('A decision workbench document needs a report: decisionengine\'s report.toJSON(), with ranked entries');
+        if (!doc.report.entries.length) throw new Error('The report ranks no candidates');
+        if (doc.plan !== undefined && !(doc.plan && Array.isArray(doc.plan.periods) && Array.isArray(doc.plan.value))) {
+            throw new Error('A plan, when given, is decisionengine\'s plan.toJSON(): periods and value');
+        }
+        if (doc.before !== undefined && !isReport(doc.before)) throw new Error('An earlier report, when given, is a report.toJSON() too');
+        return new DecisionWorkbench(doc, calendar);
+    }
+
+    /**
+     * @param {{report: object, plan?: object, before?: object}} doc
+     * @param {{start?: string|number, periodDays?: number}} [calendar] - when period 1 starts (default: the report's
+     *   as-of business time, else today) and how long a period is (default 14 days), for the delivery plan's dates
+     */
+    constructor({ report, plan = null, before = null }, { start, periodDays = 14 } = {}) {
+        const from = start ?? report.asOf?.businessTime ?? Date.now();
+        const ms = typeof from === 'number' ? from : Date.parse(from);
+        if (!Number.isFinite(ms)) throw new Error(`The calendar's start is ${JSON.stringify(start)}, not a date`);
+        if (!(Number.isFinite(periodDays) && periodDays > 0)) throw new Error('periodDays must be a number of days above 0');
+        this.calendar = Object.freeze({ start: ms, periodDays });
+        this.report = report;
+        this.plan = plan;
+        this.before = before;
+        this.entries = [...report.entries].sort((a, b) => a.rank - b.rank);
+        this.byId = new Map(this.entries.map((e) => [e.id, e]));
+    }
+
+    entry(id) { return this.byId.get(id); }
+
+    /** The views this document can fill, in order. */
+    views() {
+        return WORKBENCH_VIEWS.map((View) => new View(this)).filter((view) => view.available());
+    }
+
+    view(id) {
+        return this.views().find((v) => v.id === id) ?? null;
+    }
+}

package/src/charting/diagrams/ArchimateDiagram.js

@@ -20,13 +20,13 @@ export class ArchimateDiagram extends Diagram {
         const { elements, relationships } = this.data;
         const options = this.options;
         const {
-            layerColors, relationshipStyles, defaultIcons, iconChoiceIndex = 0, elementWidth = 120, elementHeight = 55,
+            layerColors, elementColors, relationshipStyles, defaultIcons, iconChoiceIndex = 0, elementWidth = 120, elementHeight = 55,
             archimateVersion = '4', useDistinctShapes = false, iconSet = 'glyph',
             validate = true, invalidRelationships = 'highlight', onValidationWarning, annotations = [], viewpoint = null,
             viewpointMode = 'fade', customViewpoints = [], ...rest
         } = options;
         const nodeOpts = {
-            layerColors, defaultIcons, iconChoiceIndex, elementWidth, elementHeight,
+            layerColors, elementColors, defaultIcons, iconChoiceIndex, elementWidth, elementHeight,
             archimateVersion, useDistinctShapes, iconSet,
         };
         const nodes = elements.map(element => ArchimateDiagram.buildNode(element, nodeOpts));
@@ -79,6 +79,12 @@ export class ArchimateDiagram extends Diagram {
             annotation.shape = 'note';
             annotation.labelPosition = annotation.labelPosition || 'inside';
             annotation.resizable = annotation.resizable !== false;
+            if (annotation.reference || annotation.referencedModel || annotation.viewRef || annotation.isViewReference) {
+                annotation.isViewReference = true;
+                const refId = annotation.reference || annotation.referencedModel || annotation.viewRef;
+                annotation.referencedModel = refId;
+                annotation.tooltip = annotation.tooltip || `View: ${annotation.label || refId} (double-click to open)`;
+            }
             visibleNodes.push(annotation);
         }
 
@@ -117,7 +123,7 @@ export class ArchimateDiagram extends Diagram {
         // Diagram-wide ArchiMate settings survive a rerender so live icon-choice
         // changes can be applied later (see RenderEngine._archimateSetIconChoiceIndex).
         this.engine._archimateOptions = {
-            layerColors, defaultIcons, iconChoiceIndex, relationshipStyles, elementWidth, elementHeight,
+            layerColors, elementColors, defaultIcons, iconChoiceIndex, relationshipStyles, elementWidth, elementHeight,
             archimateVersion, useDistinctShapes, iconSet, viewpoint,
             viewpointMode, customViewpoints,
         };
@@ -195,15 +201,18 @@ export class ArchimateDiagram extends Diagram {
     }
 
     static buildNode(element, {
-        layerColors, defaultIcons, iconChoiceIndex = 0, elementWidth = 120, elementHeight = 55,
+        layerColors, elementColors, defaultIcons, iconChoiceIndex = 0, elementWidth = 120, elementHeight = 55,
         archimateVersion = '4', useDistinctShapes = false, iconSet = 'glyph',
     } = {}) {
         const resolved = archimateVersion === '4' ? ArchimateNotation.migrateElementToV4(element) : element;
         ArchimateSpecializationRegistry.applyToNode(resolved);
         const layer = ArchimateDiagram.elementLayer(resolved, archimateVersion);
         const type = ArchimateDiagram.resolveElementType(resolved.type, archimateVersion);
-        const useDistinctShape = resolved.useDistinctShape ?? useDistinctShapes;
-        const notationShape = useDistinctShape ? type?.notationShape : undefined;
+        const isOrJunction = resolved.type === 'or-junction'
+            || ((resolved.type === 'junction' || resolved.type === 'and-junction') && (resolved.junctionType === 'or' || resolved.attributes?.type === 'or' || resolved.archi?.attributes?.type === 'or'));
+        const isJunction = resolved.type === 'junction' || resolved.type === 'and-junction' || resolved.type === 'or-junction';
+        const useDistinctShape = isJunction ? true : (resolved.useDistinctShape ?? useDistinctShapes);
+        const notationShape = useDistinctShape ? (isJunction ? (isOrJunction ? 'junction-or' : 'junction') : type?.notationShape) : undefined;
         const glyphBadges = (resolved.iconSet ?? iconSet) !== 'emoji';
 
         // CRITICAL: Use diagramInstanceId (not elementId) as the node's unique ID
@@ -213,14 +222,21 @@ export class ArchimateDiagram extends Diagram {
         // icon, and a plain white fill unless it sets one (a note keeps its own default).
         const viewBox = resolved.viewObject && resolved.shape !== 'note';
 
+        const defaultW = isJunction ? 18 : elementWidth;
+        const defaultH = isJunction ? 18 : elementHeight;
+        const typeColor = elementColors?.[type?.name] ?? elementColors?.[resolved.type];
+        const defaultColor = typeColor || (isJunction
+            ? (isOrJunction ? '#ffffff' : '#000000')
+            : (viewBox ? '#ffffff' : ArchimateDiagram.layerColor(layer, layerColors, type?.ownColor)));
+
         return {
             ...resolved,
             id: nodeId,  // Override to use diagramInstanceId for uniqueness
             layer,
             shape: resolved.shape || notationShape || 'rect',
-            color: resolved.color || (viewBox ? '#ffffff' : ArchimateDiagram.layerColor(layer, layerColors, type?.ownColor)),
-            width: resolved.width ?? elementWidth,
-            height: resolved.height ?? elementHeight,
+            color: resolved.color || defaultColor,
+            width: resolved.width ?? defaultW,
+            height: resolved.height ?? defaultH,
             strokeColor: resolved.strokeColor || '#000000',
             strokeWidth: resolved.strokeWidth ?? 1.2,
             // The ArchiMate notation draws a Grouping with a dashed outline.