From e8962d19993eafd13e0fdb2576e8afc5caf7fe1a Mon Sep 17 00:00:00 2001
From: Felix Neubauer <felix@neuby.de>
Date: Wed, 22 Apr 2026 17:13:08 +0200
Subject: [PATCH 1/3] Make Ace Editor cursor update not change focus

---
 .../src/components/panels/code-editor/aceUtility.ts           | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/meta_configurator/src/components/panels/code-editor/aceUtility.ts b/meta_configurator/src/components/panels/code-editor/aceUtility.ts
index 8a1120522..ba9bda223 100644
--- a/meta_configurator/src/components/panels/code-editor/aceUtility.ts
+++ b/meta_configurator/src/components/panels/code-editor/aceUtility.ts
@@ -30,7 +30,9 @@ export function updateCursorPositionBasedOnPath(
   currentPath: Path
 ) {
   const position = determineCursorPosition(editor, editorContent, currentPath);
-  editor.gotoLine(position.row + 1, position.column, true); // row is 1-based, column is 0-based
+  editor.clearSelection();
+  editor.moveCursorToPosition(position);
+  editor.renderer.scrollCursorIntoView();
 }
 
 /**

From 1da3220d98b5387d3d5c8192674356e9fe1f60bb Mon Sep 17 00:00:00 2001
From: Felix Neubauer <felix@neuby.de>
Date: Wed, 22 Apr 2026 17:13:28 +0200
Subject: [PATCH 2/3] Add copy and paste functionality to schema diagram

---
 .../panels/schema-diagram/VueFlowPanel.vue    |  36 ++-
 .../schema-diagram/schemaClipboardUtils.ts    | 268 ++++++++++++++++++
 .../src/schema/schemaManipulationUtils.ts     |  28 +-
 3 files changed, 324 insertions(+), 8 deletions(-)
 create mode 100644 meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts

diff --git a/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue b/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
index 039d9f520..bcc9cea4f 100644
--- a/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
+++ b/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
@@ -48,7 +48,11 @@ import SchemaExternalReferenceNode from '@/components/panels/schema-diagram/Sche
 import $RefParser from '@apidevtools/json-schema-ref-parser';
 import {useErrorService} from '@/utility/errorServiceInstance.ts';
 import {pathToJsonPointer} from '@/utility/pathUtils.ts';
-import {stringToIdentifier, urlStringToIdentifier} from '@/utility/stringToIdentifier.ts';
+import {urlStringToIdentifier} from '@/utility/stringToIdentifier.ts';
+import {
+  copySelectedSchemaToClipboard,
+  pasteSchemaFromClipboard,
+} from '@/components/panels/schema-diagram/schemaClipboardUtils';
 
 const emit = defineEmits<{
   (e: 'update_current_path', path: Path): void;
@@ -110,6 +114,34 @@ onMounted(() => {
   });
 });
 
+
+async function handleCopy(event?: ClipboardEvent) {
+  await copyToClipboard(event);
+  event?.preventDefault(); // override default browser copy
+}
+async function handlePaste(event?: ClipboardEvent) {
+  await pasteFromClipboard(event);
+  event?.preventDefault(); // override default browser paste
+}
+
+async function copyToClipboard(event?: ClipboardEvent) {
+  await copySelectedSchemaToClipboard(
+    event,
+    schemaData,
+    selectedData.value,
+    schemaSession.currentSelectedElement.value
+  );
+}
+
+async function pasteFromClipboard(event?: ClipboardEvent) {
+  try {
+    const pastedPath = await pasteSchemaFromClipboard(event, schemaData, selectedData.value);
+    selectElement(pastedPath);
+  } catch (err) {
+    console.error('Failed to read from clipboard:', err);
+  }
+}
+
 // scroll to the current selected element when it changes
 watch(
   schemaSession.currentSelectedElement,
@@ -424,7 +456,7 @@ function updateExternalReferenceValue(
 </script>
 
 <template>
-  <div class="layout-flow">
+  <div class="layout-flow" tabindex="0" @copy="handleCopy" @paste="handlePaste">
     <VueFlow
       :nodes="activeNodes"
       :edges="activeEdges"
diff --git a/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts b/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts
new file mode 100644
index 000000000..bcd5c6d7e
--- /dev/null
+++ b/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts
@@ -0,0 +1,268 @@
+import type {ManagedData} from '@/data/managedData';
+import {
+    SchemaElementData,
+    SchemaObjectAttributeData,
+    SchemaObjectNodeData,
+} from '@/schema/graph-representation/schemaGraphTypes';
+import {findAvailableSchemaId} from '@/schema/schemaReadingUtils';
+import {
+    addSchemaEnum,
+    addSchemaObject,
+    createIdentifierForExtractedElement,
+    extractInlinedSchemaElement,
+} from '@/schema/schemaManipulationUtils';
+import type {Path} from '@/utility/path';
+
+export type ClipboardSchemaPayload = {
+    name: string;
+    schema: any;
+};
+
+export async function copySelectedSchemaToClipboard(
+    event: ClipboardEvent | undefined,
+    schemaData: ManagedData,
+    selectedData: SchemaElementData | undefined,
+    selectedPath: Path
+) {
+    if (!selectedData) {
+        console.log('No element selected to copy');
+        return;
+    }
+
+    const schema = schemaData.dataAt(selectedPath);
+    let metaType = selectedData.getNodeType();
+
+    if (schema.enum != undefined) {
+        metaType = 'schemaenum';
+    }
+
+    const dataToCopy = structuredClone(schema);
+    if (!dataToCopy.type && metaType === 'schemaobject') {
+        dataToCopy.type = 'object';
+    }
+
+    const clipboardText = JSON.stringify(
+        {
+            [getClipboardNameForSelectedSchema(selectedData)]: dataToCopy,
+        },
+        null,
+        2
+    );
+
+    try {
+        if (event?.clipboardData) {
+            event.clipboardData.setData('text/plain', clipboardText);
+            return;
+        }
+        await navigator.clipboard.writeText(clipboardText);
+        console.log('Copied to system clipboard:', dataToCopy);
+    } catch (err) {
+        console.error('Failed to write to clipboard:', err);
+    }
+}
+
+export async function pasteSchemaFromClipboard(
+    event: ClipboardEvent | undefined,
+    schemaData: ManagedData,
+    selectedData: SchemaElementData | undefined
+) {
+    const clipboardText =
+        event?.clipboardData?.getData('text/plain') ?? (await navigator.clipboard.readText());
+    const payload = normalizeClipboardSchemaPayload(JSON.parse(clipboardText));
+
+    if (isComplexSchema(payload.schema)) {
+        return addComplexSchemaToDefinitions(schemaData, payload);
+    }
+
+    return addPrimitiveSchemaAsAttribute(schemaData, selectedData, payload);
+}
+
+export function inferSchemaKind(
+    schema: any
+): 'object' | 'array' | 'enum' | 'attribute' | 'unknown' {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+        return 'unknown';
+    }
+
+    if (schema.enum !== undefined) {
+        return 'enum';
+    }
+    if (isPrimitiveArraySchema(schema)) {
+        return 'attribute';
+    }
+    if (schema.type === 'array' || schema.items !== undefined) {
+        return 'array';
+    }
+    if (schema.type === 'object' || schema.properties || schema.$ref) {
+        return 'object';
+    }
+    if (
+        ['string', 'boolean', 'number', 'null', 'integer'].includes(schema.type) ||
+        schema.const !== undefined
+    ) {
+        return 'attribute';
+    }
+
+    return 'unknown';
+}
+
+function getClipboardNameForSelectedSchema(selectedData: SchemaElementData) {
+    return createIdentifierForExtractedElement(
+        selectedData.name,
+        selectedData.title,
+        selectedData.fallbackDisplayName
+    );
+}
+
+function normalizeClipboardSchemaPayload(data: any): ClipboardSchemaPayload {
+    if (isWrappedSchemaPayload(data)) {
+        const [name, schema] = Object.entries(data)[0] as [string, any];
+        return {
+            name: name.trim() || deriveNameFromSchema(schema),
+            schema,
+        };
+    }
+
+    return {
+        name: defaultNameForSchema(data),
+        schema: data,
+    };
+}
+
+function deriveNameFromSchema(schema: any) {
+    if (schema?.title && typeof schema.title === 'string') {
+        return schema.title;
+    }
+    if (schema?.type === 'object' || schema?.properties || schema?.$ref) {
+        return 'object';
+    }
+    if (schema?.type === 'array' || schema?.items) {
+        return 'array';
+    }
+    if (schema?.enum !== undefined) {
+        return 'enum';
+    }
+    if (typeof schema?.type === 'string') {
+        return schema.type;
+    }
+    return 'schema';
+}
+
+function isWrappedSchemaPayload(data: any) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return false;
+    }
+
+    const entries = Object.entries(data);
+    if (entries.length !== 1) {
+        return false;
+    }
+
+    return inferSchemaKind(data) === 'unknown' && inferSchemaKind(entries[0]![1]) !== 'unknown';
+}
+
+function isComplexSchema(schema: any) {
+    return ['object', 'array', 'enum'].includes(inferSchemaKind(schema));
+}
+
+function defaultNameForSchema(schema: any) {
+    const schemaKind = inferSchemaKind(schema);
+
+    if (schemaKind === 'attribute') {
+        return 'attr';
+    }
+    if (schemaKind === 'object' || schemaKind === 'array') {
+        return 'object';
+    }
+    if (schemaKind === 'enum') {
+        return 'enum';
+    }
+
+    return 'schema';
+}
+
+function addComplexSchemaToDefinitions(schemaData: ManagedData, payload: ClipboardSchemaPayload) {
+    const preferredName = payload.name.trim() || deriveNameFromSchema(payload.schema);
+    const schemaKind = inferSchemaKind(payload.schema);
+
+    if (schemaKind === 'enum') {
+        return addSchemaEnum(schemaData, payload.schema, preferredName);
+    }
+
+    const elementPath = addSchemaObject(schemaData, false, payload.schema, preferredName);
+
+    if (schemaKind === 'array') {
+        return extractArrayItemsToDefinition(schemaData, elementPath, payload);
+    }
+
+    return elementPath;
+}
+
+function addPrimitiveSchemaAsAttribute(
+    schemaData: ManagedData,
+    selectedData: SchemaElementData | undefined,
+    payload: ClipboardSchemaPayload
+) {
+    const targetObjectPath = getSelectedObjectPathForAttributePaste(selectedData);
+    if (!targetObjectPath) {
+        throw new Error('Primitive schemas can only be pasted when an object is selected.');
+    }
+
+    const attributePath = findAvailableSchemaId(
+        schemaData,
+        [...targetObjectPath, 'properties'],
+        payload.name.trim() || 'property',
+        true
+    );
+
+    schemaData.setDataAt(attributePath, payload.schema);
+    return attributePath;
+}
+
+function getSelectedObjectPathForAttributePaste(selectedData: SchemaElementData | undefined) {
+    if (selectedData instanceof SchemaObjectNodeData) {
+        return selectedData.absolutePath;
+    }
+
+    if (selectedData instanceof SchemaObjectAttributeData) {
+        return selectedData.absolutePath.slice(0, -2);
+    }
+
+    return undefined;
+}
+
+function isPrimitiveArraySchema(schema: any) {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+        return false;
+    }
+
+    if (!(schema.type === 'array' || schema.items !== undefined)) {
+        return false;
+    }
+
+    const items = schema.items;
+    if (!items || typeof items !== 'object' || Array.isArray(items)) {
+        return false;
+    }
+
+    return inferSchemaKind(items) === 'attribute';
+}
+
+function extractArrayItemsToDefinition(
+    schemaData: ManagedData,
+    arrayPath: Path,
+    payload: ClipboardSchemaPayload
+) {
+    const arraySchema = schemaData.dataAt(arrayPath);
+    if (!arraySchema?.items || typeof arraySchema.items !== 'object' || arraySchema.items.$ref) {
+        return arrayPath;
+    }
+
+    const itemName = createIdentifierForExtractedElement(
+        undefined,
+        arraySchema.items.title,
+        payload.name + 'Item'
+    );
+
+    return extractInlinedSchemaElement([...arrayPath, 'items'], schemaData, itemName, true);
+}
\ No newline at end of file
diff --git a/meta_configurator/src/schema/schemaManipulationUtils.ts b/meta_configurator/src/schema/schemaManipulationUtils.ts
index 8b873c7f1..f68bbffc3 100644
--- a/meta_configurator/src/schema/schemaManipulationUtils.ts
+++ b/meta_configurator/src/schema/schemaManipulationUtils.ts
@@ -153,11 +153,27 @@ export function addSchemaObject(
   return objectPath;
 }
 
-export function addSchemaEnum(schemaData: ManagedData) {
-  const enumPath = findAvailableSchemaId(schemaData, ['$defs'], 'enum');
-  schemaData.setDataAt(enumPath, {
-    type: 'string',
-    enum: ['VAL_1', 'VAL_2'],
-  });
+
+export function addSchemaEnum(
+    schemaData: ManagedData,
+    schema: any = undefined,
+    identifier: string | undefined = undefined
+) {
+  let enumPath: Path;
+
+  if (identifier !== undefined) {
+    enumPath = findAvailableSchemaId(schemaData, ['$defs'], identifier, true);
+  } else {
+    enumPath = findAvailableSchemaId(schemaData, ['$defs'], 'enum');
+  }
+
+  if (schema !== undefined) {
+    schemaData.setDataAt(enumPath, schema);
+  } else {
+    schemaData.setDataAt(enumPath, {
+      type: 'string',
+      enum: ['VAL_1', 'VAL_2'],
+    });
+  }
   return enumPath;
 }

From 563546954a93e7b850463ea023a68fa7cec5bcab Mon Sep 17 00:00:00 2001
From: Logende <Logende@users.noreply.github.com>
Date: Wed, 22 Apr 2026 15:15:03 +0000
Subject: [PATCH 3/3] apply formatting changes

---
 .../panels/schema-diagram/VueFlowPanel.vue    |   1 -
 .../schema-diagram/schemaClipboardUtils.ts    | 390 +++++++++---------
 .../src/schema/schemaManipulationUtils.ts     |   7 +-
 3 files changed, 198 insertions(+), 200 deletions(-)

diff --git a/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue b/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
index bcc9cea4f..1c3b44d5d 100644
--- a/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
+++ b/meta_configurator/src/components/panels/schema-diagram/VueFlowPanel.vue
@@ -114,7 +114,6 @@ onMounted(() => {
   });
 });
 
-
 async function handleCopy(event?: ClipboardEvent) {
   await copyToClipboard(event);
   event?.preventDefault(); // override default browser copy
diff --git a/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts b/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts
index bcd5c6d7e..38e767939 100644
--- a/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts
+++ b/meta_configurator/src/components/panels/schema-diagram/schemaClipboardUtils.ts
@@ -1,268 +1,268 @@
 import type {ManagedData} from '@/data/managedData';
 import {
-    SchemaElementData,
-    SchemaObjectAttributeData,
-    SchemaObjectNodeData,
+  SchemaElementData,
+  SchemaObjectAttributeData,
+  SchemaObjectNodeData,
 } from '@/schema/graph-representation/schemaGraphTypes';
 import {findAvailableSchemaId} from '@/schema/schemaReadingUtils';
 import {
-    addSchemaEnum,
-    addSchemaObject,
-    createIdentifierForExtractedElement,
-    extractInlinedSchemaElement,
+  addSchemaEnum,
+  addSchemaObject,
+  createIdentifierForExtractedElement,
+  extractInlinedSchemaElement,
 } from '@/schema/schemaManipulationUtils';
 import type {Path} from '@/utility/path';
 
 export type ClipboardSchemaPayload = {
-    name: string;
-    schema: any;
+  name: string;
+  schema: any;
 };
 
 export async function copySelectedSchemaToClipboard(
-    event: ClipboardEvent | undefined,
-    schemaData: ManagedData,
-    selectedData: SchemaElementData | undefined,
-    selectedPath: Path
+  event: ClipboardEvent | undefined,
+  schemaData: ManagedData,
+  selectedData: SchemaElementData | undefined,
+  selectedPath: Path
 ) {
-    if (!selectedData) {
-        console.log('No element selected to copy');
-        return;
-    }
-
-    const schema = schemaData.dataAt(selectedPath);
-    let metaType = selectedData.getNodeType();
-
-    if (schema.enum != undefined) {
-        metaType = 'schemaenum';
-    }
-
-    const dataToCopy = structuredClone(schema);
-    if (!dataToCopy.type && metaType === 'schemaobject') {
-        dataToCopy.type = 'object';
-    }
-
-    const clipboardText = JSON.stringify(
-        {
-            [getClipboardNameForSelectedSchema(selectedData)]: dataToCopy,
-        },
-        null,
-        2
-    );
-
-    try {
-        if (event?.clipboardData) {
-            event.clipboardData.setData('text/plain', clipboardText);
-            return;
-        }
-        await navigator.clipboard.writeText(clipboardText);
-        console.log('Copied to system clipboard:', dataToCopy);
-    } catch (err) {
-        console.error('Failed to write to clipboard:', err);
+  if (!selectedData) {
+    console.log('No element selected to copy');
+    return;
+  }
+
+  const schema = schemaData.dataAt(selectedPath);
+  let metaType = selectedData.getNodeType();
+
+  if (schema.enum != undefined) {
+    metaType = 'schemaenum';
+  }
+
+  const dataToCopy = structuredClone(schema);
+  if (!dataToCopy.type && metaType === 'schemaobject') {
+    dataToCopy.type = 'object';
+  }
+
+  const clipboardText = JSON.stringify(
+    {
+      [getClipboardNameForSelectedSchema(selectedData)]: dataToCopy,
+    },
+    null,
+    2
+  );
+
+  try {
+    if (event?.clipboardData) {
+      event.clipboardData.setData('text/plain', clipboardText);
+      return;
     }
+    await navigator.clipboard.writeText(clipboardText);
+    console.log('Copied to system clipboard:', dataToCopy);
+  } catch (err) {
+    console.error('Failed to write to clipboard:', err);
+  }
 }
 
 export async function pasteSchemaFromClipboard(
-    event: ClipboardEvent | undefined,
-    schemaData: ManagedData,
-    selectedData: SchemaElementData | undefined
+  event: ClipboardEvent | undefined,
+  schemaData: ManagedData,
+  selectedData: SchemaElementData | undefined
 ) {
-    const clipboardText =
-        event?.clipboardData?.getData('text/plain') ?? (await navigator.clipboard.readText());
-    const payload = normalizeClipboardSchemaPayload(JSON.parse(clipboardText));
+  const clipboardText =
+    event?.clipboardData?.getData('text/plain') ?? (await navigator.clipboard.readText());
+  const payload = normalizeClipboardSchemaPayload(JSON.parse(clipboardText));
 
-    if (isComplexSchema(payload.schema)) {
-        return addComplexSchemaToDefinitions(schemaData, payload);
-    }
+  if (isComplexSchema(payload.schema)) {
+    return addComplexSchemaToDefinitions(schemaData, payload);
+  }
 
-    return addPrimitiveSchemaAsAttribute(schemaData, selectedData, payload);
+  return addPrimitiveSchemaAsAttribute(schemaData, selectedData, payload);
 }
 
 export function inferSchemaKind(
-    schema: any
+  schema: any
 ): 'object' | 'array' | 'enum' | 'attribute' | 'unknown' {
-    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
-        return 'unknown';
-    }
-
-    if (schema.enum !== undefined) {
-        return 'enum';
-    }
-    if (isPrimitiveArraySchema(schema)) {
-        return 'attribute';
-    }
-    if (schema.type === 'array' || schema.items !== undefined) {
-        return 'array';
-    }
-    if (schema.type === 'object' || schema.properties || schema.$ref) {
-        return 'object';
-    }
-    if (
-        ['string', 'boolean', 'number', 'null', 'integer'].includes(schema.type) ||
-        schema.const !== undefined
-    ) {
-        return 'attribute';
-    }
-
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
     return 'unknown';
+  }
+
+  if (schema.enum !== undefined) {
+    return 'enum';
+  }
+  if (isPrimitiveArraySchema(schema)) {
+    return 'attribute';
+  }
+  if (schema.type === 'array' || schema.items !== undefined) {
+    return 'array';
+  }
+  if (schema.type === 'object' || schema.properties || schema.$ref) {
+    return 'object';
+  }
+  if (
+    ['string', 'boolean', 'number', 'null', 'integer'].includes(schema.type) ||
+    schema.const !== undefined
+  ) {
+    return 'attribute';
+  }
+
+  return 'unknown';
 }
 
 function getClipboardNameForSelectedSchema(selectedData: SchemaElementData) {
-    return createIdentifierForExtractedElement(
-        selectedData.name,
-        selectedData.title,
-        selectedData.fallbackDisplayName
-    );
+  return createIdentifierForExtractedElement(
+    selectedData.name,
+    selectedData.title,
+    selectedData.fallbackDisplayName
+  );
 }
 
 function normalizeClipboardSchemaPayload(data: any): ClipboardSchemaPayload {
-    if (isWrappedSchemaPayload(data)) {
-        const [name, schema] = Object.entries(data)[0] as [string, any];
-        return {
-            name: name.trim() || deriveNameFromSchema(schema),
-            schema,
-        };
-    }
-
+  if (isWrappedSchemaPayload(data)) {
+    const [name, schema] = Object.entries(data)[0] as [string, any];
     return {
-        name: defaultNameForSchema(data),
-        schema: data,
+      name: name.trim() || deriveNameFromSchema(schema),
+      schema,
     };
+  }
+
+  return {
+    name: defaultNameForSchema(data),
+    schema: data,
+  };
 }
 
 function deriveNameFromSchema(schema: any) {
-    if (schema?.title && typeof schema.title === 'string') {
-        return schema.title;
-    }
-    if (schema?.type === 'object' || schema?.properties || schema?.$ref) {
-        return 'object';
-    }
-    if (schema?.type === 'array' || schema?.items) {
-        return 'array';
-    }
-    if (schema?.enum !== undefined) {
-        return 'enum';
-    }
-    if (typeof schema?.type === 'string') {
-        return schema.type;
-    }
-    return 'schema';
+  if (schema?.title && typeof schema.title === 'string') {
+    return schema.title;
+  }
+  if (schema?.type === 'object' || schema?.properties || schema?.$ref) {
+    return 'object';
+  }
+  if (schema?.type === 'array' || schema?.items) {
+    return 'array';
+  }
+  if (schema?.enum !== undefined) {
+    return 'enum';
+  }
+  if (typeof schema?.type === 'string') {
+    return schema.type;
+  }
+  return 'schema';
 }
 
 function isWrappedSchemaPayload(data: any) {
-    if (!data || typeof data !== 'object' || Array.isArray(data)) {
-        return false;
-    }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return false;
+  }
 
-    const entries = Object.entries(data);
-    if (entries.length !== 1) {
-        return false;
-    }
+  const entries = Object.entries(data);
+  if (entries.length !== 1) {
+    return false;
+  }
 
-    return inferSchemaKind(data) === 'unknown' && inferSchemaKind(entries[0]![1]) !== 'unknown';
+  return inferSchemaKind(data) === 'unknown' && inferSchemaKind(entries[0]![1]) !== 'unknown';
 }
 
 function isComplexSchema(schema: any) {
-    return ['object', 'array', 'enum'].includes(inferSchemaKind(schema));
+  return ['object', 'array', 'enum'].includes(inferSchemaKind(schema));
 }
 
 function defaultNameForSchema(schema: any) {
-    const schemaKind = inferSchemaKind(schema);
-
-    if (schemaKind === 'attribute') {
-        return 'attr';
-    }
-    if (schemaKind === 'object' || schemaKind === 'array') {
-        return 'object';
-    }
-    if (schemaKind === 'enum') {
-        return 'enum';
-    }
-
-    return 'schema';
+  const schemaKind = inferSchemaKind(schema);
+
+  if (schemaKind === 'attribute') {
+    return 'attr';
+  }
+  if (schemaKind === 'object' || schemaKind === 'array') {
+    return 'object';
+  }
+  if (schemaKind === 'enum') {
+    return 'enum';
+  }
+
+  return 'schema';
 }
 
 function addComplexSchemaToDefinitions(schemaData: ManagedData, payload: ClipboardSchemaPayload) {
-    const preferredName = payload.name.trim() || deriveNameFromSchema(payload.schema);
-    const schemaKind = inferSchemaKind(payload.schema);
+  const preferredName = payload.name.trim() || deriveNameFromSchema(payload.schema);
+  const schemaKind = inferSchemaKind(payload.schema);
 
-    if (schemaKind === 'enum') {
-        return addSchemaEnum(schemaData, payload.schema, preferredName);
-    }
+  if (schemaKind === 'enum') {
+    return addSchemaEnum(schemaData, payload.schema, preferredName);
+  }
 
-    const elementPath = addSchemaObject(schemaData, false, payload.schema, preferredName);
+  const elementPath = addSchemaObject(schemaData, false, payload.schema, preferredName);
 
-    if (schemaKind === 'array') {
-        return extractArrayItemsToDefinition(schemaData, elementPath, payload);
-    }
+  if (schemaKind === 'array') {
+    return extractArrayItemsToDefinition(schemaData, elementPath, payload);
+  }
 
-    return elementPath;
+  return elementPath;
 }
 
 function addPrimitiveSchemaAsAttribute(
-    schemaData: ManagedData,
-    selectedData: SchemaElementData | undefined,
-    payload: ClipboardSchemaPayload
+  schemaData: ManagedData,
+  selectedData: SchemaElementData | undefined,
+  payload: ClipboardSchemaPayload
 ) {
-    const targetObjectPath = getSelectedObjectPathForAttributePaste(selectedData);
-    if (!targetObjectPath) {
-        throw new Error('Primitive schemas can only be pasted when an object is selected.');
-    }
-
-    const attributePath = findAvailableSchemaId(
-        schemaData,
-        [...targetObjectPath, 'properties'],
-        payload.name.trim() || 'property',
-        true
-    );
-
-    schemaData.setDataAt(attributePath, payload.schema);
-    return attributePath;
+  const targetObjectPath = getSelectedObjectPathForAttributePaste(selectedData);
+  if (!targetObjectPath) {
+    throw new Error('Primitive schemas can only be pasted when an object is selected.');
+  }
+
+  const attributePath = findAvailableSchemaId(
+    schemaData,
+    [...targetObjectPath, 'properties'],
+    payload.name.trim() || 'property',
+    true
+  );
+
+  schemaData.setDataAt(attributePath, payload.schema);
+  return attributePath;
 }
 
 function getSelectedObjectPathForAttributePaste(selectedData: SchemaElementData | undefined) {
-    if (selectedData instanceof SchemaObjectNodeData) {
-        return selectedData.absolutePath;
-    }
+  if (selectedData instanceof SchemaObjectNodeData) {
+    return selectedData.absolutePath;
+  }
 
-    if (selectedData instanceof SchemaObjectAttributeData) {
-        return selectedData.absolutePath.slice(0, -2);
-    }
+  if (selectedData instanceof SchemaObjectAttributeData) {
+    return selectedData.absolutePath.slice(0, -2);
+  }
 
-    return undefined;
+  return undefined;
 }
 
 function isPrimitiveArraySchema(schema: any) {
-    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
-        return false;
-    }
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+    return false;
+  }
 
-    if (!(schema.type === 'array' || schema.items !== undefined)) {
-        return false;
-    }
+  if (!(schema.type === 'array' || schema.items !== undefined)) {
+    return false;
+  }
 
-    const items = schema.items;
-    if (!items || typeof items !== 'object' || Array.isArray(items)) {
-        return false;
-    }
+  const items = schema.items;
+  if (!items || typeof items !== 'object' || Array.isArray(items)) {
+    return false;
+  }
 
-    return inferSchemaKind(items) === 'attribute';
+  return inferSchemaKind(items) === 'attribute';
 }
 
 function extractArrayItemsToDefinition(
-    schemaData: ManagedData,
-    arrayPath: Path,
-    payload: ClipboardSchemaPayload
+  schemaData: ManagedData,
+  arrayPath: Path,
+  payload: ClipboardSchemaPayload
 ) {
-    const arraySchema = schemaData.dataAt(arrayPath);
-    if (!arraySchema?.items || typeof arraySchema.items !== 'object' || arraySchema.items.$ref) {
-        return arrayPath;
-    }
-
-    const itemName = createIdentifierForExtractedElement(
-        undefined,
-        arraySchema.items.title,
-        payload.name + 'Item'
-    );
-
-    return extractInlinedSchemaElement([...arrayPath, 'items'], schemaData, itemName, true);
-}
\ No newline at end of file
+  const arraySchema = schemaData.dataAt(arrayPath);
+  if (!arraySchema?.items || typeof arraySchema.items !== 'object' || arraySchema.items.$ref) {
+    return arrayPath;
+  }
+
+  const itemName = createIdentifierForExtractedElement(
+    undefined,
+    arraySchema.items.title,
+    payload.name + 'Item'
+  );
+
+  return extractInlinedSchemaElement([...arrayPath, 'items'], schemaData, itemName, true);
+}
diff --git a/meta_configurator/src/schema/schemaManipulationUtils.ts b/meta_configurator/src/schema/schemaManipulationUtils.ts
index f68bbffc3..fb24b8dac 100644
--- a/meta_configurator/src/schema/schemaManipulationUtils.ts
+++ b/meta_configurator/src/schema/schemaManipulationUtils.ts
@@ -153,11 +153,10 @@ export function addSchemaObject(
   return objectPath;
 }
 
-
 export function addSchemaEnum(
-    schemaData: ManagedData,
-    schema: any = undefined,
-    identifier: string | undefined = undefined
+  schemaData: ManagedData,
+  schema: any = undefined,
+  identifier: string | undefined = undefined
 ) {
   let enumPath: Path;