@process-analytics/bpmn-visualization-addons 0.8.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,142 @@
+# bpmn-visualization-addons
+
+`bpmn-visualization-addons` offers new functionalities to [bpmn-visualization](https://github.com/process-analytics/bpmn-visualization-js) in the form of addons.
+
+
+## 📌 Usage
+
+Install `bpmn-visualization-addons` and [bpmn-visualization](https://github.com/process-analytics/bpmn-visualization-js/):
+```shell
+npm install @process-analytics/bpmn-visualization-addons bpmn-visualization
+```
+
+> [!NOTE]  
+> Until version 0.7.1, the `bpmn-visualization-addons` package was available under the name `bv-experimental-add-ons`.
+If your application was using the package under its former name, proceed as follows 👇:
+```shell
+# first uninstall the old package
+npm uninstall @process-analytics/bv-experimental-add-ons
+# then install the new package
+npm install @process-analytics/bpmn-visualization-addons
+```
+Then, update the imports in your application code to use the new package name as follows 👇:
+```diff
+- import {BpmnVisualization} from "@process-analytics/bv-experimental-add-ons";
++ import {BpmnVisualization} from "@process-analytics/bpmn-visualization-addons";
+```
+
+## 📜 TypeScript Support
+
+The `@process-analytics/bpmn-visualization-addons` npm package includes type definitions, so the integration works out of the box in TypeScript projects and applications.
+`bpmn-visualization-addons` requires **TypeScript 4.5** or greater.
+
+
+## 🎨 Features
+
+### Plugins
+
+The plugins infrastructure provides a way to register extension points.
+
+> [!IMPORTANT]  
+> To be able to register and use the plugins, you need to import `BpmnVisualization` from `bpmn-visualization-addons`, and not from `bpmn-visualization`.
+```diff
+- import {BpmnVisualization} from "bpmn-visualization";
++ import {BpmnVisualization} from "@process-analytics/bpmn-visualization-addons";
+```
+
+Example of use:
+
+```ts
+import {BpmnVisualization} from "@process-analytics/bpmn-visualization-addons";
+
+const bpmnVisualization = new BpmnVisualization({
+    container: 'bpmn-container',
+    plugins: [MyPlugin]
+});
+// Retrieve the plugin by id. The id is defined in the plugin implementation
+const myPlugin = bpmnVisualization.getPlugin<MyPlugin>('my-plugin');
+myPlugin.aMethod();
+```
+
+#### Available plugins
+
+- Plugins providing `BpmnElementsRegistry` methods divided into different categories. This is how `bpmn-visualization` will provide these functionalities
+in the future, in order to better separate responsibilities and improve tree-shaking :
+  - `CssClassesPlugin`: all methods for manipulating the CSS classes of BPMN elements.
+  - `ElementsPlugin`: all methods for retrieving `BpmnElement` and `BpmnSemantic` objects.
+  - `OverlaysPlugin`:
+    - provides all `BpmnElementsRegistry` methods relating to overlays.
+    - ADDITION: let show/hide overlays created with `BpmnElementsRegistry.addOverlays`.
+  - `StylePlugin`: all methods for manipulating the style of BPMN elements.
+- `StyleByNamePlugin`: provides all `BpmnElementsRegistry` methods for manipulating the style of BPMN elements, identifying the BPMN elements by name.
+
+
+#### Writing a custom plugin
+
+A plugin is defined as a class:
+- It must implement the `Plugin` interface.
+- Its constructor must satisfy the `PluginConstructor` type.
+- It can implement the `configure` method to configure the plugin after construction.
+- It can provide new methods to extend existing API or introduce new behavior .
+
+
+### `BpmnElementsIdentifier`
+
+Convenient tools to know the type/kind of BPMN elements.
+
+
+### `BpmnElementsSearcher`
+
+`bpmn-visualization` only provides APIs that take BPMN element ids as parameters.
+However, there are scenario where the ids in the BPMN source/model have been generated and are unknown by the application.
+
+Instead, the application knows the name of the elements. `BpmnElementsSearcher` provides a way to retrieve elements given their names.
+
+This is useful for example in "Process Discovery" scenario. The elements are identified by name only. Ids may be generated
+and not fully linked with the name of the elements.
+
+IMPORTANT: There is no guarantee that names are unique in the BPMN source. In case that there are several matches, `BpmnElementsSearcher` may do filtering (see below).
+
+#### Retrieving `ids`
+
+Once you get the ids of elements related to their names, you can then call regular `bpmn-visualization` API by passing the resulting ids.
+
+Limitations
+- If there are several matching names, `BpmnElementsSearcher` returns the first matching identifier.
+
+#### Retrieving the whole `BpmnSemantic`
+
+`BpmnElementsSearcher` also provides a method to retrieve the whole BpmnSemantic objects.
+
+In this case, it allows to provide ways to choose the elements if there are several matches for a given name. See `DeduplicateNamesOptions` for more details.
+
+
+### Available implementations for `Path Resolution`
+
+**WARNING**: this is front-end processing. It's more efficient for this type of processing to be carried out in the backend.
+Use it to bypass the limitations of the tools and algorithms provided in the backend.
+
+The `Path Resolution` infers a BPMN path from elements known to be completed or pending.
+
+#### `PathResolver`
+
+As it is generic and covers general use cases, its capabilities are limited.
+
+It only infers edges/flows given a list of flowNode/shape ids.
+
+#### `CasePathResolver`
+
+Provides path resolution for a single process instance/case.
+
+It is an enhanced implementation of `PathResolver` with resolution options and returns categorized `BpmnSemantic` objects.
+
+
+### `ShapeUtil`
+
+Add new methods to the `ShapeUtil` class provided by `bpmn-visualization`. 
+
+
+## 📃 License
+
+`bpmn-visualization-addons` is released under the [Apache 2.0](LICENSE) license.  
+Copyright &copy; 2023-present, Bonitasoft S.A.

package/lib/bpmn-elements.d.ts

@@ -0,0 +1,59 @@
+import type { BpmnElementKind, BpmnSemantic, ElementsRegistry } from 'bpmn-visualization';
+import { ShapeBpmnElementKind, ShapeUtil as BaseShapeUtil } from 'bpmn-visualization';
+/**
+ * Options to deduplicate elements when several names match.
+ */
+export type DeduplicateNamesOptions = {
+    /** If not set, use all `BpmnElementKind` values. */
+    kinds?: BpmnElementKind[];
+    /** Apply custom function to filter duplicates. */
+    filter?: (bpmnSemantic: BpmnSemantic) => boolean;
+};
+/**
+ * Provides workarounds for {@link https://github.com/process-analytics/bpmn-visualization-js/issues/2453}.
+ */
+export declare class BpmnElementsSearcher {
+    private readonly elementsRegistry;
+    constructor(elementsRegistry: ElementsRegistry);
+    /**
+     * Find the ID of the first element that matches the provided name.
+     * @param name the name of the element to retrieve.
+     */
+    getElementIdByName(name: string): string | undefined;
+    /**
+     * Find the element that matches the provided name.
+     *
+     * Use the `deduplicateOptions` parameter to modify the default behavior of deduplication processing.
+     *
+     * The deduplication process is done in this order:
+     * - look for elements matching the provided kinds. If not specified, use all `BpmnElementKind` values.
+     * - apply the deduplication filter if provided, otherwise take the first element corresponding to the name provided.
+     *
+     * @param name the name of the element to retrieve.
+     * @param deduplicateOptions if not defined, or if the object doesn't define any properties, duplicates are filtered out by selecting the first element corresponding to the name provided.
+     */
+    getElementByName(name: string, deduplicateOptions?: DeduplicateNamesOptions): BpmnSemantic | undefined;
+    /**
+     * Returns all elements matching the names passed in parameter.
+     *
+     * The number of elements returned may differ from the number of names passed in parameter:
+     * - if there are no elements matching the names
+     * - if one of the names does not correspond to any elements
+     * - if a name corresponds to several elements (duplicates)
+     *
+     * @param names the names of the elements to retrieve.
+     */
+    getElementsByNames(names: string[]): BpmnSemantic[];
+}
+export declare class BpmnElementsIdentifier {
+    private readonly elementsRegistry;
+    constructor(elementsRegistry: ElementsRegistry);
+    isActivity(elementId: string): boolean;
+    isBpmnArtifact(elementId: string): boolean;
+    isGateway(elementId: string): boolean;
+    isEvent(elementId: string): boolean;
+    private isInCategory;
+}
+export declare class ShapeUtil extends BaseShapeUtil {
+    static isBpmnArtifact(kind: ShapeBpmnElementKind | string): boolean;
+}

package/lib/bpmn-elements.js

@@ -0,0 +1,122 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { FlowKind, ShapeBpmnElementKind, ShapeUtil as BaseShapeUtil } from 'bpmn-visualization';
+const allBpmnElementKinds = [...Object.values(ShapeBpmnElementKind), ...Object.values(FlowKind)];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const acceptAll = (_bpmnSemantic) => true;
+/**
+ * Provides workarounds for {@link https://github.com/process-analytics/bpmn-visualization-js/issues/2453}.
+ */
+export class BpmnElementsSearcher {
+    constructor(elementsRegistry) {
+        Object.defineProperty(this, "elementsRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: elementsRegistry
+        });
+    }
+    /**
+     * Find the ID of the first element that matches the provided name.
+     * @param name the name of the element to retrieve.
+     */
+    getElementIdByName(name) {
+        var _a;
+        return (_a = this.getElementByName(name)) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    /**
+     * Find the element that matches the provided name.
+     *
+     * Use the `deduplicateOptions` parameter to modify the default behavior of deduplication processing.
+     *
+     * The deduplication process is done in this order:
+     * - look for elements matching the provided kinds. If not specified, use all `BpmnElementKind` values.
+     * - apply the deduplication filter if provided, otherwise take the first element corresponding to the name provided.
+     *
+     * @param name the name of the element to retrieve.
+     * @param deduplicateOptions if not defined, or if the object doesn't define any properties, duplicates are filtered out by selecting the first element corresponding to the name provided.
+     */
+    getElementByName(name, deduplicateOptions) {
+        var _a;
+        // Not optimized, do a full lookup at each call
+        // Split query by kind to avoid returning a big chunk of data
+        for (const kind of (_a = deduplicateOptions === null || deduplicateOptions === void 0 ? void 0 : deduplicateOptions.kinds) !== null && _a !== void 0 ? _a : allBpmnElementKinds) {
+            const candidate = this.elementsRegistry
+                .getModelElementsByKinds(kind)
+                .filter(element => element.name === name)
+                .find(element => { var _a; return ((_a = deduplicateOptions === null || deduplicateOptions === void 0 ? void 0 : deduplicateOptions.filter) !== null && _a !== void 0 ? _a : acceptAll)(element); });
+            if (candidate) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Returns all elements matching the names passed in parameter.
+     *
+     * The number of elements returned may differ from the number of names passed in parameter:
+     * - if there are no elements matching the names
+     * - if one of the names does not correspond to any elements
+     * - if a name corresponds to several elements (duplicates)
+     *
+     * @param names the names of the elements to retrieve.
+     */
+    getElementsByNames(names) {
+        const elements = [];
+        for (const kind of allBpmnElementKinds) {
+            elements.push(...this.elementsRegistry
+                .getModelElementsByKinds(kind)
+                .filter(element => names.includes(element.name))
+                .flat());
+        }
+        return elements;
+    }
+}
+export class BpmnElementsIdentifier {
+    constructor(elementsRegistry) {
+        Object.defineProperty(this, "elementsRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: elementsRegistry
+        });
+    }
+    isActivity(elementId) {
+        return this.isInCategory(BaseShapeUtil.isActivity, elementId);
+    }
+    isBpmnArtifact(elementId) {
+        return this.isInCategory(ShapeUtil.isBpmnArtifact, elementId);
+    }
+    isGateway(elementId) {
+        return this.isInCategory(BaseShapeUtil.isGateway, elementId);
+    }
+    isEvent(elementId) {
+        return this.isInCategory(BaseShapeUtil.isEvent, elementId);
+    }
+    isInCategory(categorizeFunction, elementId) {
+        const elements = this.elementsRegistry.getModelElementsByIds(elementId);
+        if (elements.length > 0) {
+            const kind = elements[0].kind;
+            return categorizeFunction(kind);
+        }
+        return false;
+    }
+}
+export class ShapeUtil extends BaseShapeUtil {
+    static isBpmnArtifact(kind) {
+        return kind === ShapeBpmnElementKind.GROUP || kind === ShapeBpmnElementKind.TEXT_ANNOTATION;
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bpmn-elements.js';
+export * from './paths.js';
+export * from './plugins/index.js';
+export * from './plugins-support.js';

package/lib/index.js

@@ -0,0 +1,19 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export * from './bpmn-elements.js';
+export * from './paths.js';
+export * from './plugins/index.js';
+export * from './plugins-support.js';

package/lib/paths.d.ts

@@ -0,0 +1,54 @@
+import type { EdgeBpmnSemantic, ElementsRegistry, ShapeBpmnSemantic } from 'bpmn-visualization';
+/**
+ * A general implementation for Path resolution.
+ *
+ * As it is generic and covers general use cases, its capabilities are limited.
+ *
+ * For the path resolution of single case/instance of a process, prefer {@link CasePathResolver}.
+ */
+export declare class PathResolver {
+    private readonly elementsRegistry;
+    constructor(elementsRegistry: ElementsRegistry);
+    /**
+     * If the `shapeIds` parameter contains ids related to edges, these ids are ignored and not returned as part of the visited edges.
+     *
+     * @param shapeIds the ids used to compute the visited edges
+     */
+    getVisitedEdges(shapeIds: string[]): string[];
+}
+/**
+ * Provides path resolution for a single process instance/case.
+ *
+ * It is an enhanced implementation of {@link PathResolver} with resolution options and returns categorized `BpmnSemantic` objects.
+ */
+export declare class CasePathResolver {
+    private readonly elementsRegistry;
+    constructor(elementsRegistry: ElementsRegistry);
+    compute(input: CasePathResolverInput): CasePathResolverOutput;
+}
+export type CasePathResolverInput = {
+    /**
+     * The IDs of elements (flowNodes/shapes and flows/edges) that are already completed. Non-existing ids will be silently ignored.
+     *
+     * `Completed` means that the element has been fully executed or definitively cancelled (for BPM engines that support this and allow cancelled elements to be continued).
+     * No further user action or automation will update the element.
+     */
+    completedIds: string[];
+};
+export type CasePathResolverOutput = {
+    /**
+     * The `BpmnSemantic` objects retrieved from the model that relate to the ids passed in {@link CasePathResolverInput}.
+     */
+    provided: {
+        completed: {
+            shapes: ShapeBpmnSemantic[];
+            edges: EdgeBpmnSemantic[];
+        };
+    };
+    computed: {
+        completed: {
+            shapes: ShapeBpmnSemantic[];
+            edges: EdgeBpmnSemantic[];
+        };
+    };
+};

package/lib/paths.js

@@ -0,0 +1,91 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+const inferEdgeIds = (shapes) => {
+    const incomingIds = [];
+    const outgoingIds = [];
+    for (const shape of shapes) {
+        incomingIds.push(...shape.incomingIds);
+        outgoingIds.push(...shape.outgoingIds);
+    }
+    return incomingIds.filter(incomingId => outgoingIds.includes(incomingId));
+};
+/**
+ * A general implementation for Path resolution.
+ *
+ * As it is generic and covers general use cases, its capabilities are limited.
+ *
+ * For the path resolution of single case/instance of a process, prefer {@link CasePathResolver}.
+ */
+export class PathResolver {
+    constructor(elementsRegistry) {
+        Object.defineProperty(this, "elementsRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: elementsRegistry
+        });
+    }
+    /**
+     * If the `shapeIds` parameter contains ids related to edges, these ids are ignored and not returned as part of the visited edges.
+     *
+     * @param shapeIds the ids used to compute the visited edges
+     */
+    getVisitedEdges(shapeIds) {
+        const shapes = this.elementsRegistry.getModelElementsByIds(shapeIds).filter(element => element.isShape);
+        return inferEdgeIds(shapes);
+    }
+}
+/**
+ * Provides path resolution for a single process instance/case.
+ *
+ * It is an enhanced implementation of {@link PathResolver} with resolution options and returns categorized `BpmnSemantic` objects.
+ */
+export class CasePathResolver {
+    constructor(elementsRegistry) {
+        Object.defineProperty(this, "elementsRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: elementsRegistry
+        });
+    }
+    compute(input) {
+        const completedElements = this.elementsRegistry.getModelElementsByIds(input.completedIds);
+        const completedShapes = completedElements.filter(element => element.isShape);
+        const completedEdges = completedElements.filter(element => !element.isShape);
+        const inputElementIds = new Set(completedElements.map(element => element.id));
+        // infer edges from shapes
+        const computedCompletedEdgeIds = inferEdgeIds(completedShapes).filter(id => !inputElementIds.has(id));
+        const computedCompletedEdges = this.elementsRegistry.getModelElementsByIds(computedCompletedEdgeIds);
+        // infer shapes from edges
+        const computedCompletedShapeIds = completedEdges.flatMap(edge => [edge.sourceRefId, edge.targetRefId]).filter(id => !inputElementIds.has(id));
+        const computedCompletedShapes = this.elementsRegistry.getModelElementsByIds(computedCompletedShapeIds);
+        return {
+            provided: {
+                completed: {
+                    shapes: completedShapes,
+                    edges: completedEdges,
+                },
+            },
+            computed: {
+                completed: {
+                    shapes: computedCompletedShapes,
+                    edges: computedCompletedEdges,
+                },
+            },
+        };
+    }
+}

package/lib/plugins/css-classes.d.ts

@@ -0,0 +1,18 @@
+import type { BpmnVisualization, Plugin } from '../plugins-support.js';
+import type { CssClassesRegistry } from 'bpmn-visualization';
+/**
+ * Provide CSS classes operations on BPMN elements.
+ *
+ * This plugin is a wrapper that delegates the actual CSS classes operations to {@link BpmnElementsRegistry}.
+ *
+ * @since 0.7.0
+ */
+export declare class CssClassesPlugin implements Plugin, CssClassesRegistry {
+    private readonly cssRegistry;
+    constructor(bpmnVisualization: BpmnVisualization);
+    getPluginId(): string;
+    addCssClasses(bpmnElementIds: string | string[], classNames: string | string[]): void;
+    removeCssClasses(bpmnElementIds: string | string[], classNames: string | string[]): void;
+    removeAllCssClasses(bpmnElementIds?: string | string[]): void;
+    toggleCssClasses(bpmnElementIds: string | string[], classNames: string | string[]): void;
+}

package/lib/plugins/css-classes.js

@@ -0,0 +1,48 @@
+/*
+Copyright 2024 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+/**
+ * Provide CSS classes operations on BPMN elements.
+ *
+ * This plugin is a wrapper that delegates the actual CSS classes operations to {@link BpmnElementsRegistry}.
+ *
+ * @since 0.7.0
+ */
+export class CssClassesPlugin {
+    constructor(bpmnVisualization) {
+        Object.defineProperty(this, "cssRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cssRegistry = bpmnVisualization.bpmnElementsRegistry;
+    }
+    getPluginId() {
+        return 'css';
+    }
+    addCssClasses(bpmnElementIds, classNames) {
+        this.cssRegistry.addCssClasses(bpmnElementIds, classNames);
+    }
+    removeCssClasses(bpmnElementIds, classNames) {
+        this.cssRegistry.removeCssClasses(bpmnElementIds, classNames);
+    }
+    removeAllCssClasses(bpmnElementIds) {
+        this.cssRegistry.removeAllCssClasses(bpmnElementIds);
+    }
+    toggleCssClasses(bpmnElementIds, classNames) {
+        this.cssRegistry.toggleCssClasses(bpmnElementIds, classNames);
+    }
+}

package/lib/plugins/elements.d.ts

@@ -0,0 +1,11 @@
+import type { BpmnVisualization, Plugin } from '../plugins-support.js';
+import type { BpmnElement, BpmnElementKind, BpmnSemantic, ElementsRegistry } from 'bpmn-visualization';
+export declare class ElementsPlugin implements Plugin, ElementsRegistry {
+    private readonly elementsRegistry;
+    constructor(bpmnVisualization: BpmnVisualization);
+    getElementsByIds(bpmnElementIds: string | string[]): BpmnElement[];
+    getElementsByKinds(bpmnKinds: BpmnElementKind | BpmnElementKind[]): BpmnElement[];
+    getModelElementsByIds(bpmnElementIds: string | string[]): BpmnSemantic[];
+    getModelElementsByKinds(bpmnKinds: BpmnElementKind | BpmnElementKind[]): BpmnSemantic[];
+    getPluginId(): string;
+}

package/lib/plugins/elements.js

@@ -0,0 +1,41 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export class ElementsPlugin {
+    constructor(bpmnVisualization) {
+        Object.defineProperty(this, "elementsRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.elementsRegistry = bpmnVisualization.bpmnElementsRegistry;
+    }
+    getElementsByIds(bpmnElementIds) {
+        return this.elementsRegistry.getElementsByIds(bpmnElementIds);
+    }
+    getElementsByKinds(bpmnKinds) {
+        return this.elementsRegistry.getElementsByKinds(bpmnKinds);
+    }
+    getModelElementsByIds(bpmnElementIds) {
+        return this.elementsRegistry.getModelElementsByIds(bpmnElementIds);
+    }
+    getModelElementsByKinds(bpmnKinds) {
+        return this.elementsRegistry.getModelElementsByKinds(bpmnKinds);
+    }
+    getPluginId() {
+        return 'elements';
+    }
+}

package/lib/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export * from './css-classes.js';
+export * from './elements.js';
+export * from './overlays.js';
+export * from './style.js';

package/lib/plugins/index.js

@@ -0,0 +1,19 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export * from './css-classes.js';
+export * from './elements.js';
+export * from './overlays.js';
+export * from './style.js';

package/lib/plugins/overlays.d.ts

@@ -0,0 +1,13 @@
+import type { BpmnVisualization, Plugin } from '../plugins-support.js';
+import type { Overlay, OverlaysRegistry } from 'bpmn-visualization';
+export declare class OverlaysPlugin implements Plugin, OverlaysRegistry {
+    private readonly overlayPane;
+    private readonly overlaysRegistry;
+    private previousStyleDisplay?;
+    private isVisible;
+    constructor(bpmnVisualization: BpmnVisualization);
+    setVisible(visible?: boolean): void;
+    addOverlays(bpmnElementId: string, overlays: Overlay | Overlay[]): void;
+    removeAllOverlays(bpmnElementId: string): void;
+    getPluginId(): string;
+}

package/lib/plugins/overlays.js

@@ -0,0 +1,66 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export class OverlaysPlugin {
+    constructor(bpmnVisualization) {
+        Object.defineProperty(this, "overlayPane", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "overlaysRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "previousStyleDisplay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isVisible", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        const view = bpmnVisualization.graph.getView();
+        this.overlayPane = view.getOverlayPane();
+        this.overlaysRegistry = bpmnVisualization.bpmnElementsRegistry;
+    }
+    setVisible(visible = true) {
+        if (visible && !this.isVisible) {
+            this.overlayPane.style.display = this.previousStyleDisplay; // if there was no display before, unset the display
+            this.isVisible = true;
+        }
+        else if (!visible && this.isVisible) {
+            this.previousStyleDisplay = this.overlayPane.style.display;
+            this.overlayPane.style.display = 'none';
+            this.isVisible = false;
+        }
+    }
+    addOverlays(bpmnElementId, overlays) {
+        this.overlaysRegistry.addOverlays(bpmnElementId, overlays);
+    }
+    removeAllOverlays(bpmnElementId) {
+        this.overlaysRegistry.removeAllOverlays(bpmnElementId);
+    }
+    getPluginId() {
+        return 'overlays';
+    }
+}

package/lib/plugins/style.d.ts

@@ -0,0 +1,62 @@
+import type { BpmnVisualization, Plugin } from '../plugins-support.js';
+import type { StyleRegistry, StyleUpdate } from 'bpmn-visualization';
+/**
+ * Provide style operations on BPMN elements.
+ *
+ * This plugin is a wrapper that delegates the actual style operations to {@link BpmnElementsRegistry}.
+ *
+ * @since 0.7.0
+ */
+export declare class StylePlugin implements Plugin, StyleRegistry {
+    private readonly styleRegistry;
+    constructor(bpmnVisualization: BpmnVisualization);
+    getPluginId(): string;
+    updateStyle(bpmnElementIds: string | string[], styleUpdate: StyleUpdate): void;
+    resetStyle(bpmnElementIds?: string | string[]): void;
+}
+/**
+ * @since 0.7.0
+ */
+export interface StyleRegistryByName extends StyleRegistry {
+    /**
+     * Update the style of the BPMN elements with the given names.
+     *
+     * See {@link StyleRegistry.updateStyle} for more details.
+     *
+     * @param bpmnElementNames The name of the BPMN element(s) whose style must be updated.
+     * @param styleUpdate The style properties to update.
+     */
+    updateStyle(bpmnElementNames: string | string[], styleUpdate: StyleUpdate): void;
+    /**
+     * Reset the style of the BPMN elements with the given names.
+     *
+     * See {@link StyleRegistry.resetStyle} for more details.
+     *
+     * @param bpmnElementNames The name of the BPMN element(s) whose style must be reset. When passing a nullish parameter, the style of all BPMN elements will be reset. Passing an empty array has no effect.
+     */
+    resetStyle(bpmnElementNames?: string | string[]): void;
+}
+/**
+ * Provide style operations on BPMN elements, identifying them by name.
+ *
+ * This plugin is a wrapper that delegates the actual style operations to a {@link StyleRegistry} instance.
+ * It uses the {@link BpmnElementsSearcher} to map names to ids.
+ *
+ * **WARNING**: This plugin does not currently allow you to configure deduplication or filtering of the elements corresponding to the names supplied as method parameters.
+ * If a name corresponds to multiple elements, all matching elements are used, as implemented in {@link BpmnElementsSearcher.getElementsByNames}.
+ * This is a known limitation of the current implementation.
+ *
+ * **IMPORTANT**: The mapping is currently not cached, nor pre-fetched after the BPMN source has been loaded.
+ * So the implementation is not very effective. Caching and pre-fetch features will be implemented in the future.
+ * See https://github.com/process-analytics/bpmn-visualization-addons/issues/4 for improvement.
+ *
+ * @since 0.7.0
+ */
+export declare class StyleByNamePlugin implements Plugin, StyleRegistryByName {
+    private readonly searcher;
+    private readonly styleRegistry;
+    constructor(bpmnVisualization: BpmnVisualization);
+    getPluginId(): string;
+    updateStyle(bpmnElementNames: string | string[], styleUpdate: StyleUpdate): void;
+    resetStyle(bpmnElementNames?: string | string[]): void;
+}

package/lib/plugins/style.js

@@ -0,0 +1,92 @@
+/*
+Copyright 2024 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { BpmnElementsSearcher } from '../bpmn-elements.js';
+/**
+ * Provide style operations on BPMN elements.
+ *
+ * This plugin is a wrapper that delegates the actual style operations to {@link BpmnElementsRegistry}.
+ *
+ * @since 0.7.0
+ */
+export class StylePlugin {
+    constructor(bpmnVisualization) {
+        Object.defineProperty(this, "styleRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.styleRegistry = bpmnVisualization.bpmnElementsRegistry;
+    }
+    getPluginId() {
+        return 'style';
+    }
+    updateStyle(bpmnElementIds, styleUpdate) {
+        this.styleRegistry.updateStyle(bpmnElementIds, styleUpdate);
+    }
+    resetStyle(bpmnElementIds) {
+        this.styleRegistry.resetStyle(bpmnElementIds);
+    }
+}
+/**
+ * Provide style operations on BPMN elements, identifying them by name.
+ *
+ * This plugin is a wrapper that delegates the actual style operations to a {@link StyleRegistry} instance.
+ * It uses the {@link BpmnElementsSearcher} to map names to ids.
+ *
+ * **WARNING**: This plugin does not currently allow you to configure deduplication or filtering of the elements corresponding to the names supplied as method parameters.
+ * If a name corresponds to multiple elements, all matching elements are used, as implemented in {@link BpmnElementsSearcher.getElementsByNames}.
+ * This is a known limitation of the current implementation.
+ *
+ * **IMPORTANT**: The mapping is currently not cached, nor pre-fetched after the BPMN source has been loaded.
+ * So the implementation is not very effective. Caching and pre-fetch features will be implemented in the future.
+ * See https://github.com/process-analytics/bpmn-visualization-addons/issues/4 for improvement.
+ *
+ * @since 0.7.0
+ */
+export class StyleByNamePlugin {
+    constructor(bpmnVisualization) {
+        Object.defineProperty(this, "searcher", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "styleRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.searcher = new BpmnElementsSearcher(bpmnVisualization.bpmnElementsRegistry);
+        this.styleRegistry = bpmnVisualization.bpmnElementsRegistry;
+    }
+    getPluginId() {
+        return 'style-by-name';
+    }
+    updateStyle(bpmnElementNames, styleUpdate) {
+        const bpmnElements = this.searcher.getElementsByNames(bpmnElementNames);
+        this.styleRegistry.updateStyle(bpmnElements.map(bpmnElement => bpmnElement.id), styleUpdate);
+    }
+    resetStyle(bpmnElementNames) {
+        if (!bpmnElementNames) {
+            this.styleRegistry.resetStyle();
+            return;
+        }
+        const bpmnElements = this.searcher.getElementsByNames(bpmnElementNames);
+        this.styleRegistry.resetStyle(bpmnElements.map(bpmnElement => bpmnElement.id));
+    }
+}

package/lib/plugins-support.d.ts

@@ -0,0 +1,53 @@
+import { BpmnVisualization as BaseBpmnVisualization, type GlobalOptions as BaseGlobalOptions } from 'bpmn-visualization';
+/**
+ * Enforce the Plugin constructor signature.
+ * Inspired from https://www.typescriptlang.org/docs/handbook/interfaces.html#difference-between-the-static-and-instance-sides-of-classes (deprecated page, but sill working).
+ */
+export type PluginConstructor = new (bpmnVisualization: BpmnVisualization, options: GlobalOptions) => Plugin;
+/**
+ * Plugin lifecycle:
+ *   - construct
+ *   - configure
+ */
+export interface Plugin {
+    /** Returns the unique identifier of the plugin. It is not possible to use several plugins having the same identifier. */
+    getPluginId(): string;
+    /**
+     * Implement this method to configure the plugin after initialization.
+     * @param options The options passed to the BpmnVisualization instance, used to configure the plugin.
+     */
+    configure?: (options: GlobalOptions) => void;
+}
+/**
+ * Let pass plugins configuration to {@link BpmnVisualization}.
+ *
+ * Use this type if you already have a dedicated custom `GlobalOptions` type extending the bpmn-visualization `GlobalOptions` type.
+ * In this case, proceed as in the following example to add the plugins configuration to the custom `GlobalOptions`.
+ *
+ * ```ts
+ * // Assuming you have a `CustomGlobalOptions` type extending the bpmn-visualization `GlobalOptions` type
+ * type GlobalOptionsWithPluginsSupport = CustomGlobalOptions & PluginOptionExtension;
+ * ```
+ *
+ * If you don't extend `GlobalOptions`, use {@link GlobalOptions} directly.
+ */
+export type PluginOptionExtension = {
+    plugins?: PluginConstructor[];
+};
+export type GlobalOptions = BaseGlobalOptions & PluginOptionExtension;
+/**
+ * The identifiers of the plugins provided by `bpmn-visualization-addons`.
+ * @since 0.7.0
+ */
+export type DefaultPlugins = 'css' | 'elements' | 'overlays' | 'style' | 'style-by-name';
+/**
+ * All possible identifiers that can be used to identify a plugin.
+ * @since 0.7.0
+ */
+export type PluginIds = DefaultPlugins | (string & Record<never, never>);
+export declare class BpmnVisualization extends BaseBpmnVisualization {
+    private readonly plugins;
+    constructor(options: GlobalOptions);
+    getPlugin<T extends Plugin>(id: PluginIds): T;
+    private readonly registerPlugins;
+}

package/lib/plugins-support.js

@@ -0,0 +1,52 @@
+/*
+Copyright 2023 Bonitasoft S.A.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { BpmnVisualization as BaseBpmnVisualization } from 'bpmn-visualization';
+export class BpmnVisualization extends BaseBpmnVisualization {
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "plugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "registerPlugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (options) => {
+                var _a, _b;
+                // construct
+                for (const constructor of (_a = options.plugins) !== null && _a !== void 0 ? _a : []) {
+                    const plugin = new constructor(this, options);
+                    const pluginId = plugin.getPluginId();
+                    if (this.plugins.has(pluginId)) {
+                        throw new Error(`Plugin loading fails. It is not possible to register multiple plugins with the same '${pluginId}' identifier.`);
+                    }
+                    this.plugins.set(pluginId, plugin);
+                }
+                // configure
+                for (const plugin of this.plugins.values()) {
+                    (_b = plugin.configure) === null || _b === void 0 ? void 0 : _b.call(plugin, options);
+                }
+            }
+        });
+        this.registerPlugins(options);
+    }
+    getPlugin(id) {
+        return this.plugins.get(id);
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@process-analytics/bpmn-visualization-addons",
+  "version": "0.8.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "description": "Experimental addons for bpmn-visualization",
+  "keywords": [
+    "analytics",
+    "bpmn",
+    "browser",
+    "visualization",
+    "addons",
+    "add-ons",
+    "extensions",
+    "process",
+    "typescript"
+  ],
+  "homepage": "https://github.com/process-analytics/bpmn-visualization-addons#readme",
+  "bugs": "https://github.com/process-analytics/bpmn-visualization-addons/issues",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/process-analytics/bpmn-visualization-addons.git"
+  },
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "dev": "tsc --watch --sourceMap",
+    "prepack": "run-s clean build",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --runInBand",
+    "test-check": "tsc --noEmit --project tsconfig.test.json"
+  },
+  "peerDependencies": {
+    "bpmn-visualization": ">=0.42.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "~29.7.0",
+    "@swc/core": "~1.7.28",
+    "@swc/jest": "~0.2.36",
+    "@testing-library/jest-dom": "~6.5.0",
+    "cross-env": "~7.0.3",
+    "eslint-plugin-jest": "~28.8.3",
+    "eslint-plugin-jest-dom": "~5.4.0",
+    "jest": "~29.7.0",
+    "jest-environment-jsdom": "~29.7.0",
+    "npm-run-all": "~4.1.5",
+    "rimraf": "~6.0.1"
+  }
+}