@miragon/create-append-c7 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miragon GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @miragon/create-append-c7
+
+> **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
+> de-prefixed name starting at `0.1.0`. The legacy package is deprecated and
+> 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.
+
+> The Camunda 8 (Cloud) build already ships `createElement`, so this polyfill is
+> only needed for the Camunda 7 (Platform) modeler.
+
+## Install
+
+```bash
+npm install @miragon/create-append-c7
+```
+
+### Peer dependencies
+
+This module is a thin add-on to your existing bpmn-js stack and declares its
+hosts as peer dependencies:
+
+| Peer | Supported range |
+|---|---|
+| `bpmn-js` | `^18.0.0` |
+| `bpmn-js-create-append-anything` | `^1.2.0` |
+
+## Usage
+
+Register the module as an `additionalModule` when you construct the Camunda 7
+modeler:
+
+```ts
+import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7";
+
+const modeler = new BpmnModeler({
+    additionalModules: [
+        CreateAppendC7ElementTemplatesModule,
+        // ...your other modules (e.g. CreateAppendElementTemplatesModule)
+    ],
+});
+```
+
+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.
+
+## License
+
+[MIT](./LICENSE)

package/dist/ExtendElementTemplates.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+export declare class ExtendElementTemplates {
+    static $inject: string[];
+    /**
+     * Checks whether `createElement` already exists on the element templates
+     * service.  If not, assigns it as an instance method that delegates to
+     * the {@link TemplateElementFactory}.
+     *
+     * @param elementTemplates The bpmn-js element templates service.
+     * @param templateElementFactory The factory that creates template-preconfigured shapes.
+     */
+    constructor(elementTemplates: any, templateElementFactory: TemplateElementFactory);
+}

package/dist/ExtendElementTemplates.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendElementTemplates = void 0;
+/**
+ * DI initialiser that patches `createElement` onto the C7 element templates
+ * service instance at startup.
+ */
+class ExtendElementTemplates {
+    /**
+     * Checks whether `createElement` already exists on the element templates
+     * service.  If not, assigns it as an instance method that delegates to
+     * the {@link TemplateElementFactory}.
+     *
+     * @param elementTemplates The bpmn-js element templates service.
+     * @param templateElementFactory The factory that creates template-preconfigured shapes.
+     */
+    constructor(elementTemplates, templateElementFactory) {
+        if (typeof elementTemplates.createElement === "function") {
+            return;
+        }
+        elementTemplates.createElement = (template) => {
+            if (!template) {
+                throw new Error("template is missing");
+            }
+            return templateElementFactory.create(template);
+        };
+    }
+}
+exports.ExtendElementTemplates = ExtendElementTemplates;
+ExtendElementTemplates.$inject = ["elementTemplates", "templateElementFactory"];

package/dist/TemplateElementFactory.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Subset of the element template schema needed to create a preconfigured shape.
+ */
+interface C7ElementTemplate {
+    id: string;
+    version?: number;
+    appliesTo: string[];
+    elementType?: {
+        value?: string;
+        eventDefinition?: string;
+    };
+}
+/**
+ * Factory that produces bpmn-js shapes with a Camunda 7 element template
+ * already applied, ready for placement on the canvas.
+ */
+export declare class TemplateElementFactory {
+    static $inject: string[];
+    private readonly commandStack;
+    private readonly elementFactory;
+    /**
+     * @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.
+     */
+    private setModelerTemplate;
+}
+export {};

package/dist/TemplateElementFactory.js

@@ -0,0 +1,73 @@
+"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.
+ */
+class TemplateElementFactory {
+    /**
+     * @param commandStack The bpmn-js command stack service.
+     * @param elementFactory The bpmn-js element factory service.
+     */
+    constructor(commandStack, elementFactory) {
+        this.commandStack = commandStack;
+        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.
+     */
+    createShape(template) {
+        const { appliesTo, elementType } = template;
+        const type = elementType?.value ?? appliesTo[0];
+        const attrs = { type };
+        if (elementType?.eventDefinition) {
+            attrs.eventDefinitionType = 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 businessObject = (0, ModelUtil_1.getBusinessObject)(element);
+        businessObject.set("camunda:modelerTemplate", template.id);
+        businessObject.set("camunda:modelerTemplateVersion", template.version);
+    }
+}
+exports.TemplateElementFactory = TemplateElementFactory;
+TemplateElementFactory.$inject = ["commandStack", "elementFactory"];

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * bpmn-js DI module that polyfills `elementTemplates.createElement()` for
+ * the Camunda 7 modeler, enabling the `bpmn-js-create-append-anything`
+ * plugin to create template-preconfigured elements.
+ *
+ * Register as an `additionalModule` when creating the C7 bpmn-js modeler:
+ * ```ts
+ * import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7-element-templates";
+ *
+ * new BpmnModeler({ additionalModules: [CreateAppendC7ElementTemplatesModule] });
+ * ```
+ */
+import { ExtendElementTemplates } from "./ExtendElementTemplates";
+import { TemplateElementFactory } from "./TemplateElementFactory";
+export declare const CreateAppendC7ElementTemplatesModule: {
+    __init__: string[];
+    extendedElementTemplates: (string | typeof ExtendElementTemplates)[];
+    templateElementFactory: (string | typeof TemplateElementFactory)[];
+};

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAppendC7ElementTemplatesModule = void 0;
+/**
+ * bpmn-js DI module that polyfills `elementTemplates.createElement()` for
+ * the Camunda 7 modeler, enabling the `bpmn-js-create-append-anything`
+ * plugin to create template-preconfigured elements.
+ *
+ * Register as an `additionalModule` when creating the C7 bpmn-js modeler:
+ * ```ts
+ * import { CreateAppendC7ElementTemplatesModule } from "@miragon/create-append-c7-element-templates";
+ *
+ * new BpmnModeler({ additionalModules: [CreateAppendC7ElementTemplatesModule] });
+ * ```
+ */
+const ExtendElementTemplates_1 = require("./ExtendElementTemplates");
+const TemplateElementFactory_1 = require("./TemplateElementFactory");
+exports.CreateAppendC7ElementTemplatesModule = {
+    __init__: ["extendedElementTemplates"],
+    extendedElementTemplates: ["type", ExtendElementTemplates_1.ExtendElementTemplates],
+    templateElementFactory: ["type", TemplateElementFactory_1.TemplateElementFactory],
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+    "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"
+    }
+}