@peter.prib/renderengine 0.0.0-stage → 0.2.0

package/src/charting/DataFilter.js

@@ -0,0 +1,52 @@
+/**
+ * DataFilter — owns visibility state for chart data indices.
+ *
+ * Encapsulating the hidden-index Set lets charts toggle items without knowing
+ * whether the filter is shared across re-renders, and gives the engine a single
+ * place to clear/inspect visibility state.
+ */
+export class DataFilter {
+    constructor(initial = []) {
+        this._hidden = new Set(initial);
+    }
+
+    /** @returns {boolean} */
+    has(index) {
+        return this._hidden.has(index);
+    }
+
+    /** Hide the given index. */
+    hide(index) {
+        this._hidden.add(index);
+    }
+
+    /** Show the given index. */
+    show(index) {
+        this._hidden.delete(index);
+    }
+
+    /** Toggle visibility and return the new state. */
+    toggle(index) {
+        if (this.has(index)) {
+            this.show(index);
+            return false;
+        }
+        this.hide(index);
+        return true;
+    }
+
+    /** Clear all hidden indices. */
+    clear() {
+        this._hidden.clear();
+    }
+
+    /** @returns {number} count of hidden indices */
+    get size() {
+        return this._hidden.size;
+    }
+
+    /** @returns {Set<number>} snapshot of hidden indices */
+    hidden() {
+        return new Set(this._hidden);
+    }
+}

package/src/charting/Diagram.js

@@ -0,0 +1,36 @@
+/**
+ * Diagram — abstract base class for one diagram type.
+ *
+ * Subclasses implement `_render()` and are instantiated by RenderEngine's
+ * diagram methods. This mirrors Chart but for diagram renderers.
+ */
+export class Diagram {
+    /** Registry key for this diagram type. Subclasses override. */
+    static diagramType = null;
+
+    constructor(renderer, data, options = {}) {
+        if (new.target === Diagram) {
+            throw new TypeError('Diagram is abstract — subclass it');
+        }
+        this.renderer = renderer;
+        this.data = data;
+        this.options = options;
+    }
+
+    /** Render the diagram. Subclasses implement `_render()`. */
+    render() {
+        if (!this.renderer) return;
+        this.renderer.clear();
+        this._render();
+    }
+
+    /** Subclasses implement the actual drawing here. */
+    _render() {
+        throw new Error(`${this.constructor.name} must implement _render()`);
+    }
+
+    /** Optional click handler; subclasses override to respond to hits. */
+    onClick(event, hitShape) {
+        // no-op by default
+    }
+}

package/src/charting/Diagram3D.js

@@ -0,0 +1,29 @@
+import { Diagram } from './Diagram.js';
+import { CameraSeeder } from './CameraSeeder.js';
+
+/**
+ * Diagram3D — abstract base class for diagrams that use the orbit camera.
+ *
+ * Subclasses get camera-seeding helpers and the same persistence convention
+ * used by Chart3D-backed charts (camera state survives redraws).
+ */
+export class Diagram3D extends Diagram {
+    constructor(renderer, data, options = {}) {
+        if (new.target === Diagram3D) {
+            throw new TypeError('Diagram3D is abstract — subclass it');
+        }
+        super(renderer, data, options);
+        this.camera = null;
+        this._cameraSeeder = new CameraSeeder();
+    }
+
+    /**
+     * Seed an orbit-camera state object if one isn't already present.
+     * @param {{theta?:number, phi?:number, distance?:number}} defaults
+     * @returns {{theta:number, phi:number, distance:number}}
+     */
+    seedCamera(defaults = CameraSeeder.DEFAULTS) {
+        this.camera = this._cameraSeeder.seed(this.camera, defaults);
+        return this.camera;
+    }
+}

package/src/charting/DiagramClipboard.js

@@ -0,0 +1,31 @@
+/**
+ * DiagramClipboard — what was last copied in any editor on the page: its
+ * kind (which editors can paste it, e.g. 'diagram' or 'archimate'), the copy
+ * itself (whatever the editor that made it needs to paste it again), and
+ * where its top-left corner was. One for the page, so a copy pastes into
+ * another view, another tab, or another model's editor of the same kind.
+ */
+export class DiagramClipboard {
+    static _entry = null;
+
+    /** Keep a copy. */
+    static put(kind, payload, origin = { x: 0, y: 0 }) {
+        DiagramClipboard._entry = { kind, payload, origin: { ...origin }, pastes: 0 };
+    }
+
+    /** The copy of `kind`, or null when what was copied is another kind (or nothing). */
+    static get(kind) {
+        const entry = DiagramClipboard._entry;
+        return entry?.kind === kind ? entry : null;
+    }
+
+    /** Whether there is a copy an editor of `kind` can paste. */
+    static has(kind) {
+        return !!DiagramClipboard.get(kind);
+    }
+
+    /** Forget the copy. */
+    static clear() {
+        DiagramClipboard._entry = null;
+    }
+}