@miragon/create-append-c7 0.1.0 → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## [1.0.1](https://github.com/Miragon/create-append-c7/compare/v1.0.0...v1.0.1) (2026-09-11)
+
+
+### 🐞 Bug Fixes
+
+* **ci:** match npm trusted publisher environment ([#12](https://github.com/Miragon/create-append-c7/issues/12)) ([279077b](https://github.com/Miragon/create-append-c7/commit/279077b67e886cc3b5ddf75f80340afc0b8f813c))
+
+
+### 🛠️ Misc
+
+* **deps-dev:** bump bpmn-js-create-append-anything ([#11](https://github.com/Miragon/create-append-c7/issues/11)) ([084b545](https://github.com/Miragon/create-append-c7/commit/084b54552a54ed30f1d7c1558304613b57406480))
+
+## [1.0.0](https://github.com/Miragon/create-append-c7/compare/v0.1.0...v1.0.0) (2026-09-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* apply C7 template bindings during placement ([#3](https://github.com/Miragon/create-append-c7/issues/3))
+
+### 🐞 Bug Fixes
+
+* apply C7 template bindings during placement ([#3](https://github.com/Miragon/create-append-c7/issues/3)) ([62dc687](https://github.com/Miragon/create-append-c7/commit/62dc687f91864faef2b0fa57346fb4e3c4fde3e8))
+
+
+### 🛠️ Misc
+
+* **ci:** enable dependabot ([#6](https://github.com/Miragon/create-append-c7/issues/6)) ([b8cf694](https://github.com/Miragon/create-append-c7/commit/b8cf6942b302ed037b15b427df971edb0452925e))
+* **deps-dev:** bump the npm-major group with 2 updates ([#9](https://github.com/Miragon/create-append-c7/issues/9)) ([b4479bf](https://github.com/Miragon/create-append-c7/commit/b4479bfb75bc975cf886fb5b22406942707cc73a))
+* **deps-dev:** bump the npm-minor-patch group with 2 updates ([#8](https://github.com/Miragon/create-append-c7/issues/8)) ([ec0935a](https://github.com/Miragon/create-append-c7/commit/ec0935ae55f8d248f1efc8b29913b498446e4f83))
+* **deps:** bump the github-actions-all group with 2 updates ([#7](https://github.com/Miragon/create-append-c7/issues/7)) ([3f459b4](https://github.com/Miragon/create-append-c7/commit/3f459b412279e380249d1ce4a5cfe489f08a5039))
+* migrate development and publishing to Yarn 4 ([#10](https://github.com/Miragon/create-append-c7/issues/10)) ([d443588](https://github.com/Miragon/create-append-c7/commit/d443588866bed87addbd2b89ce21d2e505ed13ef))
+* **repo:** polish repository and automate releases ([#4](https://github.com/Miragon/create-append-c7/issues/4)) ([4d82e17](https://github.com/Miragon/create-append-c7/commit/4d82e170637985b5260985dc79f9b80fa2764cfc))

package/README.md

@@ -1,5 +1,14 @@
 # @miragon/create-append-c7
 
+[![npm version](https://img.shields.io/npm/v/@miragon/create-append-c7.svg)](https://www.npmjs.com/package/@miragon/create-append-c7)
+[![Build](https://github.com/Miragon/create-append-c7/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/Miragon/create-append-c7/actions/workflows/build.yml)
+[![MIT License](https://img.shields.io/github/license/Miragon/create-append-c7)](./LICENSE)
+
+A [bpmn-js](https://github.com/bpmn-io/bpmn-js) DI module that polyfills
+`elementTemplates.createElement()` for the **Camunda 7** modeler, so the
+[`bpmn-js-create-append-anything`](https://github.com/bpmn-io/bpmn-js-create-append-anything)
+plugin can create elements that already carry an element template.
+
 > **Renamed package.** This is the continuation of
 > [`@miragon/miranum-create-append-c7-element-templates`](https://www.npmjs.com/package/@miragon/miranum-create-append-c7-element-templates).
 > npm packages cannot be renamed in place, so the project moved to this
@@ -7,18 +16,19 @@
 > receives no further updates — switch your dependency to
 > `@miragon/create-append-c7`.
 
-A [bpmn-js](https://github.com/bpmn-io/bpmn-js) DI module that polyfills
-`elementTemplates.createElement()` for the **Camunda 7** modeler, so the
-[`bpmn-js-create-append-anything`](https://github.com/bpmn-io/bpmn-js-create-append-anything)
-plugin can create elements that already carry an element template.
-
 ## Why this exists
 
 `bpmn-js-create-append-anything` calls `elementTemplates.createElement(template)`
-to instantiate a shape that is preconfigured with a template. The Camunda 7
-element-templates build does **not** ship `createElement`, so append-anything
-cannot create template-preconfigured elements out of the box. This module patches
-the missing method onto the C7 element-templates service at modeler startup.
+to instantiate a shape. The Camunda 7 element-templates build does **not** ship
+that method, so append-anything cannot create template-preconfigured elements
+out of the box. This module patches the missing method onto the C7
+element-templates service at modeler startup.
+
+The returned preview already has the resolved BPMN type, event definition, and
+template identity. Template bindings are deliberately deferred until the shape
+is placed on a diagram. This lets bindings safely access the process definitions
+and keeps creation, configuration, and automatic-append connections in one undo
+step.
 
 > The Camunda 8 (Cloud) build already ships `createElement`, so this polyfill is
 > only needed for the Camunda 7 (Platform) modeler.
@@ -26,7 +36,7 @@ the missing method onto the C7 element-templates service at modeler startup.
 ## Install
 
 ```bash
-npm install @miragon/create-append-c7
+yarn add @miragon/create-append-c7
 ```
 
 ### Peer dependencies
@@ -37,7 +47,20 @@ hosts as peer dependencies:
 | Peer | Supported range |
 |---|---|
 | `bpmn-js` | `^18.0.0` |
-| `bpmn-js-create-append-anything` | `^1.2.0` |
+| `bpmn-js-create-append-anything` | `^1.2.0 \|\| ^2.0.0` |
+| `bpmn-js-element-templates` | `^2.27.0` |
+
+The tested host combinations are:
+
+| bpmn-js | Create/append | Element templates |
+|---:|---:|---:|
+| 18.16.1 | 1.2.0 | 2.27.0 |
+| 18.25.1 | 2.0.0 | 2.33.0 |
+| 18.28.0 | 1.2.0 | 2.35.0 |
+| 18.28.0 | 2.0.0 | 2.35.0 |
+
+Create/append 2.x itself requires bpmn-js 18.22 or newer; its stricter host
+requirements still apply.
 
 ## Usage
 
@@ -45,20 +68,85 @@ Register the module as an `additionalModule` when you construct the Camunda 7
 modeler:
 
 ```ts
+import { ElementTemplatesCoreModule } from "bpmn-js-element-templates/core";
+import { CreateAppendElementTemplatesModule } from "bpmn-js-create-append-anything";
 import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7";
+import camundaModdle from "camunda-bpmn-moddle/resources/camunda.json";
 
 const modeler = new BpmnModeler({
     additionalModules: [
+        ElementTemplatesCoreModule,
+        CreateAppendElementTemplatesModule,
         CreateAppendC7ElementTemplatesModule,
-        // ...your other modules (e.g. CreateAppendElementTemplatesModule)
     ],
+    moddleExtensions: {
+        camunda: camundaModdle,
+    },
 });
 ```
 
-The module installs itself on init: it patches `elementTemplates.createElement`
-only when the host service does not already provide it, so it is safe to leave
-registered even if a future bpmn-js / Camunda build adds the method natively.
+Register the C7 element-templates module and create/append module as normal; this
+adapter does not install either host module for you. It patches
+`elementTemplates.createElement` only when the host service does not already
+provide it. Native implementations and their `templateElementFactory` service
+are left untouched, regardless of module registration order.
+
+The example uses the headless `ElementTemplatesCoreModule`. Applications that
+show template controls in the properties panel can register
+`ElementTemplatesPropertiesProviderModule` and its properties-panel dependencies
+instead; that module already includes the C7 core.
+
+`createElement(template, options?)` accepts omitted or empty options. C8-style
+template presets are not supported and a supplied `presetId` throws before a
+shape is allocated.
+
+## Timing and undo behavior
+
+Starting with 0.2.0, `createElement()` returns a detached preview without applied
+bindings. Bindings are applied by the upstream C7
+`propertiesPanel.camunda.changeTemplate` command during `shape.create`. Direct
+callers that previously inspected bindings before placement must move that work
+after creation completes.
+
+Canceled previews do not affect the diagram or command history. Once placed,
+one undo removes the whole configured creation; redo restores the recorded
+bindings without applying them a second time.
+
+## Development
+
+Use Node.js 22 and Corepack. The repository pins Yarn 4.18.0 and uses
+`node_modules` for dependency resolution.
+
+```bash
+corepack enable
+yarn install --immutable
+yarn playwright install chromium
+yarn check
+yarn npm audit --all --recursive --severity high
+```
+
+`yarn check` runs the Chromium tests and validates the package contents;
+`prepack` builds the JavaScript and declarations. Use `yarn build` to compile
+without running tests. Commit `yarn.lock` when changing dependencies.
+
+## Releases
+
+Maintainers use [Conventional Commits](https://www.conventionalcommits.org/) to
+drive version bumps and release notes. Merge the release-please PR to create the
+matching GitHub release and publish it to npm using Yarn and OIDC Trusted
+Publishing. If publishing fails, retry the failed publish job from that original
+release workflow run. Already-published
+versions are skipped. Manual Publish workflow runs only validate the package;
+they never upload it. The supplied release tag must match the package version.
+
+For a local publish preview after installing Chromium, run:
+
+```bash
+yarn npm publish --access public --dry-run
+```
+
+Publishing runs the browser tests in `prepublish` and builds in `prepack`.
 
 ## License
 
-[MIT](./LICENSE)
+Licensed under the [MIT License](./LICENSE). Copyright © 2026 Miragon GmbH.

package/dist/ApplyTemplateOnShapeCreateBehavior.d.ts

@@ -0,0 +1,9 @@
+import type { TemplateElementFactory } from "./TemplateElementFactory";
+/**
+ * Applies templates to adapter-created shapes as part of the surrounding
+ * shape.create transaction, after the shape has been attached to the model.
+ */
+export declare class ApplyTemplateOnShapeCreateBehavior {
+    static $inject: string[];
+    constructor(eventBus: any, commandStack: any, templateElementFactory: TemplateElementFactory);
+}

package/dist/ApplyTemplateOnShapeCreateBehavior.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplyTemplateOnShapeCreateBehavior = void 0;
+const APPLY_TEMPLATE_PRIORITY = 1500;
+/**
+ * Applies templates to adapter-created shapes as part of the surrounding
+ * shape.create transaction, after the shape has been attached to the model.
+ */
+class ApplyTemplateOnShapeCreateBehavior {
+    constructor(eventBus, commandStack, templateElementFactory) {
+        eventBus.on("commandStack.shape.create.postExecute", APPLY_TEMPLATE_PRIORITY, (event) => {
+            const element = event.context.shape;
+            const template = templateElementFactory.getPendingTemplate(element);
+            if (!template) {
+                return;
+            }
+            commandStack.execute("propertiesPanel.camunda.changeTemplate", {
+                element,
+                oldTemplate: null,
+                newTemplate: omitElementType(template),
+            });
+            templateElementFactory.consumePendingTemplate(element);
+        });
+    }
+}
+exports.ApplyTemplateOnShapeCreateBehavior = ApplyTemplateOnShapeCreateBehavior;
+ApplyTemplateOnShapeCreateBehavior.$inject = ["eventBus", "commandStack", "c7TemplateElementFactory"];
+function omitElementType(template) {
+    const { elementType: _elementType, ...templateWithoutElementType } = template;
+    return templateWithoutElementType;
+}

package/dist/ExtendElementTemplates.d.ts

@@ -1,13 +1,3 @@
-/**
- * Polyfills `elementTemplates.createElement()` on the C7 element templates
- * service if the method does not already exist.
- *
- * The `bpmn-js-create-append-anything` plugin calls `createElement()` to
- * produce a shape preconfigured with a template, but the Camunda 7
- * properties panel does not ship this method.  This class bridges the gap
- * by delegating to {@link TemplateElementFactory}.
- */
-import type { TemplateElementFactory } from "./TemplateElementFactory";
 /**
  * DI initialiser that patches `createElement` onto the C7 element templates
  * service instance at startup.
@@ -20,7 +10,7 @@ export declare class ExtendElementTemplates {
      * the {@link TemplateElementFactory}.
      *
      * @param elementTemplates The bpmn-js element templates service.
-     * @param templateElementFactory The factory that creates template-preconfigured shapes.
+     * @param injector The modeler's dependency injector, used only for the C7 fallback.
      */
-    constructor(elementTemplates: any, templateElementFactory: TemplateElementFactory);
+    constructor(elementTemplates: any, injector: any);
 }

package/dist/ExtendElementTemplates.js

@@ -12,19 +12,17 @@ class ExtendElementTemplates {
      * the {@link TemplateElementFactory}.
      *
      * @param elementTemplates The bpmn-js element templates service.
-     * @param templateElementFactory The factory that creates template-preconfigured shapes.
+     * @param injector The modeler's dependency injector, used only for the C7 fallback.
      */
-    constructor(elementTemplates, templateElementFactory) {
+    constructor(elementTemplates, injector) {
         if (typeof elementTemplates.createElement === "function") {
             return;
         }
-        elementTemplates.createElement = (template) => {
-            if (!template) {
-                throw new Error("template is missing");
-            }
-            return templateElementFactory.create(template);
-        };
+        const templateElementFactory = injector.get("c7TemplateElementFactory");
+        // Instantiation registers the shape-create listener.
+        injector.get("c7ApplyTemplateOnShapeCreateBehavior");
+        elementTemplates.createElement = (template, options) => templateElementFactory.create(template, options);
     }
 }
 exports.ExtendElementTemplates = ExtendElementTemplates;
-ExtendElementTemplates.$inject = ["elementTemplates", "templateElementFactory"];
+ExtendElementTemplates.$inject = ["elementTemplates", "injector"];

package/dist/TemplateElementFactory.d.ts

@@ -1,51 +1,35 @@
 /**
- * Subset of the element template schema needed to create a preconfigured shape.
+ * The subset of the C7 element-template schema needed by the adapter.
+ * Additional template fields are deliberately retained for the upstream
+ * change-template command.
  */
-interface C7ElementTemplate {
+export interface C7ElementTemplate {
     id: string;
     version?: number;
-    appliesTo: string[];
+    appliesTo?: string[];
     elementType?: {
         value?: string;
         eventDefinition?: string;
     };
+    [key: string]: unknown;
+}
+export interface CreateElementOptions {
+    presetId?: string;
 }
 /**
- * Factory that produces bpmn-js shapes with a Camunda 7 element template
- * already applied, ready for placement on the canvas.
+ * Creates detached C7 shapes and remembers the template that must be applied
+ * once the shape is attached to a diagram.
  */
 export declare class TemplateElementFactory {
     static $inject: string[];
-    private readonly commandStack;
     private readonly elementFactory;
+    private readonly pendingTemplates;
+    constructor(elementFactory: any);
     /**
-     * @param commandStack The bpmn-js command stack service.
-     * @param elementFactory The bpmn-js element factory service.
-     */
-    constructor(commandStack: any, elementFactory: any);
-    /**
-     * Creates a shape with the given element template applied.
-     *
-     * @param template The element template to apply.
-     * @returns The created bpmn-js shape with template bindings applied.
-     */
-    create(template: C7ElementTemplate): any;
-    /**
-     * Creates the base shape from the template's type information.
-     *
-     * Uses `elementType.value` if specified, otherwise falls back to the
-     * first entry in `appliesTo`.
-     *
-     * @param template The element template.
-     * @returns The created bpmn-js shape.
-     */
-    private createShape;
-    /**
-     * Stamps the template ID and version onto the element's business object.
-     *
-     * @param element The bpmn-js shape.
-     * @param template The element template.
+     * Create a detached preview. No editing command is executed here because
+     * C7 bindings may need the shape's parent and the diagram definitions.
      */
-    private setModelerTemplate;
+    create(template: C7ElementTemplate, options?: CreateElementOptions): any;
+    getPendingTemplate(element: object): C7ElementTemplate | undefined;
+    consumePendingTemplate(element: object): void;
 }
-export {};

package/dist/TemplateElementFactory.js

@@ -1,73 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateElementFactory = void 0;
-/**
- * Creates bpmn-js shapes preconfigured with a Camunda 7 element template.
- *
- * Handles the three-step process:
- * 1. Create the base shape from the template's `appliesTo` / `elementType`.
- * 2. Stamp `camunda:modelerTemplate` and version onto the business object.
- * 3. Execute the properties-panel command to apply template bindings.
- */
 const ModelUtil_1 = require("bpmn-js/lib/util/ModelUtil");
 /**
- * Factory that produces bpmn-js shapes with a Camunda 7 element template
- * already applied, ready for placement on the canvas.
+ * Creates detached C7 shapes and remembers the template that must be applied
+ * once the shape is attached to a diagram.
  */
 class TemplateElementFactory {
-    /**
-     * @param commandStack The bpmn-js command stack service.
-     * @param elementFactory The bpmn-js element factory service.
-     */
-    constructor(commandStack, elementFactory) {
-        this.commandStack = commandStack;
+    constructor(elementFactory) {
+        this.pendingTemplates = new WeakMap();
         this.elementFactory = elementFactory;
     }
     /**
-     * Creates a shape with the given element template applied.
-     *
-     * @param template The element template to apply.
-     * @returns The created bpmn-js shape with template bindings applied.
-     */
-    create(template) {
-        const element = this.createShape(template);
-        this.setModelerTemplate(element, template);
-        this.commandStack.execute("propertiesPanel.camunda.changeTemplate", {
-            element,
-            oldTemplate: null,
-            newTemplate: template,
-        });
-        return element;
-    }
-    /**
-     * Creates the base shape from the template's type information.
-     *
-     * Uses `elementType.value` if specified, otherwise falls back to the
-     * first entry in `appliesTo`.
-     *
-     * @param template The element template.
-     * @returns The created bpmn-js shape.
+     * Create a detached preview. No editing command is executed here because
+     * C7 bindings may need the shape's parent and the diagram definitions.
      */
-    createShape(template) {
-        const { appliesTo, elementType } = template;
-        const type = elementType?.value ?? appliesTo[0];
+    create(template, options = {}) {
+        if (!template) {
+            throw new Error("template is missing");
+        }
+        if (options?.presetId !== undefined) {
+            throw new Error("C7 element template presets are not supported");
+        }
+        const selectedTemplate = cloneTemplate(template);
+        const type = selectedTemplate.elementType?.value ?? selectedTemplate.appliesTo?.[0];
+        if (!type) {
+            throw new Error("template element type is missing");
+        }
         const attrs = { type };
-        if (elementType?.eventDefinition) {
-            attrs.eventDefinitionType = elementType.eventDefinition;
+        if (selectedTemplate.elementType?.eventDefinition) {
+            attrs.eventDefinitionType = selectedTemplate.elementType.eventDefinition;
         }
-        return this.elementFactory.createShape(attrs);
-    }
-    /**
-     * Stamps the template ID and version onto the element's business object.
-     *
-     * @param element The bpmn-js shape.
-     * @param template The element template.
-     */
-    setModelerTemplate(element, template) {
+        const element = this.elementFactory.createShape(attrs);
         const businessObject = (0, ModelUtil_1.getBusinessObject)(element);
-        businessObject.set("camunda:modelerTemplate", template.id);
-        businessObject.set("camunda:modelerTemplateVersion", template.version);
+        businessObject.set("camunda:modelerTemplate", selectedTemplate.id);
+        businessObject.set("camunda:modelerTemplateVersion", selectedTemplate.version);
+        this.pendingTemplates.set(element, selectedTemplate);
+        return element;
+    }
+    getPendingTemplate(element) {
+        return this.pendingTemplates.get(element);
+    }
+    consumePendingTemplate(element) {
+        this.pendingTemplates.delete(element);
     }
 }
 exports.TemplateElementFactory = TemplateElementFactory;
-TemplateElementFactory.$inject = ["commandStack", "elementFactory"];
+TemplateElementFactory.$inject = ["elementFactory"];
+function cloneTemplate(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneTemplate(entry));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneTemplate(entry)]));
+    }
+    return value;
+}

package/dist/index.d.ts

@@ -5,15 +5,17 @@
  *
  * Register as an `additionalModule` when creating the C7 bpmn-js modeler:
  * ```ts
- * import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7-element-templates";
+ * import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7";
  *
  * new BpmnModeler({ additionalModules: [CreateAppendC7ElementTemplatesModule] });
  * ```
  */
+import { ApplyTemplateOnShapeCreateBehavior } from "./ApplyTemplateOnShapeCreateBehavior";
 import { ExtendElementTemplates } from "./ExtendElementTemplates";
 import { TemplateElementFactory } from "./TemplateElementFactory";
 export declare const CreateAppendC7ElementTemplatesModule: {
     __init__: string[];
-    extendedElementTemplates: (string | typeof ExtendElementTemplates)[];
-    templateElementFactory: (string | typeof TemplateElementFactory)[];
+    c7ExtendedElementTemplates: (string | typeof ExtendElementTemplates)[];
+    c7TemplateElementFactory: (string | typeof TemplateElementFactory)[];
+    c7ApplyTemplateOnShapeCreateBehavior: (string | typeof ApplyTemplateOnShapeCreateBehavior)[];
 };

package/dist/index.js

@@ -8,15 +8,17 @@ exports.CreateAppendC7ElementTemplatesModule = void 0;
  *
  * Register as an `additionalModule` when creating the C7 bpmn-js modeler:
  * ```ts
- * import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7-element-templates";
+ * import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7";
  *
  * new BpmnModeler({ additionalModules: [CreateAppendC7ElementTemplatesModule] });
  * ```
  */
+const ApplyTemplateOnShapeCreateBehavior_1 = require("./ApplyTemplateOnShapeCreateBehavior");
 const ExtendElementTemplates_1 = require("./ExtendElementTemplates");
 const TemplateElementFactory_1 = require("./TemplateElementFactory");
 exports.CreateAppendC7ElementTemplatesModule = {
-    __init__: ["extendedElementTemplates"],
-    extendedElementTemplates: ["type", ExtendElementTemplates_1.ExtendElementTemplates],
-    templateElementFactory: ["type", TemplateElementFactory_1.TemplateElementFactory],
+    __init__: ["c7ExtendedElementTemplates"],
+    c7ExtendedElementTemplates: ["type", ExtendElementTemplates_1.ExtendElementTemplates],
+    c7TemplateElementFactory: ["type", TemplateElementFactory_1.TemplateElementFactory],
+    c7ApplyTemplateOnShapeCreateBehavior: ["type", ApplyTemplateOnShapeCreateBehavior_1.ApplyTemplateOnShapeCreateBehavior],
 };

package/package.json

@@ -1,39 +1,59 @@
 {
-    "name": "@miragon/create-append-c7",
-    "version": "0.1.0",
-    "description": "Polyfills elementTemplates.createElement() for the Camunda 7 bpmn-js modeler, enabling bpmn-js-create-append-anything to create template-preconfigured elements.",
-    "license": "MIT",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "build": "tsc -p tsconfig.lib.json"
-    },
-    "keywords": [
-        "bpmn-js",
-        "bpmn-io",
-        "bpmn-js-element-templates",
-        "bpmn-js-create-append-anything",
-        "camunda-7"
-    ],
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Miragon/create-append-c7"
-    },
-    "bugs": {
-        "url": "https://github.com/Miragon/create-append-c7/issues"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "peerDependencies": {
-        "bpmn-js": "^18.0.0",
-        "bpmn-js-create-append-anything": "^1.2.0"
-    },
-    "devDependencies": {
-        "bpmn-js": "18.16.1",
-        "typescript": "6.0.3"
-    }
-}
+  "name": "@miragon/create-append-c7",
+  "version": "1.0.1",
+  "description": "Polyfills elementTemplates.createElement() for the Camunda 7 bpmn-js modeler, enabling bpmn-js-create-append-anything to create template-preconfigured elements.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json",
+    "test": "vitest run --browser.enabled",
+    "test:browser": "vitest run --browser.enabled",
+    "check": "yarn test && yarn pack --dry-run",
+    "prepack": "yarn build",
+    "prepublish": "yarn test"
+  },
+  "keywords": [
+    "bpmn-js",
+    "bpmn-io",
+    "bpmn-js-element-templates",
+    "bpmn-js-create-append-anything",
+    "camunda-7"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Miragon/create-append-c7"
+  },
+  "bugs": {
+    "url": "https://github.com/Miragon/create-append-c7/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "bpmn-js": "^18.0.0",
+    "bpmn-js-create-append-anything": "^1.2.0 || ^2.0.0",
+    "bpmn-js-element-templates": "^2.27.0"
+  },
+  "devDependencies": {
+    "@bpmn-io/properties-panel": "3.54.1",
+    "@vitest/browser-playwright": "5.0.0",
+    "bpmn-js": "18.28.0",
+    "bpmn-js-create-append-anything": "2.1.0",
+    "bpmn-js-element-templates": "2.35.0",
+    "bpmn-js-properties-panel": "5.65.0",
+    "camunda-bpmn-js-behaviors": "1.18.0",
+    "camunda-bpmn-moddle": "8.0.1",
+    "diagram-js": "15.26.0",
+    "moddle": "8.2.1",
+    "playwright": "1.63.0",
+    "typescript": "7.0.2",
+    "vite": "8.3.0",
+    "vitest": "5.0.0",
+    "zeebe-bpmn-moddle": "2.0.0"
+  },
+  "packageManager": "yarn@4.18.0"
+}