graphwise-reactodia 0.0.1-TR16 → 0.0.1-TR18

package/dist/cjs/index.cjs.js

@@ -1,9 +1,19 @@
 'use strict';
 
+var errorCode = require('./error-code-BdRU0RQ9.js');
+
 /**
- * Event name for clearing the local store state of the diagram. There is an event listener listening for it, which
- * will clear the local store state, whenever this event is fired.
+ * Name of the DOM event the `graphwise-reactodia` element dispatches for every event.
  */
-const CLEAR_DIAGRAM_STORAGE_EVENT = 'graphwise-reactodia:clear-diagram-storage';
+const GRAPHWISE_REACTODIA_EVENT = 'graphwiseReactodiaEvent';
 
-exports.CLEAR_DIAGRAM_STORAGE_EVENT = CLEAR_DIAGRAM_STORAGE_EVENT;
+exports.CLEAR_DIAGRAM_STORAGE_EVENT = errorCode.CLEAR_DIAGRAM_STORAGE_EVENT;
+Object.defineProperty(exports, "ErrorCode", {
+	enumerable: true,
+	get: function () { return errorCode.ErrorCode; }
+});
+Object.defineProperty(exports, "EventType", {
+	enumerable: true,
+	get: function () { return errorCode.EventType; }
+});
+exports.GRAPHWISE_REACTODIA_EVENT = GRAPHWISE_REACTODIA_EVENT;

package/dist/cjs/loader.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-CII9aUQC.js');
+var index = require('./index-DtzCybH4.js');
 var appGlobals = require('./app-globals-CcJr5lkF.js');
 
 const defineCustomElements = async (win, options) => {

package/dist/collection/components/graphwise-reactodia/graphwise-reactodia.js

@@ -1,7 +1,14 @@
 import { h, Host } from "@stencil/core";
 import { mountReactodia, unmountReactodia, updateReactodia } from "./reactodia-app";
 import { LanguageKey } from "./i18n/language-key";
+import { ErrorCode } from "./models/error/error-code";
+import { SubscriptionList } from "./models/subscription-list";
+import { service } from "./providers/service/service-inject";
+import { ErrorService } from "./services/error/error.service";
+import { EventService } from "./services/event/event.service";
 import { resetColors } from "./styles/type-style.resolver";
+const errorService = service(ErrorService);
+const eventService = service(EventService);
 /**
  * A web component that renders a graph with the Reactodia workspace.
  *
@@ -15,6 +22,7 @@ import { resetColors } from "./styles/type-style.resolver";
  */
 export class GraphwiseReactodia {
     constructor() {
+        this.subscriptions = new SubscriptionList();
         /**
          * UI language code (e.g. `en`, `fr`) for the Reactodia interface. Defaults to English.
          */
@@ -42,6 +50,7 @@ export class GraphwiseReactodia {
         this.renderGraph(true);
     }
     connectedCallback() {
+        this.subscribeToEvents();
         this.renderGraph();
     }
     componentDidLoad() {
@@ -49,13 +58,17 @@ export class GraphwiseReactodia {
         this.renderGraph();
     }
     disconnectedCallback() {
+        this.subscriptions.unsubscribeAll();
         if (this.reactRoot) {
             unmountReactodia(this.reactRoot);
             this.reactRoot = undefined;
         }
     }
     render() {
-        return (h(Host, { key: 'a03aad892cb1947ab2426d77b3229e1324776c2c' }));
+        return (h(Host, { key: '2e8541c791f478484c4bad64ad758df99aba2059' }));
+    }
+    subscribeToEvents() {
+        this.subscriptions.add(eventService.subscribe((detail) => this.eventEmitter.emit(detail)));
     }
     renderGraph(isReloading) {
         var _a;
@@ -63,13 +76,13 @@ export class GraphwiseReactodia {
             return;
         }
         if (!this.currentRepository) {
-            throw new Error('currentRepository is required');
+            throw this.reportMissingPropError('currentRepository is required');
         }
         if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.queryFunction)) {
-            throw new Error('config.queryFunction is required');
+            throw this.reportMissingPropError('config.queryFunction is required');
         }
         if (!this.providerSettings) {
-            throw new Error('providerSettings is required');
+            throw this.reportMissingPropError('providerSettings is required');
         }
         if (!this.hostElement) {
             return;
@@ -89,6 +102,11 @@ export class GraphwiseReactodia {
             this.reactRoot = mountReactodia(this.hostElement, props);
         }
     }
+    reportMissingPropError(message) {
+        const error = new Error(message);
+        errorService.report(ErrorCode.MISSING_REQUIRED_PROP, error);
+        return error;
+    }
     static get is() { return "graphwise-reactodia"; }
     static get originalStyleUrls() {
         return {
@@ -216,6 +234,30 @@ export class GraphwiseReactodia {
             }
         };
     }
+    static get events() {
+        return [{
+                "method": "eventEmitter",
+                "name": "graphwiseReactodiaEvent",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Fires for every event to the host, differentiated by `detail.type`."
+                },
+                "complexType": {
+                    "original": "EventDetail",
+                    "resolved": "{ type: EventType; payload: ErrorReport; }",
+                    "references": {
+                        "EventDetail": {
+                            "location": "import",
+                            "path": "./models/event/event-detail",
+                            "id": "src/components/graphwise-reactodia/models/event/event-detail.ts::EventDetail"
+                        }
+                    }
+                }
+            }];
+    }
     static get elementRef() { return "hostElement"; }
     static get watchers() {
         return [{

package/dist/collection/components/graphwise-reactodia/menu/graphwise-menu.js

@@ -3,6 +3,8 @@ import { ToolbarAction, ToolbarActionClearAll, ToolbarActionExport, ToolbarActio
 import { service } from "../providers/service/service-inject";
 import { DiagramService } from "../services/diagram/diagram.service";
 import { DiagramFileService } from "../services/diagram-file/diagram-file.service";
+import { ErrorService } from "../services/error/error.service";
+import { ErrorCode } from "../models/error/error-code";
 /**
  * The workspace main menu: Reactodia's default actions, followed by the diagram download and upload.
  *
@@ -14,6 +16,7 @@ export function GraphwiseMenu() {
     const t = useTranslation();
     const diagramFileService = service(DiagramFileService);
     const diagramService = service(DiagramService);
+    const errorService = service(ErrorService);
     const downloadDiagram = () => {
         const timestamp = new Date().toISOString().replace(/[-:]|\.\d+Z$/g, '');
         diagramFileService.download(model.exportLayout(), `diagram-${timestamp}${DiagramFileService.FILE_EXTENSION}`);
@@ -24,7 +27,7 @@ export function GraphwiseMenu() {
             await diagramService.importDiagram(model, model.dataProvider, diagram);
         }
         catch (error) {
-            console.error('Failed to upload the diagram', error);
+            errorService.report(ErrorCode.DIAGRAM_IMPORT, error);
         }
     };
     return createElement(Fragment, null, createElement(ToolbarActionClearAll, {}), createElement(ToolbarActionExport, { kind: 'exportRaster' }), createElement(ToolbarActionExport, { kind: 'exportSvg' }), createElement(ToolbarActionExport, { kind: 'print' }), createElement(ToolbarAction, 

package/dist/collection/components/graphwise-reactodia/models/error/error-cause.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/graphwise-reactodia/models/error/error-code.js

@@ -0,0 +1,18 @@
+/**
+ * The stable category of a reported error. The host uses it to choose its own message.
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    /** A required prop is missing. */
+    ErrorCode["MISSING_REQUIRED_PROP"] = "missing-required-prop";
+    /** A SPARQL data provider call failed. */
+    ErrorCode["DATA_FETCH"] = "data-fetch";
+    /** The startup load, a reload or a repository switch failed. */
+    ErrorCode["DIAGRAM_LOAD"] = "diagram-load";
+    /** The uploaded file was rejected or its import failed. */
+    ErrorCode["DIAGRAM_IMPORT"] = "diagram-import";
+    /** Reading the diagram from local storage failed. */
+    ErrorCode["LOCAL_DIAGRAM_READ"] = "local-diagram-read";
+    /** Saving the diagram in local storage failed. */
+    ErrorCode["LOCAL_DIAGRAM_SAVE"] = "local-diagram-save";
+})(ErrorCode || (ErrorCode = {}));

package/dist/collection/components/graphwise-reactodia/models/error/error-report.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/graphwise-reactodia/models/event/event-callback.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/graphwise-reactodia/models/event/event-detail.js

@@ -0,0 +1,4 @@
+/**
+ * Name of the DOM event the `graphwise-reactodia` element dispatches for every event.
+ */
+export const GRAPHWISE_REACTODIA_EVENT = 'graphwiseReactodiaEvent';

package/dist/collection/components/graphwise-reactodia/models/event/event-type.js

@@ -0,0 +1,7 @@
+/**
+ * The kind of event the wrapper announces to the host. It selects the payload of an {@link EventDetail}.
+ */
+export var EventType;
+(function (EventType) {
+    EventType["ERROR"] = "error";
+})(EventType || (EventType = {}));

package/dist/collection/components/graphwise-reactodia/reactodia-app.js

@@ -1,12 +1,14 @@
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
-import { DefaultWorkspace, SparqlDataProvider, useLoadedWorkspace, Workspace } from "@reactodia/workspace";
+import { DecoratedDataProvider, DefaultWorkspace, SparqlDataProvider, useLoadedWorkspace, Workspace } from "@reactodia/workspace";
 import { blockingDefaultLayout } from "@reactodia/workspace/layout-sync";
 import { TRANSLATIONS } from "./i18n/translations";
 import { service } from "./providers/service/service-inject";
 import { DiagramService } from "./services/diagram/diagram.service";
 import { DiagramStorageService } from "./services/diagram-storage/diagram-storage.service";
 import { EventService } from "./services/event/event.service";
+import { ErrorService } from "./services/error/error.service";
+import { ErrorCode } from "./models/error/error-code";
 import { SubscriptionList } from "./models/subscription-list";
 import { resolveTypeStyle } from "./styles/type-style.resolver";
 import { GraphwiseMenu } from "./menu/graphwise-menu";
@@ -37,17 +39,35 @@ let diagramStorageSubscription;
 const diagramService = service(DiagramService);
 const diagramStorageService = service(DiagramStorageService);
 const eventService = service(EventService);
+const errorService = service(ErrorService);
+/**
+ * Reports every failed data provider call, unless the call was aborted, and passes the failure on to the caller.
+ */
+const reportDataFetchError = async (_method, params, body) => {
+    var _a;
+    try {
+        return await body(params);
+    }
+    catch (error) {
+        if (!((_a = params.signal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+            errorService.report(ErrorCode.DATA_FETCH, error);
+        }
+        throw error;
+    }
+};
 /**
  * Builds a Reactodia {@link SparqlDataProvider} for the given endpoint using the supplied
  * query preset. The host owns the query configuration and always passes it in via props.
+ * The provider is decorated, so its failed calls are reported.
  */
 function createDataProvider(props) {
     const { currentRepository, config, providerSettings } = props;
-    return new SparqlDataProvider({
+    const baseProvider = new SparqlDataProvider({
         endpointUrl: currentRepository,
         queryMethod: 'POST',
         queryFunction: config.queryFunction
     }, providerSettings);
+    return new DecoratedDataProvider({ baseProvider, decorator: reportDataFetchError });
 }
 /**
  * Places the seed entities on the canvas. Each IRI is added as a placeholder element, and data is then loaded for the
@@ -142,22 +162,31 @@ function ReactodiaApp(props) {
         const dataProvider = createDataProvider(props);
         const isReload = props.isReload;
         const savedDiagram = diagramStorageService.load();
-        if (isReload) {
-            // Reload the diagram that is currently on the canvas. This may happen when the host changes the provider
-            // settings, or when the user switches the language at runtime, since there is no existing mechanism to
-            // re-translate the UI at runtime (not for the UI labels at least)
-            await diagramService.importDiagram(model, dataProvider, currentDiagram, signal);
+        try {
+            if (isReload) {
+                // Reload the diagram that is currently on the canvas. This may happen when the host changes the provider
+                // settings, or when the user switches the language at runtime, since there is no existing mechanism to
+                // re-translate the UI at runtime (not for the UI labels at least)
+                await diagramService.importDiagram(model, dataProvider, currentDiagram, signal);
+            }
+            else if ((_a = config.seedIris) === null || _a === void 0 ? void 0 : _a.length) {
+                await seedIrisToCanvas(context, dataProvider, config.seedIris, signal);
+            }
+            else if ((_b = config.seedGraph) === null || _b === void 0 ? void 0 : _b.length) {
+                await seedGraphToCanvas(context, dataProvider, config.seedGraph, signal);
+            }
+            else {
+                // Restore the previously saved layout when present, otherwise start empty. Either way this binds the
+                // data provider (savedDiagram is undefined -> empty diagram), so the unified search/lookup works.
+                await diagramService.importDiagram(model, dataProvider, savedDiagram, signal);
+            }
         }
-        else if ((_a = config.seedIris) === null || _a === void 0 ? void 0 : _a.length) {
-            await seedIrisToCanvas(context, dataProvider, config.seedIris, signal);
-        }
-        else if ((_b = config.seedGraph) === null || _b === void 0 ? void 0 : _b.length) {
-            await seedGraphToCanvas(context, dataProvider, config.seedGraph, signal);
-        }
-        else {
-            // Restore the previously saved layout when present, otherwise start empty. Either way this binds the
-            // data provider (savedDiagram is undefined -> empty diagram), so the unified search/lookup works.
-            await diagramService.importDiagram(model, dataProvider, savedDiagram, signal);
+        catch (error) {
+            if (!signal.aborted) {
+                errorService.report(ErrorCode.DIAGRAM_LOAD, error);
+            }
+            // rethrow, so the workspace shows the failure on its loading spinner
+            throw error;
         }
     }, [language]);
     /**
@@ -194,7 +223,7 @@ export function mountReactodia(container, props) {
 /**
  * Re-points the diagram at a new SPARQL endpoint by recreating it with a fresh data provider.
  * The canvas is reset to empty, matching the initial mount, since the data of another repository
- * has nothing to do with the current graph.
+ * has nothing to do with the current graph. A failure is reported, not thrown.
  */
 export async function updateReactodia(props) {
     if (!workspaceContext) {
@@ -202,7 +231,12 @@ export async function updateReactodia(props) {
     }
     const { model } = workspaceContext;
     const dataProvider = createDataProvider(props);
-    await model.createNewDiagram({ dataProvider });
+    try {
+        await model.createNewDiagram({ dataProvider });
+    }
+    catch (error) {
+        errorService.report(ErrorCode.DIAGRAM_LOAD, error);
+    }
 }
 /**
  * Serializes the current diagram so it can be restored after a remount (e.g. when a

package/dist/collection/components/graphwise-reactodia/services/diagram-storage/diagram-storage.service.js

@@ -12,26 +12,42 @@ var DiagramStorageService_1;
 import { Service } from "../../providers/service/service";
 import { service } from "../../providers/service/service-inject";
 import { WindowService } from "../window/window.service";
+import { ErrorService } from "../error/error.service";
+import { ErrorCode } from "../../models/error/error-code";
 /**
  * Service for local store-related diagram operations
  */
 let DiagramStorageService = DiagramStorageService_1 = class DiagramStorageService {
+    constructor() {
+        this.errorService = service(ErrorService);
+    }
     /**
      * Load the persisted diagram from the local store, or `undefined` when nothing is stored (or the stored value
      * is unreadable).
      */
     load() {
-        const raw = this.storage.getItem(DiagramStorageService_1.STORAGE_KEY);
-        if (!raw) {
+        try {
+            const raw = this.storage.getItem(DiagramStorageService_1.STORAGE_KEY);
+            if (!raw) {
+                return undefined;
+            }
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            this.errorService.report(ErrorCode.LOCAL_DIAGRAM_READ, error);
             return undefined;
         }
-        return JSON.parse(raw);
     }
     /**
      * Persists the given diagram serialization.
      */
     save(diagram) {
-        this.storage.setItem(DiagramStorageService_1.STORAGE_KEY, JSON.stringify(diagram));
+        try {
+            this.storage.setItem(DiagramStorageService_1.STORAGE_KEY, JSON.stringify(diagram));
+        }
+        catch (error) {
+            this.errorService.report(ErrorCode.LOCAL_DIAGRAM_SAVE, error);
+        }
     }
     /**
      * Removes the persisted diagram. Used when a new view (a seed) should take precedence over

package/dist/collection/components/graphwise-reactodia/services/error/error.service.js

@@ -0,0 +1,78 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ErrorService_1;
+import { Service } from "../../providers/service/service";
+import { service } from "../../providers/service/service-inject";
+import { EventType } from "../../models/event/event-type";
+import { EventService } from "../event/event.service";
+/**
+ * Service that collects the failures of the wrapper and the fork, so they can be announced to the host.
+ */
+let ErrorService = ErrorService_1 = class ErrorService {
+    constructor() {
+        this.eventService = service(EventService);
+        this.reported = new WeakSet();
+    }
+    /**
+     * Reports a failure to the host, unless it's an abort, or this exact error object is already reported
+     * from another place.
+     *
+     * The same error object may be reported from different places. E.g. a query that fails while a diagram loads is
+     * reported by the data provider decorator as `data-fetch`, and then reaches the `catch` around the load, which
+     * reports it as `diagram-load`. Only the first one is announced.
+     *
+     * The `cause` is checked because the fork wraps whatever fails during a diagram import in a new error:
+     *
+     * ```ts
+     * // reactodia-workspace/src/editor/dataDiagramModel.ts, importLayout
+     * } catch (error) {
+     *   throw new Error('Reactodia: failed to import a layout', {cause: error});
+     * }
+     * ```
+     *
+     * We need to check the cause to make sure we don't report the same error/abort more than once.
+     *
+     * @param code The category of the failure.
+     * @param thrown The thrown value.
+     */
+    report(code, thrown) {
+        const causes = this.causeChain(thrown);
+        if (this.isAbortedOrAlreadyReported(causes)) {
+            return;
+        }
+        causes.forEach((cause) => this.reported.add(cause));
+        this.eventService.emit({ type: EventType.ERROR, payload: { code, error: thrown } });
+    }
+    /**
+     * Whether any link of the given cause chain is an abort or is already reported.
+     */
+    isAbortedOrAlreadyReported(causes) {
+        return causes.some((cause) => cause.name === ErrorService_1.ABORT_ERROR_NAME || this.reported.has(cause));
+    }
+    /**
+     * The thrown value followed by its `cause`, the cause of that, and so on, for as long as they are objects.
+     */
+    causeChain(thrown) {
+        const causes = [];
+        let current = thrown;
+        while (typeof current === 'object' && current !== null && !causes.includes(current)) {
+            causes.push(current);
+            current = current.cause;
+        }
+        return causes;
+    }
+};
+ErrorService.ID = 'ErrorService';
+ErrorService.ABORT_ERROR_NAME = 'AbortError';
+ErrorService = ErrorService_1 = __decorate([
+    Service
+], ErrorService);
+export { ErrorService };

package/dist/collection/components/graphwise-reactodia/services/event/event.service.js

@@ -16,6 +16,29 @@ import { WindowService } from "../window/window.service";
  * Service for event based operations
  */
 let EventService = class EventService {
+    /**
+     * Announces an event to the host.
+     *
+     * @param detail The event detail.
+     */
+    emit(detail) {
+        var _a;
+        (_a = this.callback) === null || _a === void 0 ? void 0 : _a.call(this, detail);
+    }
+    /**
+     * Subscribes to the emitted events, replacing the previous subscriber.
+     *
+     * @param callback Called with every emitted event.
+     * @returns A {@link Subscription} that, when called, removes the callback, unless it has already been replaced.
+     */
+    subscribe(callback) {
+        this.callback = callback;
+        return () => {
+            if (this.callback === callback) {
+                this.callback = undefined;
+            }
+        };
+    }
     /**
      * Subscribes to the host's "clear persisted diagram" command.
      *

package/dist/collection/index.js

@@ -1 +1,4 @@
 export { CLEAR_DIAGRAM_STORAGE_EVENT } from './components/graphwise-reactodia/models/clear-diagram-storage-event';
+export { GRAPHWISE_REACTODIA_EVENT } from './components/graphwise-reactodia/models/event/event-detail';
+export { EventType } from './components/graphwise-reactodia/models/event/event-type';
+export { ErrorCode } from './components/graphwise-reactodia/models/error/error-code';

package/dist/collection/pages/graphwise-reactodia/main.js

@@ -17,6 +17,39 @@ async function stubQueryFunction(params) {
   return new Response('', {headers: {'Content-Type': 'text/turtle'}});
 }
 
+// A transport that always fails, as an unreachable or misconfigured endpoint would.
+async function failingQueryFunction() {
+  throw new Error('Query failed');
+}
+
+// A transport that never answers. Once its request is cancelled it fails with an ordinary error, as a transport
+// that does not throw an `AbortError` would. The pending and the cancelled requests are counted.
+window.pendingQueries = 0;
+window.cancelledQueries = 0;
+
+function hangingQueryFunction(params) {
+  window.pendingQueries++;
+  return new Promise((_resolve, reject) => {
+    params.signal?.addEventListener('abort', () => {
+      window.pendingQueries--;
+      window.cancelledQueries++;
+      reject(new Error('Request cancelled'));
+    });
+  });
+}
+
+// The errors the component reports are recorded, so the tests can tell what the host was notified of.
+const reportedErrors = [];
+window.reportedErrors = reportedErrors;
+// The listener is on the document, since the tests replace the element.
+document.addEventListener('graphwiseReactodiaEvent', (event) => {
+  if (event.detail.type !== 'error') {
+    return;
+  }
+  const {code, error} = event.detail.payload;
+  reportedErrors.push({code, message: error.message});
+});
+
 const SEED_NODES = ['http://example.com/alice', 'http://example.com/bob'];
 
 const SEED_GRAPH = [
@@ -33,6 +66,14 @@ function setQueryFunction() {
   reactodia.config = {...reactodia.config, queryFunction: stubQueryFunction};
 }
 
+function setFailingQueryFunction() {
+  reactodia.config = {...reactodia.config, queryFunction: failingQueryFunction};
+}
+
+function setHangingQueryFunction() {
+  reactodia.config = {...reactodia.config, queryFunction: hangingQueryFunction};
+}
+
 // The wrapper has no default preset, so the host always passes one. The demo uses Reactodia's generic
 // OWL/RDFS preset, copied into `owl-rdfs-settings.js`.
 function setProviderSettings() {

package/dist/esm/error-code-DHI2bePh.js

@@ -0,0 +1,34 @@
+/**
+ * Event name for clearing the local store state of the diagram. There is an event listener listening for it, which
+ * will clear the local store state, whenever this event is fired.
+ */
+const CLEAR_DIAGRAM_STORAGE_EVENT = 'graphwise-reactodia:clear-diagram-storage';
+
+/**
+ * The kind of event the wrapper announces to the host. It selects the payload of an {@link EventDetail}.
+ */
+var EventType;
+(function (EventType) {
+    EventType["ERROR"] = "error";
+})(EventType || (EventType = {}));
+
+/**
+ * The stable category of a reported error. The host uses it to choose its own message.
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    /** A required prop is missing. */
+    ErrorCode["MISSING_REQUIRED_PROP"] = "missing-required-prop";
+    /** A SPARQL data provider call failed. */
+    ErrorCode["DATA_FETCH"] = "data-fetch";
+    /** The startup load, a reload or a repository switch failed. */
+    ErrorCode["DIAGRAM_LOAD"] = "diagram-load";
+    /** The uploaded file was rejected or its import failed. */
+    ErrorCode["DIAGRAM_IMPORT"] = "diagram-import";
+    /** Reading the diagram from local storage failed. */
+    ErrorCode["LOCAL_DIAGRAM_READ"] = "local-diagram-read";
+    /** Saving the diagram in local storage failed. */
+    ErrorCode["LOCAL_DIAGRAM_SAVE"] = "local-diagram-save";
+})(ErrorCode || (ErrorCode = {}));
+
+export { CLEAR_DIAGRAM_STORAGE_EVENT as C, EventType as E, ErrorCode as a };