@peter.prib/renderengine 0.2.5 → 0.2.7

package/src/charting/datamodel/DataModelChecker.js

@@ -0,0 +1,92 @@
+import { ModelChecker } from '../ModelChecker.js';
+import { BianNotation } from '../../bian.js';
+
+/**
+ * DataModelChecker — checks over a DataModel (a ModelChecker): each business
+ * object (a logical entity) owned by one service domain, as BIAN has it
+ * (none, once there are service domains, is worth a look; more than one is
+ * wrong); service domains complete (a control record, qualifiers that are
+ * entities, a pattern BIAN has); mappings joining entities that are there;
+ * data types sound (an enumeration with values, each once; one name a type)
+ * and used. Each finding names what it is about (`kind`: 'entity',
+ * 'perspective', 'mapping', 'data-type') and, for an entity, its `level`.
+ */
+export class DataModelChecker extends ModelChecker {
+    checks() {
+        return [this.ownedTwice, this.unowned, this.serviceDomains, this.mappings, this.dataTypes];
+    }
+
+    /** The service domains (perspectives that own business objects). @private */
+    _owners() {
+        return this.model.perspectives.filter(p => p.ownedEntities().length);
+    }
+
+    /** A business object owned by more than one service domain. */
+    ownedTwice() {
+        return this.model.level('logical').entities
+            .map(e => [e, this.model.ownersOf(e.id)])
+            .filter(([, owners]) => owners.length > 1)
+            .map(([e, owners]) => ({
+                code: 'owned-twice', severity: 'warning', kind: 'entity', level: 'logical', ids: [e.id],
+                message: `"${e.name}" is owned by ${owners.length} service domains (${owners.map(o => o.name).join(', ')}); BIAN gives a business object one`,
+            }));
+    }
+
+    /** A business object no service domain owns, once some own business objects. */
+    unowned() {
+        if (!this._owners().length) return [];
+        return this.model.level('logical').entities
+            .filter(e => !this.model.ownersOf(e.id).length)
+            .map(e => ({
+                code: 'unowned', severity: 'info', kind: 'entity', level: 'logical', ids: [e.id],
+                message: `"${e.name}" is owned by no service domain`,
+            }));
+    }
+
+    /** A service domain with no control record, a pattern BIAN lacks, or a qualifier that is no entity. */
+    serviceDomains() {
+        const logical = this.model.level('logical');
+        return this._serviceDomains().flatMap(sd => [
+            ...(!sd.controlRecord ? [{ code: 'no-control-record', severity: 'warning', message: `Service domain "${sd.name}" has no control record` }]
+                : !logical.entity(sd.controlRecord) ? [{ code: 'control-record-missing', severity: 'warning', message: `Service domain "${sd.name}": its control record "${sd.controlRecord}" is no logical entity` }]
+                    : []),
+            ...(!BianNotation.functionalPattern(sd.pattern) ? [{ code: 'unknown-pattern', severity: 'warning', message: `Service domain "${sd.name}": "${sd.pattern}" is no BIAN functional pattern` }] : []),
+            ...sd.qualifiers.filter(q => !q.entity || !logical.entity(q.entity)).map(q => ({
+                code: 'qualifier-entity-missing', severity: 'info', message: `Service domain "${sd.name}": behaviour qualifier "${q.name}" is no logical entity`,
+            })),
+        ].map(f => ({ ...f, kind: 'perspective', ids: [sd.id] })));
+    }
+
+    /** The service domains among the perspectives. @private */
+    _serviceDomains() {
+        return this.model.perspectives.filter(p => p.constructor.kind === 'service-domain');
+    }
+
+    /** An enumeration with no values or a value twice, two data types of one name, a data type nothing uses. */
+    dataTypes() {
+        const types = this.model.dataTypes;
+        const finding = (t, code, severity, message) => ({ code, severity, kind: 'data-type', ids: [t.id], message });
+        return types.flatMap(t => {
+            const values = (t.values ?? []).map(v => v.name);
+            const twice = [...new Set(values.filter((v, i) => values.indexOf(v) !== i))];
+            const sameName = types.filter(o => o !== t && o.name.toLowerCase() === t.name.toLowerCase());
+            const { attributes, types: users } = this.model.usesOf(t.id);
+            return [
+                ...(t.values && !values.length ? [finding(t, 'enumeration-empty', 'warning', `Enumeration "${t.name}" has no values`)] : []),
+                ...(twice.length ? [finding(t, 'value-twice', 'warning', `Enumeration "${t.name}" has ${twice.map(v => `"${v}"`).join(', ')} more than once`)] : []),
+                ...(sameName.length && types.indexOf(t) < types.indexOf(sameName[0]) ? [finding(t, 'type-name-twice', 'warning', `${sameName.length + 1} data types are called "${t.name}": an attribute naming it gets the first`)] : []),
+                ...(!attributes.length && !users.length ? [finding(t, 'type-unused', 'info', `Data type "${t.name}" is used by no attribute or other data type`)] : []),
+            ];
+        });
+    }
+
+    /** A mapping pair joining an entity that is not there. */
+    mappings() {
+        return this.model.mappings.flatMap(m => m.pairs
+            .filter(([a, b]) => !this.model.level(m.from).entity(a) || !this.model.level(m.to).entity(b))
+            .map(([a, b]) => ({
+                code: 'mapping-dangling', severity: 'warning', kind: 'mapping', ids: [`${m.from}:${a}->${m.to}:${b}`],
+                message: `A mapping from ${m.from} "${a}" to ${m.to} "${b}" joins an entity that is not there`,
+            })));
+    }
+}

package/src/charting/datamodel/DataModelCompared.js

@@ -0,0 +1,127 @@
+import { ComparedKind } from '../diagramModel/ComparedKind.js';
+
+/** A plain copy of JSON-shaped data. */
+const copy = (value) => (value === undefined ? undefined : JSON.parse(JSON.stringify(value)));
+
+/**
+ * The kinds two DataModels are compared on and merged by (ModelComparison,
+ * as for ArchiMate models): each level's entities and relationships, the
+ * mappings between levels, contexts and perspectives, in the order a merge
+ * brings them (what is needed first). Where a box sits is layout, not content:
+ * two models alike but for where their boxes are, are alike.
+ */
+
+/** A list of a model's held in an array (`list(model)`), each by an id; bring puts a copy in place or adds it. */
+class ListCompared extends ComparedKind {
+    constructor() {
+        super();
+        if (new.target === ListCompared) throw new TypeError('ListCompared is abstract — subclass it');
+    }
+
+    /** The array the model holds them in. @abstract */
+    list(model) { throw new Error(`${this.constructor.name} must implement list()`); }
+
+    items(model) { return this.list(model); }
+    get(model, id) { return this.items(model).find(item => this.idOf(item) === id) ?? null; }
+
+    /** Put a copy of `item` at its place (in place of the one with its id, else last); undone, as it was. */
+    bring(model, item) {
+        const list = this.list(model);
+        const twin = this.copyOf(item);
+        const at = list.findIndex(x => this.idOf(x) === this.idOf(item));
+        if (at < 0) {
+            list.push(twin);
+            return () => { const i = list.indexOf(twin); if (i >= 0) list.splice(i, 1); };
+        }
+        const old = list[at];
+        list[at] = twin;
+        return () => { const i = list.indexOf(twin); if (i >= 0) list[i] = old; };
+    }
+
+    /** A copy to put in the other model. */
+    copyOf(item) { return copy(item); }
+}
+
+/** One level's entities: compared on all but where they are drawn. */
+export class LevelEntitiesCompared extends ListCompared {
+    constructor(level) {
+        super();
+        this.level = level;
+    }
+
+    get key() { return `${this.level}-entity`; }
+    get label() { return `${this.level.charAt(0).toUpperCase()}${this.level.slice(1)} entities`; }
+    list(model) { return model.level(this.level).entities; }
+
+    content(entity) {
+        const { x, y, ...rest } = entity;
+        return copy(rest);
+    }
+}
+
+/**
+ * One level's relationships: known by their id, else by their ends and name
+ * (a relationship often has no id); each needs its two ends at that level.
+ */
+export class LevelRelationshipsCompared extends ListCompared {
+    constructor(level) {
+        super();
+        this.level = level;
+    }
+
+    get key() { return `${this.level}-relationship`; }
+    get label() { return `${this.level.charAt(0).toUpperCase()}${this.level.slice(1)} relationships`; }
+    list(model) { return model.level(this.level).relationships; }
+    idOf(r) { return r.id ?? `${r.source}->${r.target}${r.name ? `:${r.name}` : ''}`; }
+    nameOf(r) { return `${r.source} ${r.name || '→'} ${r.target}`; }
+    content(r) { return copy(r); }
+    requires(r) { return [[`${this.level}-entity`, r.source], [`${this.level}-entity`, r.target]]; }
+}
+
+/** The mappings between levels, a pair each: a pair needs its two entities. */
+export class MappingsCompared extends ComparedKind {
+    get key() { return 'mapping'; }
+    get label() { return 'Mappings'; }
+
+    items(model) {
+        return model.mappings.flatMap(m => m.pairs.map(([a, b]) => ({ id: `${m.from}:${a}->${m.to}:${b}`, from: m.from, to: m.to, a, b })));
+    }
+
+    nameOf(p) { return `${p.a} → ${p.b} (${p.from} to ${p.to})`; }
+    content() { return {}; }
+    requires(p) { return [[`${p.from}-entity`, p.a], [`${p.to}-entity`, p.b]]; }
+
+    bring(model, p) {
+        const mapping = model.mapping(p.from, p.to);
+        if (mapping.pairs.some(([a, b]) => a === p.a && b === p.b)) return () => {};
+        mapping.add(p.a, p.b);
+        return () => { mapping.pairs = mapping.pairs.filter(([a, b]) => !(a === p.a && b === p.b)); };
+    }
+}
+
+/** Perspectives and contexts are classes; their JSON is what counts, and a copy is one made from it. */
+class ModelPartsCompared extends ListCompared {
+    content(item) { return copy(item.toJSON()); }
+    copyOf(item) { return new item.constructor(copy(item.toJSON())); }
+}
+
+export class ContextsCompared extends ModelPartsCompared {
+    get key() { return 'context'; }
+    get label() { return 'Contexts'; }
+    list(model) { return model.contexts; }
+}
+
+/** Data types: an attribute names one by its id or name; a structure's fields others. */
+export class DataTypesCompared extends ModelPartsCompared {
+    get key() { return 'data-type'; }
+    get label() { return 'Data types'; }
+    list(model) { return model.dataTypes; }
+}
+
+/** A perspective needs the context it is read in. */
+export class PerspectivesCompared extends ModelPartsCompared {
+    get key() { return 'perspective'; }
+    get label() { return 'Perspectives'; }
+    list(model) { return model.perspectives; }
+    requires(p) { return p.context ? [['context', p.context]] : []; }
+}

package/src/charting/datamodel/DataModelContext.js

@@ -0,0 +1,108 @@
+/**
+ * DataModelContext — the semantic environment a data model is read in: what
+ * its entities mean here (`meanings`, by entity id: "Account" in banking is
+ * not "Account" in a CRM), the rules that hold here (`constraints`, each on
+ * some entities), and where and when that applies (`jurisdiction`,
+ * `validFrom`, `validTo`). The schema stays as it is; a context gives it
+ * meaning, scope and constraints.
+ */
+export class DataModelContext {
+    /**
+     * @param {Object} spec
+     * @param {string} spec.id
+     * @param {string} [spec.name]
+     * @param {string} [spec.description]
+     * @param {Object<string, string>} [spec.meanings] - What an entity means here, by entity id
+     * @param {Array<{id?: string, text: string, applies?: string[], x?: number, y?: number}>} [spec.constraints]
+     *   Rules that hold here, each on the entities it `applies` to (drawn as notes attached to them)
+     * @param {string} [spec.jurisdiction]
+     * @param {string} [spec.validFrom] - ISO date
+     * @param {string} [spec.validTo] - ISO date
+     */
+    constructor({ id, name = id, description = '', meanings = {}, constraints = [], jurisdiction = '', validFrom = '', validTo = '' } = {}) {
+        if (!id) throw new TypeError('DataModelContext must have an id');
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.meanings = { ...meanings };
+        this.constraints = constraints.map((c, i) => ({ ...c, id: c.id ?? `${id}-rule-${i + 1}`, applies: [...(c.applies ?? [])] }));
+        this.jurisdiction = jurisdiction;
+        this.validFrom = validFrom;
+        this.validTo = validTo;
+    }
+
+    /** What an entity means here, or null (then its schema description holds). */
+    meaningOf(entityId) {
+        return this.meanings[entityId] ?? null;
+    }
+
+    /** The rules that hold here on an entity. */
+    constraintsOn(entityId) {
+        return this.constraints.filter(c => c.applies.includes(entityId));
+    }
+
+    /** Where and when this context applies, in a few words ('AU · from 2024-07-01'), or ''. */
+    get scope() {
+        const when = this.validFrom && this.validTo ? `${this.validFrom} – ${this.validTo}`
+            : this.validFrom ? `from ${this.validFrom}`
+                : this.validTo ? `until ${this.validTo}` : '';
+        return [this.jurisdiction, when].filter(Boolean).join(' · ');
+    }
+
+    /**
+     * The fields of a dialog making or changing a context of `model`
+     * (FormDialog fields): its name, description, jurisdiction and dates, what
+     * each concept means in it, and its rules, one a line: the rule, then
+     * after '|' the concepts it applies to.
+     * @param {DataModel} model
+     * @param {DataModelContext|null} [context] - The one changed; none for a new one
+     */
+    static fields(model, context = null) {
+        const concepts = model.concepts;
+        const nameOf = (id) => model.level('conceptual').entity(id)?.name ?? id;
+        return [
+            { key: 'name', label: 'Name', type: 'text', value: context?.name ?? '' },
+            { key: 'description', label: 'Description', type: 'textarea', rows: 2, value: context?.description ?? '' },
+            { key: 'jurisdiction', label: 'Jurisdiction', type: 'text', value: context?.jurisdiction ?? '' },
+            { key: 'validFrom', label: 'Valid from', type: 'date', value: context?.validFrom ?? '' },
+            { key: 'validTo', label: 'Valid to', type: 'date', value: context?.validTo ?? '' },
+            { type: 'heading', label: 'Means here' },
+            ...concepts.map(c => ({ key: `meaning:${c.id}`, label: c.name, type: 'textarea', rows: 2, value: context?.meanings[c.id] ?? '', placeholder: 'as the schema describes it' })),
+            { type: 'heading', label: 'Rules' },
+            {
+                key: 'rules', label: '', type: 'textarea', rows: 5,
+                value: (context?.constraints ?? []).map(c => `${c.text} | ${c.applies.map(nameOf).join(', ')}`).join('\n'),
+                hint: 'One a line: the rule | the concepts it applies to (by name)',
+            },
+        ];
+    }
+
+    /**
+     * A context's spec from those fields' values. A rule kept from `context`
+     * (the same text) keeps its id and place; a concept is named by name or id.
+     */
+    static specFrom(values, model, context = null) {
+        const concepts = model.concepts;
+        const conceptOf = (word) => concepts.find(c => c.id === word || c.name.toLowerCase() === word.toLowerCase())?.id ?? null;
+        const meanings = Object.fromEntries(concepts.map(c => [c.id, (values[`meaning:${c.id}`] ?? '').trim()]).filter(([, text]) => text));
+        const constraints = String(values.rules ?? '').split('\n').map(line => line.trim()).filter(Boolean).map(line => {
+            const [text, on = ''] = line.split('|').map(part => part.trim());
+            const applies = on.split(',').map(w => w.trim()).filter(Boolean).map(conceptOf).filter(Boolean);
+            const kept = context?.constraints.find(c => c.text === text);
+            return { text, applies, ...(kept && { id: kept.id, ...(Number.isFinite(kept.x) && { x: kept.x, y: kept.y }) }) };
+        });
+        return {
+            name: (values.name ?? '').trim(), description: (values.description ?? '').trim(),
+            jurisdiction: (values.jurisdiction ?? '').trim(), validFrom: values.validFrom ?? '', validTo: values.validTo ?? '',
+            meanings, constraints,
+        };
+    }
+
+    toJSON() {
+        return {
+            id: this.id, name: this.name, description: this.description, meanings: { ...this.meanings },
+            constraints: this.constraints.map(c => ({ ...c, applies: [...c.applies] })),
+            jurisdiction: this.jurisdiction, validFrom: this.validFrom, validTo: this.validTo,
+        };
+    }
+}

package/src/charting/datamodel/DataModelFileFormat.js

@@ -0,0 +1,33 @@
+import { ModelFileFormat } from '../ModelFileFormat.js';
+import { DataModel } from './DataModel.js';
+
+/**
+ * DataModelFileFormat — a data model as a file (`.datamodel.json`): its name,
+ * its levels, the mappings between them, where its boxes and notes are, and
+ * its perspectives and contexts (DataModel#toJSON), read back by `new
+ * DataModel(json)`. The older one-entity form reads too.
+ */
+export class DataModelFileFormat extends ModelFileFormat {
+    get label() { return '.datamodel.json'; }
+    get accept() { return '.datamodel.json,.json'; }
+    get fileName() { return 'model.datamodel.json'; }
+    get featureName() { return 'DataModel'; }
+
+    /** JSON with a data model's shape: levels, or the older entities. */
+    recognizes(text) {
+        try {
+            const json = JSON.parse(text);
+            return !!json && typeof json === 'object' && (!!json.levels || Array.isArray(json.entities));
+        } catch {
+            return false;
+        }
+    }
+
+    export(model) {
+        return { data: JSON.stringify(model.toJSON(), null, 2), mimeType: 'application/json' };
+    }
+
+    import(text) {
+        return new DataModel(JSON.parse(text));
+    }
+}

package/src/charting/datamodel/DataModelPerspective.js

@@ -0,0 +1,129 @@
+/**
+ * DataModelPerspective — how one stakeholder sees a data model: a lens on the
+ * schema, not another schema. It shows some of the entities (`entities`; all
+ * when unset) under the names that stakeholder uses (`names`: Party is the
+ * Customer, Ledger the Billing), with relationships renamed too
+ * (`relationshipNames`, by relationship id), and names the context it is
+ * usually read in (`context`, a DataModelContext id).
+ *
+ * A kind of perspective that says more (a BIAN ServiceDomain) is a subclass,
+ * registered by its `kind` (`DataModelPerspective.register`); a spec's `kind`
+ * makes one of it (`DataModelPerspective.from`). What it adds to a view, the view
+ * asks it: entities it shows besides (`alsoShows`), how an entity is marked
+ * (`decorate`), notes (`notes`). The plain perspective adds none.
+ */
+export class DataModelPerspective {
+    /** What this kind of perspective is called in a spec (`kind`) and in menus. */
+    static kind = 'perspective';
+    static kindLabel = 'Perspective';
+
+    /** Perspective classes by kind. */
+    static KINDS = new Map();
+
+    /** Make a kind of perspective known, so a spec of its `kind` makes one. */
+    static register(PerspectiveClass) {
+        DataModelPerspective.KINDS.set(PerspectiveClass.kind, PerspectiveClass);
+    }
+
+    /** A perspective from a spec, of the class its `kind` names (a plain one without). */
+    static from(spec) {
+        const Kind = DataModelPerspective.KINDS.get(spec?.kind) ?? DataModelPerspective;
+        return new Kind(spec);
+    }
+
+    /**
+     * @param {Object} spec
+     * @param {string} spec.id
+     * @param {string} [spec.name]
+     * @param {string} [spec.description]
+     * @param {string[]|null} [spec.entities] - The entity ids it shows; null: every one
+     * @param {Object<string, string>} [spec.names] - An entity's name here, by entity id
+     * @param {Object<string, string>} [spec.relationshipNames] - A relationship's name here, by relationship id
+     * @param {string|null} [spec.context] - The context it is read in by default
+     */
+    constructor({ id, name = id, description = '', entities = null, names = {}, relationshipNames = {}, context = null } = {}) {
+        if (!id) throw new TypeError('DataModelPerspective must have an id');
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.entities = entities ? [...entities] : null;
+        this.names = { ...names };
+        this.relationshipNames = { ...relationshipNames };
+        this.context = context;
+    }
+
+    /** Whether it shows an entity. */
+    shows(entityId) {
+        return !this.entities || this.entities.includes(entityId);
+    }
+
+    /** What an entity is called here: its name in this perspective, else the schema's. */
+    nameOf(entity) {
+        return this.names[entity.id] ?? entity.name;
+    }
+
+    /** Entities at a level this perspective shows besides what realises its concepts (none here). */
+    alsoShows(level) {
+        return [];
+    }
+
+    /** How an entity it shows is marked at a level: `{ color?, details? }` (nothing here). */
+    decorate(entity, level) {
+        return {};
+    }
+
+    /** The business objects (logical entities) it owns, as a BIAN service domain does (none here). */
+    ownedEntities() {
+        return [];
+    }
+
+    /** Notes it adds at a level: `[{ id, text, attachTo }]` (none here). */
+    notes(level) {
+        return [];
+    }
+
+    /** What a relationship is called here. */
+    relationshipNameOf(relationship) {
+        return (relationship.id && this.relationshipNames[relationship.id]) ?? relationship.name;
+    }
+
+    /**
+     * The fields of a dialog making or changing a perspective of `model`
+     * (FormDialog fields): its name, description, the context it is read in,
+     * the concepts it shows, and what it calls each.
+     * @param {DataModel} model
+     * @param {DataModelPerspective|null} [perspective] - The one changed; none for a new one
+     */
+    static fields(model, perspective = null) {
+        const concepts = model.concepts;
+        return [
+            { key: 'name', label: 'Name', type: 'text', value: perspective?.name ?? '' },
+            { key: 'description', label: 'Whose view', type: 'textarea', rows: 2, value: perspective?.description ?? '' },
+            { key: 'context', label: 'Read in', type: 'select', value: perspective?.context ?? '', choices: [['', 'No context'], ...model.contexts.map(c => [c.id, c.name])] },
+            { type: 'heading', label: 'Shows' },
+            { key: 'entities', label: '', type: 'checklist', value: perspective?.entities ?? concepts.map(c => c.id), choices: concepts.map(c => [c.id, c.name]) },
+            { type: 'heading', label: 'Called here' },
+            ...concepts.map(c => ({ key: `name:${c.id}`, label: c.name, type: 'text', value: perspective?.names[c.id] ?? '', placeholder: 'as in the schema' })),
+        ];
+    }
+
+    /** A perspective's spec from those fields' values (all shown: `entities` null; names left blank: none). */
+    static specFrom(values, model) {
+        const ids = model.concepts.map(c => c.id);
+        const shown = values.entities ?? ids;
+        const names = Object.fromEntries(ids.map(id => [id, (values[`name:${id}`] ?? '').trim()]).filter(([, name]) => name));
+        return {
+            name: (values.name ?? '').trim(), description: (values.description ?? '').trim(), context: values.context || null,
+            entities: shown.length === ids.length ? null : [...shown], names,
+        };
+    }
+
+    toJSON() {
+        return {
+            ...(this.constructor.kind !== DataModelPerspective.kind && { kind: this.constructor.kind }),
+            id: this.id, name: this.name, description: this.description,
+            entities: this.entities ? [...this.entities] : null,
+            names: { ...this.names }, relationshipNames: { ...this.relationshipNames }, context: this.context,
+        };
+    }
+}

package/src/charting/datamodel/DataType.js

@@ -0,0 +1,108 @@
+/** Where the ISO 20022 standards repository describes a type, by its name. */
+const ISO20022_TYPE_URL = 'https://www.iso20022.org/standardsrepository/type/';
+
+/**
+ * DataType — a type an attribute can have, defined once in the model and named
+ * by the attributes of that type (`attribute.type` its id or name): what BIAN
+ * publishes as its data types and DAMA-DMBOK2 calls a domain. This base is a
+ * plain named type (a text, a value, a date, perhaps based on another:
+ * `basedOn`); EnumerationType and StructuredType add their values and fields.
+ * A type may say which ISO 20022 type it is (`iso20022`, linked by
+ * `iso20022Url`). Kinds register as perspective kinds do (`kind` in a spec).
+ */
+export class DataType {
+    /** What this kind is called in a spec (`kind`) and in menus. */
+    static kind = 'type';
+    static kindLabel = 'Type';
+
+    /** DataType classes by kind. */
+    static KINDS = new Map();
+
+    /** Make a kind of data type known, so a spec of its `kind` makes one. */
+    static register(TypeClass) {
+        DataType.KINDS.set(TypeClass.kind, TypeClass);
+    }
+
+    /** A data type from a spec, of the class its `kind` names (a plain one without). */
+    static from(spec) {
+        const Kind = DataType.KINDS.get(spec?.kind) ?? DataType;
+        return new Kind(spec);
+    }
+
+    /** Where the ISO 20022 standards repository describes a type (its name), or null. */
+    static iso20022Url(name) {
+        return name ? `${ISO20022_TYPE_URL}${encodeURIComponent(name)}` : null;
+    }
+
+    /**
+     * @param {Object} spec
+     * @param {string} spec.id
+     * @param {string} [spec.name] - Its id when unset
+     * @param {string} [spec.description]
+     * @param {string} [spec.basedOn] - The type it narrows ('Text', 'Decimal', another's id)
+     * @param {string} [spec.iso20022] - The ISO 20022 type it is ('CurrencyCode')
+     */
+    constructor({ id, name = id, description = '', basedOn = '', iso20022 = '' } = {}) {
+        if (!id) throw new TypeError('DataType must have an id');
+        Object.assign(this, { id, name, description, basedOn, iso20022 });
+    }
+
+    /** Its ISO 20022 type's page, or null. */
+    get iso20022Url() {
+        return DataType.iso20022Url(this.iso20022);
+    }
+
+    /** What it is in a few words, for a hover: its kind, and what it holds. */
+    summary() {
+        return this.basedOn ? `${this.name} (${this.basedOn})` : this.name;
+    }
+
+    /** Its rows when drawn as a box: `[{ name, type? }]` (none for a plain type). */
+    rows() {
+        return [];
+    }
+
+    /** The other data types it names (by id or name), as a structure's fields do (none here). */
+    uses() {
+        return this.basedOn ? [this.basedOn] : [];
+    }
+
+    toJSON() {
+        return {
+            ...(this.constructor !== DataType && { kind: this.constructor.kind }),
+            id: this.id, name: this.name,
+            ...(this.description && { description: this.description }),
+            ...(this.basedOn && { basedOn: this.basedOn }),
+            ...(this.iso20022 && { iso20022: this.iso20022 }),
+        };
+    }
+
+    /** Its dialog's fields: name, description, what it is based on, its ISO 20022 type. */
+    static fields(model, type = null) {
+        return [
+            { key: 'name', label: 'Name', type: 'text', value: type?.name ?? '' },
+            { key: 'description', label: 'Description', type: 'textarea', rows: 2, value: type?.description ?? '' },
+            { key: 'basedOn', label: 'Based on', type: 'text', value: type?.basedOn ?? '', placeholder: 'Text, Decimal, Date… or another data type' },
+            { key: 'iso20022', label: 'ISO 20022 type', type: 'text', value: type?.iso20022 ?? '', placeholder: 'e.g. CurrencyCode' },
+        ];
+    }
+
+    /** A spec from those fields. */
+    static specFrom(values) {
+        return {
+            ...(this !== DataType && { kind: this.kind }),
+            name: String(values.name ?? '').trim(),
+            description: String(values.description ?? '').trim(),
+            basedOn: String(values.basedOn ?? '').trim(),
+            iso20022: String(values.iso20022 ?? '').trim(),
+        };
+    }
+
+    /** Lines `name | more` from a textarea, each split on its first bar. @protected */
+    static lines(text) {
+        return String(text ?? '').split('\n').map(l => l.trim()).filter(Boolean).map(line => {
+            const bar = line.indexOf('|');
+            return bar < 0 ? [line, ''] : [line.slice(0, bar).trim(), line.slice(bar + 1).trim()];
+        });
+    }
+}

package/src/charting/datamodel/EnumerationType.js

@@ -0,0 +1,51 @@
+import { DataType } from './DataType.js';
+
+/**
+ * EnumerationType — a data type whose values are a fixed list, each perhaps
+ * with what it means (BIAN's `…typevalues`, a code list): `values` as
+ * `[{ name, description? }]`. Drawn as a box with a row per value.
+ */
+export class EnumerationType extends DataType {
+    static kind = 'enumeration';
+    static kindLabel = 'Enumeration';
+
+    /** @param {Object} spec - As DataType, plus `values: [{ name, description? }]` (or plain names) */
+    constructor({ values = [], ...spec } = {}) {
+        super(spec);
+        this.values = values.map(v => (typeof v === 'object' && v ? { name: String(v.name), ...(v.description && { description: v.description }) } : { name: String(v) }));
+    }
+
+    summary() {
+        const shown = this.values.slice(0, 6).map(v => v.name).join(', ');
+        return `${this.name}: one of ${shown}${this.values.length > 6 ? `, … (${this.values.length})` : ''}`;
+    }
+
+    rows() {
+        return this.values.map(v => ({ name: v.name }));
+    }
+
+    toJSON() {
+        return { ...super.toJSON(), values: this.values.map(v => ({ ...v })) };
+    }
+
+    /** A plain type's fields, then its values a line each: `name | what it means`. */
+    static fields(model, type = null) {
+        return [
+            ...DataType.fields(model, type),
+            {
+                key: 'values', label: 'Values', type: 'textarea', rows: 6,
+                value: (type?.values ?? []).map(v => (v.description ? `${v.name} | ${v.description}` : v.name)).join('\n'),
+                hint: 'One a line: value | what it means (optional)',
+            },
+        ];
+    }
+
+    static specFrom(values) {
+        return {
+            ...super.specFrom(values),
+            values: DataType.lines(values.values).map(([name, description]) => ({ name, ...(description && { description }) })),
+        };
+    }
+}
+
+DataType.register(EnumerationType);