@peter.prib/renderengine 0.2.11 → 0.4.0

package/src/charting/{datamodel/DataModelEditCommand.js → model/ModelEditCommand.js}

@@ -1,47 +1,47 @@
-import { Command } from '../CommandHistory.js';
-
-/**
- * DataModelEditCommand — one edit of a DataModel (an entity, an attribute, a
- * relationship, a delete) as one undo step: run, it makes the change and keeps
- * the model as it was before and after (DataModel#toJSON); undone or redone, it
- * puts the model back as it was (DataModel#restore). Any change to a model is
- * undoable this way, whatever it touches.
- */
-export class DataModelEditCommand extends Command {
-    /** A model edit is no edit on one view: undoing it shows no other. */
-    viewId = null;
-
-    /**
-     * @param {DataModel} model
-     * @param {string} label - What the undo menu calls it ('Edit Customer')
-     * @param {(model: DataModel) => *} change - Makes the change
-     */
-    constructor(model, label, change) {
-        super(label);
-        this.model = model;
-        this.change = change;
-        this.before = null;
-        this.after = null;
-    }
-
-    execute() {
-        if (this.after) {
-            this.model.restore(this.after);
-        } else {
-            this.before = DataModelEditCommand.snapshot(this.model);
-            this.result = this.change(this.model);
-            this.after = DataModelEditCommand.snapshot(this.model);
-        }
-        this.model.edited();
-    }
-
-    undo() {
-        this.model.restore(this.before);
-        this.model.edited();
-    }
-
-    /** The model as it is, a copy nothing later changes (its toJSON shares some arrays). */
-    static snapshot(model) {
-        return JSON.parse(JSON.stringify(model.toJSON()));
-    }
-}
+import { Command } from '../CommandHistory.js';
+
+/**
+ * ModelEditCommand — one edit of an EditableModel (a data model's entity, a
+ * requirements model's story, a delete) as one undo step: run, it makes the
+ * change and keeps the model as it was before and after (its toJSON); undone
+ * or redone, it puts the model back as it was (its restore). Any change to a
+ * model is undoable this way, whatever it touches.
+ */
+export class ModelEditCommand extends Command {
+    /** A model edit is no edit on one view: undoing it shows no other. */
+    viewId = null;
+
+    /**
+     * @param {EditableModel} model
+     * @param {string} label - What the undo menu calls it ('Edit Customer')
+     * @param {(model: EditableModel) => *} change - Makes the change
+     */
+    constructor(model, label, change) {
+        super(label);
+        this.model = model;
+        this.change = change;
+        this.before = null;
+        this.after = null;
+    }
+
+    execute() {
+        if (this.after) {
+            this.model.restore(this.after);
+        } else {
+            this.before = ModelEditCommand.snapshot(this.model);
+            this.result = this.change(this.model);
+            this.after = ModelEditCommand.snapshot(this.model);
+        }
+        this.model.edited();
+    }
+
+    undo() {
+        this.model.restore(this.before);
+        this.model.edited();
+    }
+
+    /** The model as it is, a copy nothing later changes (its toJSON may share arrays). */
+    static snapshot(model) {
+        return JSON.parse(JSON.stringify(model.toJSON()));
+    }
+}

package/src/charting/requirements/RequirementsChecker.js

@@ -0,0 +1,76 @@
+import { ModelChecker } from '../ModelChecker.js';
+
+/**
+ * RequirementsChecker — what a requirements model is missing, as a team
+ * reviewing a backlog would say it: a story with no acceptance criteria
+ * (nothing to say when it is done), one that says neither who wants it nor
+ * what (no "As a … I want …"), one that traces to nothing (nothing realises
+ * it), one under no epic, an epic with no stories, two stories of one name.
+ *
+ * With `resolve(trace)` — the host's way to find what a trace names in its
+ * other models (true, false, or undefined when it cannot tell) — a trace to
+ * something that is not there is found too.
+ *
+ * Findings name a story or an epic (`kind`), as ModelChecker's do.
+ */
+export class RequirementsChecker extends ModelChecker {
+    /**
+     * @param {RequirementsModel} model
+     * @param {{resolve?: (trace: Object) => (boolean|undefined)}} [options]
+     */
+    constructor(model, { resolve = null } = {}) {
+        super(model);
+        this.resolve = resolve;
+    }
+
+    checks() {
+        return [this.noCriteria, this.noNarrative, this.untraced, this.brokenTraces, this.noEpic, this.emptyEpics, this.sameNames];
+    }
+
+    /** @private */
+    _story(story, code, severity, message) {
+        return { code, severity, kind: 'story', ids: [story.id], message };
+    }
+
+    noCriteria() {
+        return this.model.stories.filter(s => !s.criteria.length)
+            .map(s => this._story(s, 'story-no-criteria', 'warning', `"${s.name}" has no acceptance criteria: nothing says when it is done`));
+    }
+
+    noNarrative() {
+        return this.model.stories.filter(s => !s.want && !s.description)
+            .map(s => this._story(s, 'story-no-narrative', 'info', `"${s.name}" says neither who wants it nor what (As a … I want … so that …)`));
+    }
+
+    untraced() {
+        return this.model.stories.filter(s => !s.traces.length)
+            .map(s => this._story(s, 'story-untraced', 'info', `"${s.name}" traces to nothing that realises it`));
+    }
+
+    brokenTraces() {
+        if (!this.resolve) return [];
+        return this.model.stories.flatMap(s => s.traces.filter(t => this.resolve(t) === false)
+            .map(t => this._story(s, 'trace-missing', 'warning', `"${s.name}" traces to ${t.kind} "${t.name || t.ref}", which is not there`)));
+    }
+
+    noEpic() {
+        if (!this.model.epics.length) return [];
+        return this.model.stories.filter(s => !this.model.epic(s.epic))
+            .map(s => this._story(s, 'story-no-epic', 'info', `"${s.name}" is under no epic`));
+    }
+
+    emptyEpics() {
+        return this.model.epics.filter(e => !this.model.storiesOf(e.id).length)
+            .map(e => ({ code: 'epic-empty', severity: 'info', kind: 'epic', ids: [e.id], message: `Epic "${e.name}" has no stories` }));
+    }
+
+    sameNames() {
+        const byName = new Map();
+        for (const s of this.model.stories) {
+            const key = s.name.trim().toLowerCase();
+            if (key) byName.set(key, [...(byName.get(key) ?? []), s]);
+        }
+        return [...byName.values()].filter(list => list.length > 1)
+            .map(list => ({ code: 'story-duplicate', severity: 'warning', kind: 'story', ids: list.map(s => s.id), message: `${list.length} stories are called "${list[0].name}"` }));
+    }
+}

package/src/charting/requirements/RequirementsCompared.js

@@ -0,0 +1,33 @@
+import { ListCompared } from '../diagramModel/ListCompared.js';
+
+/**
+ * The kinds two RequirementsModels are compared on and merged by
+ * (ModelComparison): epics, releases, then stories, in the order a merge
+ * brings them — a story needs its epic and its release.
+ */
+
+export class EpicsCompared extends ListCompared {
+    get key() { return 'epic'; }
+    get label() { return 'Epics'; }
+    list(model) { return model.epics; }
+    content(epic) { return { ...epic }; }
+}
+
+export class ReleasesCompared extends ListCompared {
+    get key() { return 'release'; }
+    get label() { return 'Releases'; }
+    list(model) { return model.releases; }
+    content(release) { return { ...release }; }
+}
+
+/** Stories: compared on everything, where they sit in the list aside. */
+export class StoriesCompared extends ListCompared {
+    get key() { return 'story'; }
+    get label() { return 'Stories'; }
+    list(model) { return model.stories; }
+    content(story) { return JSON.parse(JSON.stringify(story)); }
+
+    requires(story) {
+        return [...(story.epic ? [['epic', story.epic]] : []), ...(story.release ? [['release', story.release]] : [])];
+    }
+}

package/src/charting/requirements/RequirementsFileFormat.js

@@ -0,0 +1,32 @@
+import { ModelFileFormat } from '../ModelFileFormat.js';
+import { RequirementsModel } from './RequirementsModel.js';
+
+/**
+ * RequirementsFileFormat — a requirements model as a file
+ * (`.requirements.json`): its epics, releases and stories
+ * (RequirementsModel#toJSON), read back by `new RequirementsModel(json)`.
+ */
+export class RequirementsFileFormat extends ModelFileFormat {
+    get label() { return '.requirements.json'; }
+    get accept() { return '.requirements.json,.json'; }
+    get fileName() { return 'model.requirements.json'; }
+    get featureName() { return 'Requirements'; }
+
+    /** JSON with a requirements model's shape: stories, or epics. */
+    recognizes(text) {
+        try {
+            const json = JSON.parse(text);
+            return !!json && typeof json === 'object' && (Array.isArray(json.stories) || Array.isArray(json.epics));
+        } catch {
+            return false;
+        }
+    }
+
+    export(model) {
+        return { data: JSON.stringify(model.toJSON(), null, 2), mimeType: 'application/json' };
+    }
+
+    import(text) {
+        return new RequirementsModel(JSON.parse(text));
+    }
+}

package/src/charting/requirements/RequirementsImportFormats.js

@@ -0,0 +1,48 @@
+import { ModelFileFormat } from '../ModelFileFormat.js';
+import { RequirementsModel } from './RequirementsModel.js';
+import { TrackerExport } from './TrackerExport.js';
+import { Storyboard } from './Storyboard.js';
+
+/**
+ * The files a requirements model is read from that another tool wrote — they
+ * import only: a tracker's export (TrackerExport: Jira, Azure DevOps,
+ * GitLab, CSV or JSON) and a storyboard (Storyboard: Markdown). Each reads
+ * the file as a new model; `spec(text)` is what it holds, for a part that
+ * brings it into the model open (RequirementsModel#bringCommand).
+ */
+class RequirementsImportFormat extends ModelFileFormat {
+    get exports() { return false; }
+
+    /** What the file holds, as a RequirementsModel spec. @abstract */
+    spec(text) { throw new Error(`${this.constructor.name} must implement spec()`); }
+
+    import(text) {
+        return new RequirementsModel(this.spec(text));
+    }
+}
+
+export class TrackerExportFileFormat extends RequirementsImportFormat {
+    get label() { return 'Tracker export (Jira, Azure DevOps, GitLab)'; }
+    get accept() { return '.csv,.json'; }
+    get featureName() { return 'TrackerExport'; }
+
+    /** A CSV or JSON export one of the trackers wrote. */
+    recognizes(text) {
+        return !!TrackerExport.detect(text);
+    }
+
+    spec(text) {
+        const { tracker, ...spec } = new TrackerExport().read(text);
+        return { name: `${TrackerExport.label(tracker)} export`, ...spec };
+    }
+}
+
+export class StoryboardFileFormat extends RequirementsImportFormat {
+    get label() { return 'Storyboard (Markdown)'; }
+    get accept() { return '.md,.markdown,.txt'; }
+    get featureName() { return 'Storyboard'; }
+
+    spec(text) {
+        return new Storyboard().read(text);
+    }
+}

package/src/charting/requirements/RequirementsModel.js

@@ -0,0 +1,305 @@
+import { EditableModel } from '../model/EditableModel.js';
+import { EpicsCompared, ReleasesCompared, StoriesCompared } from './RequirementsCompared.js';
+import { RequirementsChecker } from './RequirementsChecker.js';
+import { Benchmark } from '../model/Benchmark.js';
+
+/** A plain copy of JSON-shaped data. */
+const copy = (value) => JSON.parse(JSON.stringify(value));
+
+/**
+ * What a story can trace to, and what its trace is called: ArchiMate's
+ * motivation and implementation elements, any other element of an
+ * architecture, and a data model's concepts, entities and tables — so a trace
+ * runs epic → story → requirement → component → entity → table. A trace's
+ * `kind` is any string; these are the ones offered.
+ */
+const TRACE_KINDS = Object.freeze([
+    ['requirement', 'Requirement (ArchiMate)'],
+    ['work-package', 'Work package (ArchiMate)'],
+    ['element', 'Architecture element'],
+    ['concept', 'Data concept'],
+    ['entity', 'Data entity'],
+    ['table', 'Table'],
+]);
+
+/** Where a story is in its life, in order; a status is any string, these are offered. */
+const STATUSES = Object.freeze(['To do', 'In progress', 'Done']);
+
+/**
+ * RequirementsModel — what a system is to do, as an agile team writes it:
+ * **epics** (large outcomes), the **stories** that deliver them ("As a … I
+ * want … so that …"), each with its **acceptance criteria**, sliced into
+ * **releases**; and **traces** from a story to what realises it in the other
+ * models (TRACE_KINDS: an ArchiMate requirement or work package, an element,
+ * a data concept, entity or table — `{kind, ref, name?, model?}`, `ref` that
+ * model's id).
+ *
+ * Read as a **story map** (`storyMap()`): epics across in order, releases
+ * down, each cell the stories of that epic in that release; stories with no
+ * epic or no release have a column and a row of their own. `coverage()` and
+ * the checker (RequirementsChecker) say what is missing — a story with no
+ * acceptance criteria, nothing realising it — the numbers a bench measures.
+ *
+ * Spec (its toJSON): `{ name?, epics: [{id, name, description?}], releases:
+ * [{id, name}], stories: [{id, name, epic?, release?, as?, want?, soThat?,
+ * description?, criteria: [{id, text}], status?, priority?, points?, labels?,
+ * source?: {system, key, url?}, traces: [{kind, ref, name?, model?}]}] }`.
+ * Ids are made from names when not given. Every edit is a command (one undo
+ * step); compare and merge, and changed-since-saved, are EditableModel's.
+ */
+export class RequirementsModel extends EditableModel {
+    static STATE = Object.freeze(['name', 'epics', 'releases', 'stories']);
+
+    static TRACE_KINDS = TRACE_KINDS;
+
+    static STATUSES = STATUSES;
+
+    /** A story map's column for stories with no epic, and its row for those in no release. */
+    static NO_EPIC = '';
+    static NO_RELEASE = '';
+
+    constructor(spec = {}) {
+        super(spec);
+        this.epics = [];
+        this.releases = [];
+        this.stories = [];
+        for (const e of spec.epics ?? []) this.epics.push(this._epic(e));
+        for (const r of spec.releases ?? []) this.releases.push(this._release(r));
+        for (const s of spec.stories ?? []) this.stories.push(this._story(s));
+    }
+
+    // ===== Reading =====
+
+    epic(id) { return this.epics.find(e => e.id === id) ?? null; }
+    release(id) { return this.releases.find(r => r.id === id) ?? null; }
+    story(id) { return this.stories.find(s => s.id === id) ?? null; }
+
+    /** The stories of an epic (NO_EPIC: of none), in order; with `release`, only those in it (NO_RELEASE: in none). */
+    storiesOf(epicId, release) {
+        return this.stories.filter(s => (s.epic || '') === (epicId || '')
+            && (release === undefined || (s.release || '') === (release || '')));
+    }
+
+    /** The story's sentence: "As a … I want … so that …", from what it has. */
+    static narrative(story) {
+        return [story.as && `As ${/^(a|an|the)\b/i.test(story.as) ? '' : 'a '}${story.as}`, story.want && `I want ${story.want}`, story.soThat && `so that ${story.soThat}`]
+            .filter(Boolean).join(', ');
+    }
+
+    /**
+     * The story map: `columns` the epics in order (then NO_EPIC, if any story
+     * has none), `rows` the releases in order (then NO_RELEASE, if any story is
+     * in none, or there are no releases), and `cell(epicId, releaseId)` the
+     * stories there, in order.
+     */
+    storyMap() {
+        const columns = [...this.epics.map(e => ({ id: e.id, name: e.name, epic: e }))];
+        if (this.stories.some(s => !this.epic(s.epic))) columns.push({ id: RequirementsModel.NO_EPIC, name: 'No epic', epic: null });
+        const rows = this.releases.map(r => ({ id: r.id, name: r.name, release: r }));
+        if (!rows.length || this.stories.some(s => !this.release(s.release))) rows.push({ id: RequirementsModel.NO_RELEASE, name: this.releases.length ? 'Not planned' : 'Stories', release: null });
+        const epicOf = (s) => (this.epic(s.epic) ? s.epic : RequirementsModel.NO_EPIC);
+        const releaseOf = (s) => (this.release(s.release) ? s.release : RequirementsModel.NO_RELEASE);
+        return {
+            columns, rows,
+            cell: (epicId, releaseId) => this.stories.filter(s => epicOf(s) === epicId && releaseOf(s) === releaseId),
+        };
+    }
+
+    /** The stories that trace to `ref` (with `kind`, only traces of that kind): what a change to it touches. */
+    tracingTo(ref, kind) {
+        return this.stories.filter(s => s.traces.some(t => t.ref === ref && (!kind || t.kind === kind)));
+    }
+
+    /**
+     * How complete it is, as numbers to measure by: stories, how many have
+     * acceptance criteria, how many trace to something, epics with no stories,
+     * and each as a share (0..1; 1 with nothing to count).
+     */
+    coverage() {
+        const stories = this.stories.length;
+        const withCriteria = this.stories.filter(s => s.criteria.length).length;
+        const traced = this.stories.filter(s => s.traces.length).length;
+        const emptyEpics = this.epics.filter(e => !this.storiesOf(e.id).length).length;
+        const share = (n, of) => (of ? n / of : 1);
+        return {
+            stories, withCriteria, traced, epics: this.epics.length, emptyEpics,
+            criteriaShare: share(withCriteria, stories), traceShare: share(traced, stories),
+        };
+    }
+
+    /** What it is measured by (Benchmark): its check's findings, and how many stories say when they are done and trace to something. */
+    benchmark() {
+        const c = this.coverage();
+        return [
+            ...Benchmark.findings(this),
+            { key: 'criteria', label: 'Stories with acceptance criteria', value: c.criteriaShare, better: 'higher', format: 'share' },
+            { key: 'traced', label: 'Stories traced', value: c.traceShare, better: 'higher', format: 'share' },
+        ];
+    }
+
+    /** Its checks (RequirementsChecker). */
+    checker(options) {
+        return new RequirementsChecker(this, options);
+    }
+
+    comparedKinds() {
+        return [new EpicsCompared(), new ReleasesCompared(), new StoriesCompared()];
+    }
+
+    // ===== Editing (each an editCommand: one undo step) =====
+
+    /** Add an epic (`id` null) or change one. The command's result is the epic. */
+    saveEpicCommand(id, spec) {
+        return this.editCommand(id ? `Edit epic ${spec.name ?? id}` : `New epic ${spec.name ?? ''}`.trim(), (model) => {
+            if (!id) { const epic = model._epic(spec); model.epics.push(epic); return epic; }
+            const epic = model.epic(id);
+            if (epic) Object.assign(epic, model._epic({ ...epic, ...spec, id }));
+            return epic;
+        });
+    }
+
+    /** Remove an epic; its stories stay, with no epic. */
+    removeEpicCommand(id) {
+        return this.editCommand(`Remove epic ${this.epic(id)?.name ?? id}`, (model) => {
+            model.epics = model.epics.filter(e => e.id !== id);
+            for (const s of model.stories) if (s.epic === id) s.epic = '';
+        });
+    }
+
+    /** Add a release (`id` null) or rename one. */
+    saveReleaseCommand(id, spec) {
+        return this.editCommand(id ? `Edit release ${spec.name ?? id}` : `New release ${spec.name ?? ''}`.trim(), (model) => {
+            if (!id) { const release = model._release(spec); model.releases.push(release); return release; }
+            const release = model.release(id);
+            if (release) Object.assign(release, model._release({ ...release, ...spec, id }));
+            return release;
+        });
+    }
+
+    /** Remove a release; its stories stay, planned in none. */
+    removeReleaseCommand(id) {
+        return this.editCommand(`Remove release ${this.release(id)?.name ?? id}`, (model) => {
+            model.releases = model.releases.filter(r => r.id !== id);
+            for (const s of model.stories) if (s.release === id) s.release = '';
+        });
+    }
+
+    /** Add a story (`id` null) or change one — what the spec leaves out kept. The command's result is the story. */
+    saveStoryCommand(id, spec) {
+        return this.editCommand(id ? `Edit ${spec.name ?? this.story(id)?.name ?? id}` : `New story ${spec.name ?? ''}`.trim(), (model) => {
+            if (!id) { const story = model._story(spec); model.stories.push(story); return story; }
+            const at = model.stories.findIndex(s => s.id === id);
+            if (at < 0) return null;
+            model.stories[at] = model._story({ ...model.stories[at], ...spec, id });
+            return model.stories[at];
+        });
+    }
+
+    removeStoryCommand(id) {
+        return this.editCommand(`Remove ${this.story(id)?.name ?? id}`, (model) => {
+            model.stories = model.stories.filter(s => s.id !== id);
+        });
+    }
+
+    /**
+     * Move a story on the map: to an epic and a release (NO_EPIC, NO_RELEASE:
+     * none), before another story there (`before`; none: last).
+     */
+    moveStoryCommand(id, { epic, release, before = null }) {
+        return this.editCommand(`Move ${this.story(id)?.name ?? id}`, (model) => {
+            const story = model.story(id);
+            if (!story || before === id) return;
+            if (epic !== undefined) story.epic = epic || '';
+            if (release !== undefined) story.release = release || '';
+            model.stories.splice(model.stories.indexOf(story), 1);
+            const at = before ? model.stories.findIndex(s => s.id === before) : -1;
+            model.stories.splice(at < 0 ? model.stories.length : at, 0, story);
+        });
+    }
+
+    /** Trace a story to something that realises it (`{kind, ref, name?, model?}`); once per kind and ref. */
+    traceCommand(storyId, trace) {
+        return this.editCommand(`Trace ${this.story(storyId)?.name ?? storyId} to ${trace.name || trace.ref}`, (model) => {
+            const story = model.story(storyId);
+            if (!story || story.traces.some(t => t.kind === trace.kind && t.ref === trace.ref)) return;
+            story.traces.push(RequirementsModel._trace(trace));
+        });
+    }
+
+    /** Remove a story's trace to `ref` (of `kind`, if given). */
+    untraceCommand(storyId, ref, kind) {
+        return this.editCommand(`Remove the trace of ${this.story(storyId)?.name ?? storyId}`, (model) => {
+            const story = model.story(storyId);
+            if (story) story.traces = story.traces.filter(t => !(t.ref === ref && (!kind || t.kind === kind)));
+        });
+    }
+
+    /**
+     * Bring epics, releases and stories in (an import): one undo step. One with
+     * the id of one there replaces it; the rest are added.
+     */
+    bringCommand({ epics = [], releases = [], stories = [] }, label = 'Import') {
+        return this.editCommand(label, (model) => {
+            const put = (list, item) => {
+                const at = list.findIndex(x => x.id === item.id);
+                if (at < 0) list.push(item); else list[at] = item;
+            };
+            for (const e of epics) put(model.epics, model._epic(e));
+            for (const r of releases) put(model.releases, model._release(r));
+            for (const s of stories) put(model.stories, model._story(s));
+        });
+    }
+
+    // ===== Its parts, read from a spec =====
+
+    /** @private */
+    _epic({ id, name = '', description = '', source } = {}) {
+        return {
+            id: id ?? this._freshId(name || 'epic', this.epics), name, description,
+            ...(source && { source: copy(source) }),
+        };
+    }
+
+    /** @private */
+    _release({ id, name = '' } = {}) {
+        return { id: id ?? this._freshId(name || 'release', this.releases), name };
+    }
+
+    /** @private */
+    _story(spec = {}) {
+        const { id, name = '', epic = '', release = '', as = '', want = '', soThat = '', description = '', status = '', priority = '', points = null, labels = [], source, criteria = [], traces = [] } = spec;
+        const story = {
+            id: id ?? this._freshId(name || 'story', this.stories), name, epic: epic ?? '', release: release ?? '',
+            as, want, soThat, description, status, priority,
+            points: Number.isFinite(Number(points)) && points !== null && points !== '' ? Number(points) : null,
+            labels: [...labels],
+            criteria: [],
+            traces: traces.map(t => RequirementsModel._trace(t)),
+            ...(source && { source: copy(source) }),
+        };
+        // A new criterion is numbered past every id the story's criteria have, so none is given twice.
+        const given = new Set(criteria.map(c => (typeof c === 'object' && c?.id) || null).filter(Boolean));
+        let n = 0;
+        const fresh = () => { let id; do id = `${story.id}-ac${++n}`; while (given.has(id)); given.add(id); return id; };
+        for (const c of criteria) {
+            const text = typeof c === 'string' ? c : c?.text;
+            if (!String(text ?? '').trim()) continue;
+            story.criteria.push({ id: (typeof c === 'object' && c.id) || fresh(), text: String(text).trim() });
+        }
+        return story;
+    }
+
+    /** @private */
+    static _trace({ kind = 'element', ref, name = '', model = '' } = {}) {
+        return { kind, ref: String(ref ?? ''), ...(name && { name }), ...(model && { model }) };
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            epics: copy(this.epics),
+            releases: copy(this.releases),
+            stories: copy(this.stories),
+        };
+    }
+}