@raclettejs/core 0.1.18 → 0.1.19

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.19] - 12.12.2025 <a href="https://gitlab.com/raclettejs/core/-/compare/v0.1.18...v0.1.19" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
+
+### Added
+
+- Global: added bulk import to interactionLinks, compositions and tags
+
 ## [0.1.18] - 05.12.2025 <a href="https://gitlab.com/raclettejs/core/-/compare/v0.1.17...v0.1.18" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
@@ -69,7 +69,7 @@
   },
   "devDependencies": {
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "^0.1.18",
+    "@raclettejs/types": "0.1.19",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
     "@types/node": "24.5.1",

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/composition/composition.service.ts

@@ -337,6 +337,90 @@ export class CompositionService {
     payload.body.deleted = [composition._id]
     fastify.emit("compositionHardDeleted", payload)
 
+    return payload
+  }
+  /**
+   * Core function to create multiple compositions (returns raw data)
+   */
+  async _createCompositions(
+    fastify: PluginFastifyInstance,
+    compositionBodies: CompositionBody[],
+    userId: string,
+  ): Promise<CompositionType[]> {
+    try {
+      const compositionsToCreate: CompositionBody[] = []
+
+      // Validate and prepare all compositions
+      for (const compositionBody of compositionBodies) {
+        if (compositionBody._id) {
+          const uuidValid = validate(compositionBody._id)
+
+          if (!uuidValid) {
+            throw new Error(
+              `Invalid ID - not a valid uuid v4: ${compositionBody._id}`,
+            )
+          }
+
+          const duplicate = await this.compositionModel.findOne({
+            _id: compositionBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${compositionBody._id}`,
+            )
+          }
+        } else {
+          compositionBody._id = uuidv4()
+        }
+
+        compositionsToCreate.push({
+          ...compositionBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const compositions =
+        await this.compositionModel.insertMany(compositionsToCreate)
+
+      fastify.log.info(
+        `[API] Created ${compositions.length} compositions in bulk`,
+      )
+
+      return compositions.map((comp) =>
+        comp.toObject ? comp.toObject() : comp,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple compositions with payload wrapping and event emission
+   */
+  async createCompositions(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    compositionBodies: CompositionBody[],
+    userId: string,
+  ): Promise<FrontendPayload<CompositionType[]>> {
+    const compositions = await this._createCompositions(
+      fastify,
+      compositionBodies,
+      userId,
+    )
+
+    const payload = await createCompositionPayload(
+      fastify,
+      compositions,
+      requestData,
+    )
+
+    fastify.emit("compositionsCreated", payload)
+
     return payload
   }
 }

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/composition/routes/index.ts

@@ -4,6 +4,7 @@ import getAll from "./route.composition.getAll"
 import hardDelete from "./route.composition.hardDelete"
 import patch from "./route.composition.patch"
 import post from "./route.composition.post"
+import postBulk from "./route.composition.post.bulk"
 import remove from "./route.composition.remove"
 import restore from "./route.composition.restore"
 
@@ -13,6 +14,7 @@ const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.patch("/composition/:_id", patch(fastify))
   await fastify.patch("/composition/:_id/restore", restore(fastify))
   await fastify.post("/composition", post(fastify))
+  await fastify.post("/composition/bulk", postBulk(fastify))
   await fastify.delete("/composition/:_id", remove(fastify))
   await fastify.delete("/composition/:_id/hard", hardDelete(fastify))
 }

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/composition/routes/route.composition.post.bulk.ts

@@ -0,0 +1,58 @@
+import type { CompositionBody } from "../composition.service"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { compositionCreateSchema } from "../composition.schema"
+
+export default (fastify: PluginFastifyInstance) => {
+  const compositionService = fastify.custom.compositionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: CompositionBody[]
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Validate that body is an array
+      if (!Array.isArray(req.body)) {
+        return reply.badRequest("Request body must be an array of compositions")
+      }
+
+      // Validate that array is not empty
+      if (req.body.length === 0) {
+        return reply.badRequest("Request body cannot be an empty array")
+      }
+
+      const payload = await compositionService.createCompositions(
+        fastify,
+        req.requestParams,
+        req.body,
+        req.user._id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["compositionsCreated"],
+    },
+    schema: {
+      summary: "Create multiple compositions in bulk",
+      tags: ["core/composition"],
+      body: {
+        type: "array",
+        items: compositionCreateSchema,
+        minItems: 1,
+      },
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/interactionLink/interactionLink.service.ts

@@ -130,16 +130,16 @@ export class InteractionLinkService {
   }
 
   /**
-   * Core function to get interaction links by composition ID (returns raw data)
+   * Core function to get interaction links by interactionLink ID (returns raw data)
    */
-  async _readInteractionLinksByComposition(
+  async _readInteractionLinksByInteractionLink(
     fastify: PluginFastifyInstance,
-    compositionId: string,
+    interactionLinkId: string,
   ): Promise<InteractionLinkType[]> {
     try {
       return await this.interactionLinkModel
         .find({
-          composition: compositionId,
+          interactionLink: interactionLinkId,
           isDeleted: false,
         })
         .lean()
@@ -150,16 +150,16 @@ export class InteractionLinkService {
   }
 
   /**
-   * Get interaction links by composition ID with payload wrapping
+   * Get interaction links by interactionLink ID with payload wrapping
    */
-  async readInteractionLinksByComposition(
+  async readInteractionLinksByInteractionLink(
     fastify: PluginFastifyInstance,
     requestData: FrontendPayloadRequestData,
-    compositionId: string,
+    interactionLinkId: string,
   ): Promise<FrontendPayload<InteractionLinkType[]>> {
-    const interactionLinks = await this._readInteractionLinksByComposition(
+    const interactionLinks = await this._readInteractionLinksByInteractionLink(
       fastify,
-      compositionId,
+      interactionLinkId,
     )
 
     return createInteractionLinkPayload(fastify, interactionLinks, requestData)
@@ -439,6 +439,91 @@ export class InteractionLinkService {
 
     return createInteractionLinkPayload(fastify, interactionLinks, requestData)
   }
+  /**
+   * Core function to create multiple interactionLinks (returns raw data)
+   */
+  async _createInteractionLinks(
+    fastify: PluginFastifyInstance,
+    interactionLinkBodies: InteractionLinkBody[],
+    userId: string,
+  ): Promise<InteractionLinkType[]> {
+    try {
+      const interactionLinksToCreate: InteractionLinkBody[] = []
+
+      // Validate and prepare all interactionLinks
+      for (const interactionLinkBody of interactionLinkBodies) {
+        if (interactionLinkBody._id) {
+          const uuidValid = validate(interactionLinkBody._id)
+
+          if (!uuidValid) {
+            throw new Error(
+              `Invalid ID - not a valid uuid v4: ${interactionLinkBody._id}`,
+            )
+          }
+
+          const duplicate = await this.interactionLinkModel.findOne({
+            _id: interactionLinkBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${interactionLinkBody._id}`,
+            )
+          }
+        } else {
+          interactionLinkBody._id = uuidv4()
+        }
+
+        interactionLinksToCreate.push({
+          ...interactionLinkBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const interactionLinks = await this.interactionLinkModel.insertMany(
+        interactionLinksToCreate,
+      )
+
+      fastify.log.info(
+        `[API] Created ${interactionLinks.length} interactionLinks in bulk`,
+      )
+
+      return interactionLinks.map((comp) =>
+        comp.toObject ? comp.toObject() : comp,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple interactionLinks with payload wrapping and event emission
+   */
+  async createInteractionLinks(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    interactionLinkBodies: InteractionLinkBody[],
+    userId: string,
+  ): Promise<FrontendPayload<InteractionLinkType[]>> {
+    const interactionLinks = await this._createInteractionLinks(
+      fastify,
+      interactionLinkBodies,
+      userId,
+    )
+
+    const payload = await createInteractionLinkPayload(
+      fastify,
+      interactionLinks,
+      requestData,
+    )
+
+    fastify.emit("interactionLinksCreated", payload)
+
+    return payload
+  }
 }
 
 export const createInteractionLinkService = (

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/interactionLink/routes/index.ts

@@ -4,6 +4,7 @@ import getAll from "./route.interactionLink.getAll"
 import hardDelete from "./route.interactionLink.hardDelete"
 import patch from "./route.interactionLink.patch"
 import post from "./route.interactionLink.post"
+import postBulk from "./route.interactionLink.post.bulk"
 import remove from "./route.interactionLink.remove"
 import restore from "./route.interactionLink.restore"
 
@@ -13,6 +14,7 @@ const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.patch("/interactionLink/:_id", patch(fastify))
   await fastify.patch("/interactionLink/:_id/restore", restore(fastify))
   await fastify.post("/interactionLink", post(fastify))
+  await fastify.post("/interactionLink/bulk", postBulk(fastify))
   await fastify.delete("/interactionLink/:_id", remove(fastify))
   await fastify.delete("/interactionLink/:_id/hard", hardDelete(fastify))
 }

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/interactionLink/routes/route.interactionLink.post.bulk.ts

@@ -0,0 +1,60 @@
+import type { InteractionLinkBody } from "../interactionLink.service"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { interactionLinkCreateSchema } from "../interactionLink.schema"
+
+export default (fastify: PluginFastifyInstance) => {
+  const interactionLinkService = fastify.custom.interactionLinkService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: InteractionLinkBody[]
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Validate that body is an array
+      if (!Array.isArray(req.body)) {
+        return reply.badRequest(
+          "Request body must be an array of interactionLinks",
+        )
+      }
+
+      // Validate that array is not empty
+      if (req.body.length === 0) {
+        return reply.badRequest("Request body cannot be an empty array")
+      }
+
+      const payload = await interactionLinkService.createInteractionLinks(
+        fastify,
+        req.requestParams,
+        req.body,
+        req.user._id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["interactionLinksCreated"],
+    },
+    schema: {
+      summary: "Create multiple interactionLinks in bulk",
+      tags: ["core/interactionLink"],
+      body: {
+        type: "array",
+        items: interactionLinkCreateSchema,
+        minItems: 1,
+      },
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/index.ts

@@ -4,6 +4,7 @@ import getAll from "./route.tag.getAll"
 import hardDelete from "./route.tag.hardDelete"
 import patch from "./route.tag.patch"
 import post from "./route.tag.post"
+import postBulk from "./route.tag.post.bulk"
 import remove from "./route.tag.remove"
 import restore from "./route.tag.restore"
 
@@ -13,6 +14,7 @@ const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.patch("/tag/:_id", patch(fastify))
   await fastify.patch("/tag/:_id/restore", restore(fastify))
   await fastify.post("/tag/:project/:_id", post(fastify))
+  await fastify.post("/tag/bulk", postBulk(fastify))
   await fastify.delete("/tag/:_id", remove(fastify))
   await fastify.delete("/tag/:_id/hard", hardDelete(fastify))
 }

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/route.tag.post.bulk.ts

@@ -0,0 +1,58 @@
+import type { TagBody } from "../tag.service"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { tagCreateSchema } from "../tag.schema"
+
+export default (fastify: PluginFastifyInstance) => {
+  const tagService = fastify.custom.tagService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: TagBody[]
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Validate that body is an array
+      if (!Array.isArray(req.body)) {
+        return reply.badRequest("Request body must be an array of tags")
+      }
+
+      // Validate that array is not empty
+      if (req.body.length === 0) {
+        return reply.badRequest("Request body cannot be an empty array")
+      }
+
+      const payload = await tagService.createTags(
+        fastify,
+        req.requestParams,
+        req.body,
+        req.user._id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["tagsCreated"],
+    },
+    schema: {
+      summary: "Create multiple tags in bulk",
+      tags: ["core/tag"],
+      body: {
+        type: "array",
+        items: tagCreateSchema,
+        minItems: 1,
+      },
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/tag.service.ts

@@ -8,7 +8,9 @@ import type { PluginFastifyInstance } from "types"
 import { v4 as uuidv4, validate } from "uuid"
 import { createTagPayload } from "./helpers/payload"
 import type { Model } from "mongoose"
-
+export type TagBody = Partial<Omit<TagType, "_id">> & {
+  _id?: string
+}
 export class TagService {
   private tagModel: Model<TagType>
 
@@ -369,6 +371,75 @@ export class TagService {
 
     fastify.emit("tagHardDeleted", payload)
 
+    return payload
+  }
+  /**
+   * Core function to create multiple tags (returns raw data)
+   */
+  async _createTags(
+    fastify: PluginFastifyInstance,
+    tagBodies: TagBody[],
+    userId: string,
+  ): Promise<TagType[]> {
+    try {
+      const tagsToCreate: TagBody[] = []
+
+      // Validate and prepare all tags
+      for (const tagBody of tagBodies) {
+        if (tagBody._id) {
+          const uuidValid = validate(tagBody._id)
+
+          if (!uuidValid) {
+            throw new Error(`Invalid ID - not a valid uuid v4: ${tagBody._id}`)
+          }
+
+          const duplicate = await this.tagModel.findOne({
+            _id: tagBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${tagBody._id}`,
+            )
+          }
+        } else {
+          tagBody._id = uuidv4()
+        }
+
+        tagsToCreate.push({
+          ...tagBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const tags = await this.tagModel.insertMany(tagsToCreate)
+
+      fastify.log.info(`[API] Created ${tags.length} tags in bulk`)
+
+      return tags.map((comp) => (comp.toObject ? comp.toObject() : comp))
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple tags with payload wrapping and event emission
+   */
+  async createTags(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    tagBodies: TagBody[],
+    userId: string,
+  ): Promise<FrontendPayload<TagType[]>> {
+    const tags = await this._createTags(fastify, tagBodies, userId)
+
+    const payload = await createTagPayload(fastify, tags, requestData)
+
+    fastify.emit("tagsCreated", payload)
+
     return payload
   }
 }

package/services/frontend/src/core/lib/data/dataApi.ts

@@ -29,7 +29,16 @@ const $writeDataApi = (
       const _executeParams = clone(executeParams)
       errorSubject$.next(null)
       responseSubject$.next({})
-      const queryParams = mergeDeepRight(_params, _executeParams)
+      let queryParams
+      if (Array.isArray(_executeParams)) {
+        if (Array.isArray(_params)) {
+          queryParams = _params.concat(_executeParams)
+        }
+        queryParams = _executeParams
+      } else {
+        queryParams = mergeDeepRight(_params, _executeParams)
+      }
+
       if (options.responseType === "stream") {
         return writeData(actionId, operationDefinition, queryParams, options)
       }

package/services/frontend/src/core/lib/eggs/snow.ts

@@ -7,11 +7,13 @@ export default () => {
 
   // This function allows you to turn on and off the snow
   const toggle_snow = () => {
-    const check_box = document.getElementById("toggle_snow")
+    const check_box = document.getElementById(
+      "toggle_snow",
+    ) as HTMLInputElement | null
     const snowEl = document.getElementById("snow")
 
     if (snowEl) {
-      snowEl.style.display = check_box.checked ? "block" : "none"
+      snowEl.style.display = check_box?.checked ? "block" : "none"
     }
   }
 
@@ -29,87 +31,74 @@ export default () => {
       const randomDuration = 8 + Math.random() * 15 // Duration between 8-23s
       const randomDelay = Math.random() * 10 // Delay between 0-10s
       const randomOpacity = 0.3 + Math.random() * 0.7 // Opacity between 0.3-1
-      const randomAnimation = Math.floor(Math.random() * 5) + 1 // Choose from 5 animations
+      const randomAnimation = Math.floor(Math.random() * 3) + 1 // Choose from 3 animations
 
-      snowflake.style.setProperty("--start-x", `${randomX}vw`)
-      snowflake.style.setProperty("--scale", randomScale)
+      snowflake.style.setProperty("--start-x", `${randomX}%`)
+      snowflake.style.setProperty("--scale", randomScale.toString())
       snowflake.style.setProperty("--duration", `${randomDuration}s`)
       snowflake.style.setProperty("--delay", `${randomDelay}s`)
-      snowflake.style.setProperty("--opacity", randomOpacity)
+      snowflake.style.setProperty("--opacity", randomOpacity.toString())
       snowflake.style.setProperty("--animation-name", `fall-${randomAnimation}`)
 
       fragment.appendChild(snowflake)
     }
 
-    document.getElementById("snow").appendChild(fragment)
+    document.getElementById("snow")?.appendChild(fragment)
   }
 
-  // Optimized CSS with reusable animations and CSS custom properties
+  // Optimized CSS with GPU acceleration and simplified animations
   const createOptimizedCSS = () => {
     const css = `
       #snow {
         position: fixed;
         top: 0;
         left: 0;
-        width: 100%;
-        height: 100%;
+        right: 0;
+        bottom: 0;
         pointer-events: none;
         z-index: 1000;
+        overflow: hidden;
       }
 
       .snowflake {
         position: absolute;
+        top: -10px;
         width: 8px;
         height: 8px;
         background: white;
         border-radius: 50%;
-        filter: drop-shadow(0 0 6px rgba(255, 255, 255, 0.8));
+        
+        /* GPU acceleration - critical for performance */
         will-change: transform;
+        transform: translateZ(0);
+        backface-visibility: hidden;
+        
+        /* Simplified glow effect - much lighter than drop-shadow filter */
+        box-shadow: 0 0 6px rgba(255, 255, 255, 0.6);
         
         /* Use CSS custom properties for individual variations */
         left: var(--start-x);
         opacity: var(--opacity);
-        transform: scale(var(--scale));
         animation: var(--animation-name) var(--duration) var(--delay) linear infinite;
       }
 
-      /* 5 different falling patterns for variety */
+      /* Simplified to 3 falling patterns - uses only transform for best performance */
       @keyframes fall-1 {
-        0% { transform: translateY(-10px) translateX(0) scale(var(--scale)); }
-        25% { transform: translateY(25vh) translateX(10px) scale(var(--scale)); }
-        50% { transform: translateY(50vh) translateX(-5px) scale(var(--scale)); }
-        75% { transform: translateY(75vh) translateX(8px) scale(var(--scale)); }
-        100% { transform: translateY(100vh) translateX(0) scale(var(--scale)); }
+        to { 
+          transform: translateY(100vh) translateX(20px) scale(var(--scale)) translateZ(0);
+        }
       }
 
       @keyframes fall-2 {
-        0% { transform: translateY(-10px) translateX(0) scale(var(--scale)); }
-        30% { transform: translateY(30vh) translateX(-15px) scale(var(--scale)); }
-        60% { transform: translateY(60vh) translateX(10px) scale(var(--scale)); }
-        100% { transform: translateY(100vh) translateX(-5px) scale(var(--scale)); }
+        to { 
+          transform: translateY(100vh) translateX(-20px) scale(var(--scale)) translateZ(0);
+        }
       }
 
       @keyframes fall-3 {
-        0% { transform: translateY(-10px) translateX(0) scale(var(--scale)); }
-        20% { transform: translateY(20vh) translateX(5px) scale(var(--scale)); }
-        40% { transform: translateY(40vh) translateX(-10px) scale(var(--scale)); }
-        70% { transform: translateY(70vh) translateX(15px) scale(var(--scale)); }
-        100% { transform: translateY(100vh) translateX(0) scale(var(--scale)); }
-      }
-
-      @keyframes fall-4 {
-        0% { transform: translateY(-10px) translateX(0) scale(var(--scale)); }
-        35% { transform: translateY(35vh) translateX(20px) scale(var(--scale)); }
-        65% { transform: translateY(65vh) translateX(-8px) scale(var(--scale)); }
-        100% { transform: translateY(100vh) translateX(12px) scale(var(--scale)); }
-      }
-
-      @keyframes fall-5 {
-        0% { transform: translateY(-10px) translateX(0) scale(var(--scale)); }
-        15% { transform: translateY(15vh) translateX(-5px) scale(var(--scale)); }
-        45% { transform: translateY(45vh) translateX(12px) scale(var(--scale)); }
-        80% { transform: translateY(80vh) translateX(-7px) scale(var(--scale)); }
-        100% { transform: translateY(100vh) translateX(3px) scale(var(--scale)); }
+        to { 
+          transform: translateY(100vh) translateX(0px) scale(var(--scale)) translateZ(0);
+        }
       }
     `
 
@@ -142,7 +131,7 @@ export default () => {
     } else {
       // Remove existing snow
       snowEl.remove()
-      // Optionally remove styles as well
+      // Remove styles as well
       const styles = document.getElementById("snow-styles")
       if (styles) {
         styles.remove()

package/services/frontend/src/orchestrator/i18n/de-DE.json

@@ -75,8 +75,22 @@
     "openInFloatingWindow": "In extrafenster öffnen",
     "showDeleted": "Zeige gelöschte",
     "hideDeleted": "Verstecke gelöschte",
+    "selectAll": "Alle auswählen",
+    "selected": "ausgewählt",
+    "noItemsSelected": "Keine Elemente ausgewählt. Bitte wählen Sie mindestens ein Element aus, um fortzufahren.",
     "cancel": "Abbrechen",
     "close": "Schließen",
+    "itemsCount": "Anzahl der Elemente",
+    "selectedItems": "Ausgewählte Elemente",
+    "selectItemsToExport": "Elemente zum Exportieren auswählen",
+    "export": "Exportieren",
+    "selectItemsToImport": "Elemente zum Importieren auswählen",
+    "import": "Importieren",
+    "exportSummary": "Export-Zusammenfassung",
+    "exportSuccessMessage": "Elemente wurden erfolgreich exportiert",
+    "importSummary": "Import-Zusammenfassung",
+    "importSuccessMessage": "Elemente bereit zum Importieren",
+    "saveImported": "Importierte Elemente speichern",
     "clear": "Leeren",
     "copyToClipboard$name": "{name} in Zwischenablage kopieren",
     "timeAgo": "vor {time}",

package/services/frontend/src/orchestrator/i18n/en-EU.json

@@ -75,8 +75,22 @@
     "openInFloatingWindow": "Open in floating window",
     "showDeleted": "Show deleted",
     "hideDeleted": "Hide deleted",
+    "selectAll": "Select All",
+    "selected": "selected",
+    "noItemsSelected": "No items selected. Please select at least one item to continue.",
     "cancel": "Cancel",
     "close": "Close",
+    "itemsCount": "Items count",
+    "selectedItems": "Selected items",
+    "selectItemsToExport": "Select Items to Export",
+    "export": "Export",
+    "selectItemsToImport": "Select Items to Import",
+    "import": "Import",
+    "exportSummary": "Export Summary",
+    "exportSuccessMessage": "Items have been successfully exported",
+    "importSummary": "Import Summary",
+    "importSuccessMessage": "Items ready to import",
+    "saveImported": "Save Imported Items",
     "clear": "Clear",
     "copyToClipboard$name": "Copy {name} to clipboard",
     "timeAgo": "{time} ago",

package/services/frontend/src/orchestrator/i18n/sk.json

@@ -75,8 +75,22 @@
     "openInFloatingWindow": "Otvoriť v plávajúcom okne",
     "showDeleted": "relácia vymazaná",
     "hideDeleted": "skryť odstránené",
+    "selectAll": "Vybrať všetko",
+    "selected": "vybrané",
+    "noItemsSelected": "Nie sú vybrané žiadne položky. Vyberte aspoň jednu položku pre pokračovanie.",
     "cancel": "Zrušiť",
     "close": "Zavrieť",
+    "itemsCount": "Počet položiek",
+    "selectedItems": "Vybrané položky",
+    "selectItemsToExport": "Vyberte položky na export",
+    "export": "Exportovať",
+    "selectItemsToImport": "Vyberte položky na import",
+    "import": "Importovať",
+    "exportSummary": "Súhrn exportu",
+    "exportSuccessMessage": "Položky boli úspešne exportované",
+    "importSummary": "Súhrn importu",
+    "importSuccessMessage": "Položky pripravené na import",
+    "saveImported": "Uložiť importované položky",
     "clear": "Vyčistiť",
     "copyToClipboard$name": "Skopírovať {name} do schránky",
     "timeAgo": "pred {time}",

package/yarn.lock

@@ -295,10 +295,10 @@
   resolved "https://registry.yarnpkg.com/@pkgr/core/-/core-0.2.9.tgz#d229a7b7f9dac167a156992ef23c7f023653f53b"
   integrity sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==
 
-"@raclettejs/types@^0.1.18":
-  version "0.1.18"
-  resolved "https://registry.yarnpkg.com/@raclettejs/types/-/types-0.1.18.tgz#7df0eb1b86db015694fabfafa089a277e654b350"
-  integrity sha512-mvQI2sO48z6+QKj/s5A5JMBKnY8piE+8D8N0soctfsU7tAKg8nEwlxOiQHZiqJyR1k+gX2p+VBMRGbxHCYAGFw==
+"@raclettejs/types@^0.1.19":
+  version "0.1.19"
+  resolved "https://registry.yarnpkg.com/@raclettejs/types/-/types-0.1.19.tgz#5f17afcc3b8f2d4849c828648711c426fdb2f74d"
+  integrity sha512-EdIMglaM+ivsvkVaXZKVKBoyXsLivulloveYPEV70Lm1iLeja6l7IywyM82dMdEgNMmpEMlG8r2TjHyXu9MPkg==
   dependencies:
     "@types/node" "24.5.2"
     fastify "5.6.0"