@eturnity/eturnity_3d 7.20.1 → 7.24.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eturnity/eturnity_3d",
   "private": false,
-  "version": "7.20.1",
+  "version": "7.24.0",
   "files": [
     "dist",
     "src"
@@ -15,7 +15,7 @@
     "prettier": "prettier --write \"**/*.{js,vue}\""
   },
   "dependencies": {
-    "@eturnity/eturnity_maths": "7.20.0",
+    "@eturnity/eturnity_maths": "7.24.0",
     "@originjs/vite-plugin-commonjs": "1.0.3",
     "core-js": "2.6.12",
     "cors": "2.8.5",

package/src/EventManager/EventManager.js

@@ -0,0 +1,48 @@
+export default class EventManager {
+  constructor() {
+    this.listeners = {}
+    this.availableEvents = []
+  }
+
+  // Add an event listener
+  addEventListener(events, callback) {
+    let eventList = events.split(' ')
+    eventList.forEach((event) => {
+      if (!this.listeners[event]) {
+        this.listeners[event] = []
+      }
+      this.listeners[event].push(callback)
+    })
+  }
+
+  // Remove an event listener
+  removeEventListener(events, callback) {
+    let eventList = events.split(' ')
+    eventList.forEach((event) => {
+      if (this.listeners[event]) {
+        this.listeners[event] = this.listeners[event].filter(
+          (listener) => listener !== callback
+        )
+      }
+    })
+  }
+
+  // Dispatch an event and bubble it up to parent components
+  emit(event, eventData) {
+    //Check if event is available
+    if (!this.availableEvents.includes(event)) {
+      console.error(
+        event,
+        ' not available. Available events:',
+        this.availableEvents
+      )
+    }
+    // Check if the event has listeners
+    if (this.listeners[event]) {
+      // Execute each listener callback
+      this.listeners[event].forEach((callback) => {
+        callback(eventData)
+      })
+    }
+  }
+}

package/src/Item/Item.js

@@ -0,0 +1,12 @@
+import { v4 as uuidv4 } from 'uuid'
+
+export default class Item {
+  constructor(emit) {
+    this.id = uuidv4()
+    this.version = 0
+    this.emit = emit
+    this.actionsAvailable = []
+    this.isSelected = false
+  }
+  serialize() {}
+}

package/src/Layer/Layer.js

@@ -0,0 +1,119 @@
+import EventManager from '../EventManager/EventManager'
+
+export default class LayerManager extends EventManager {
+  constructor() {
+    super()
+    this.items = []
+    this.selectedItemsIds = []
+    this.itemsIds = []
+    this.availableEvents.push(
+      'selected-items-updated',
+      'items-updated',
+      'item-updated',
+      'item-added',
+      'item-removed',
+      'item-selected'
+    )
+  }
+  findById(id) {
+    return this.items.find((item) => item.id == id)
+  }
+  getItems() {
+    return this.items
+  }
+  getReadyItems() {
+    return this.items.filter((item) => item.isReady)
+  }
+  getItemsIds() {
+    return this.itemsIds
+  }
+  getSelectedItemsIds() {
+    return this.selectedItemsIds
+  }
+  getSelectedItems() {
+    return this.items.filter((item) => this.selectedItemsIds.includes(item.id))
+  }
+  setItems(items) {
+    this.items = items
+    this.itemsIds = items.map((i) => i.id)
+    const newSelectedItemsIds = this.selectedItemsIds.filter((id) =>
+      this.itemsIds.includes(id)
+    )
+    this.selectItemsIds(newSelectedItemsIds)
+    this.emit('items-updated', [...this.items])
+  }
+  selectItemsIds(ids) {
+    this.selectedItemsIds = ids
+    this.items.forEach(
+      (item) => (item.isSelected = this.selectedItemsIds.includes(item.id))
+    )
+    this.emit('selected-items-updated', this.selectedItemsIds)
+  }
+  selectItems(items) {
+    const selectedItemsIds = items.map((item) => item.id)
+    this.selectItemsIds(selectedItemsIds)
+  }
+  deselectItems() {
+    this.selectItems([])
+  }
+  toggleSelectionById(id) {
+    let newSelectedItems = this.getSelectedItems()
+    if (this.selectedItemsIds.includes(id)) {
+      newSelectedItems = newSelectedItems.filter((item) => item.id != id)
+    } else {
+      let item = this.findById(id)
+      if (item) {
+        newSelectedItems.push(item)
+      }
+    }
+    this.selectItems(newSelectedItems)
+  }
+  addOrUpdateItem(item) {
+    const id = item.id
+    const existingItemWithSameId = this.items.find((i) => i.id == id)
+    if (existingItemWithSameId) {
+      if (item.version > existingItemWithSameId.version) {
+        this.removeItemById(id)
+      } else {
+        return existingItemWithSameId
+      }
+    }
+    let newItems = [...this.items]
+    newItems.push(item)
+    this.setItems(newItems)
+    this.emit('item-added', item)
+    return item
+  }
+  removeItemById(id) {
+    this.setItems(this.items.filter((item) => item.id != id))
+    this.emit('item-removed')
+  }
+  removeSelectedItems() {
+    this.setItems(this.items.filter((item) => !item.isSelected))
+    this.emit('item-removed')
+  }
+  removeAllItems() {
+    this.setItems([])
+    this.emit('item-removed')
+  }
+  dispatchActionToAllItems(actionName, params) {
+    return this.getItems().map((item) => {
+      if (
+        typeof item[actionName] === 'function' &&
+        item.actionsAvailable.includes(actionName)
+      ) {
+        return item[actionName](params)
+      }
+    })
+  }
+  dispatchActionToItemById(id, actionName, params) {
+    const item = this.findById(id)
+    if (
+      typeof item[actionName] === 'function' &&
+      item.actionsAvailable.includes(actionName)
+    ) {
+      return item[actionName](params)
+    }
+    return
+  }
+}