bfg-common 1.4.651 → 1.4.653

package/plugins/recursion.ts

@@ -1,311 +1,311 @@
-export default defineNuxtPlugin(() => {
-  const recursion = function () {
-    const self: any = {}
-
-    self.find = function (
-      arr: any[],
-      value: any,
-      valueProp: string,
-      itemsProp: string
-    ) {
-      let result = null
-      if (!arr) {
-        return result
-      }
-
-      for (let i = 0; i < arr.length; i++) {
-        const item = arr[i]
-        if (item[valueProp] === value) {
-          result = item
-          break
-        }
-        if (item[itemsProp].length) {
-          result = self.find(item.nodes, value, valueProp, itemsProp)
-          if (result) {
-            break
-          }
-        }
-      }
-      return result
-    }
-    self.findParentNodeByType = function (
-      node: any,
-      types: string[],
-      valueProp: string,
-      parentProp: string
-    ) {
-      if (!node[parentProp] || types.includes(node[valueProp])) {
-        return node
-      }
-
-      if (types.includes(node[parentProp][valueProp])) {
-        return node[parentProp]
-      }
-
-      return self.findParentNodeByType(
-        node[parentProp],
-        types,
-        valueProp,
-        parentProp
-      )
-    }
-
-    self.findAndShow = function (
-      arr: any[],
-      values: any[],
-      valueProps: string[],
-      itemsProp: string
-    ): boolean {
-      if (!arr) return false
-      let res = false
-
-      for (let i = 0; i < arr.length; i++) {
-        const item: any = arr[i]
-
-        const isFind = values.every(
-          (value, index) => value === item[valueProps[index]]
-        )
-        if (isFind) {
-          item.nodesShow = !item.nodesShow // TODO сейчас хардом написано nodesShow, нужно сделать динамически
-          res = true
-          break
-        }
-
-        if (item[itemsProp]?.length) {
-          self.findAndShow(item.nodes, values, valueProps, itemsProp)
-        }
-      }
-      return res
-    }
-
-    self.toggleAll = function (
-      arr: any[],
-      valueProp: string,
-      itemsProp: string,
-      isShow: boolean
-    ): void {
-      if (!arr) return
-
-      for (let i = 0; i < arr.length; i++) {
-        const item: any = arr[i]
-
-        item[valueProp] = isShow
-
-        if (item[itemsProp]?.length) {
-          self.toggleAll(item.nodes, valueProp, itemsProp, isShow)
-        }
-      }
-    }
-
-    self.findAndRemove = function (
-      arr: any[],
-      values: any[],
-      valueProps: string[],
-      itemsProp: string
-    ): boolean {
-      if (!arr) return false
-      let res = false
-
-      for (let i = 0; i < arr.length; i++) {
-        const item: any = arr[i]
-
-        const isFind = values.some(
-          (value, index) => value === item[valueProps[index]]
-        )
-        if (isFind) {
-          arr.splice(i, 1)
-          i--
-          res = true
-        }
-
-        if (item[itemsProp]?.length) {
-          self.findAndRemove(item[itemsProp], values, valueProps, itemsProp)
-        }
-      }
-      return res
-    }
-    self.findAndMove = function (
-      arr: any[],
-      values: any[],
-      valueProps: string[],
-      itemsProp: string,
-      moveArr: any,
-      findIndex: string
-    ) {
-      let result = null
-      if (!arr) return result
-
-      for (let i = 0; i < arr.length; i++) {
-        const item: any = arr[i]
-
-        const isFind = values.every(
-          (value, index) => value === item[valueProps[index]]
-        )
-
-        if (isFind) {
-          // Remove from the original position
-          const moveItem = arr.splice(i, 1)[0]
-          const index = moveArr[itemsProp].findLastIndex(
-            (x) => x.type === findIndex
-          )
-          moveArr[itemsProp].splice(index + 1, 0, moveItem)
-
-          result = moveItem
-          break
-        }
-
-        if (item[itemsProp]?.length) {
-          result = self.findAndMove(
-            item[itemsProp],
-            values,
-            valueProps,
-            itemsProp,
-            moveArr,
-            findIndex
-          )
-          if (result) break
-        }
-      }
-      return result
-    }
-
-    self.findAndActivate = function (
-      arr: any[],
-      values: any[],
-      valueProps: string[],
-      itemsProp: string
-    ): boolean {
-      if (!arr) return false
-      let res = false
-
-      for (let i = 0; i < arr.length; i++) {
-        const item = arr[i]
-        const isActive = values.every(
-          (value, index) => value === item[valueProps[index]]
-        )
-        item.isActive = isActive
-        if (isActive) {
-          res = true
-        }
-
-        if (item[itemsProp]?.length) {
-          const isFindInChild = self.findAndActivate(
-            item.nodes,
-            values,
-            valueProps,
-            itemsProp
-          )
-          if (!res) res = isFindInChild
-        }
-      }
-      return res
-    }
-
-    // TODO изменить nodes и сделать динамичной
-    self.filtrationTreeByExpectedTypeRecursion = (
-      node: any,
-      expectedType: string | string[]
-    ): any[] | null | any => {
-      if (!node.nodes.length) return { ...node }
-
-      const result = []
-
-      for (let i = 0; i < node.nodes.length; i++) {
-        const item = { ...node.nodes[i] }
-
-        // Проверка, является ли тип ожидаемым типом или массивом ожидаемых типов
-        if (
-          (typeof expectedType === 'string' && item.type === expectedType) ||
-          (Array.isArray(expectedType) && expectedType.includes(item.type))
-        ) {
-          result.push(
-            self.filtrationTreeByExpectedTypeRecursion(item, expectedType)
-          )
-        } else {
-          item.nodes = []
-        }
-      }
-      node.nodes = result
-      return { ...node }
-    }
-
-    self.createAbsolutePathRecursion = (
-      node: any,
-      valueProp: string,
-      parentProp: string
-    ): string => {
-      if (!node) return ''
-
-      const parentPath = self.createAbsolutePathRecursion(
-        node[parentProp],
-        valueProp,
-        parentProp
-      )
-      return (parentPath ? `${parentPath}/` : '') + node[valueProp]
-    }
-
-    self.findParentByValue = (
-      node: any,
-      value: any,
-      valueProp: string,
-      parentProp: string
-    ): any | null => {
-      if (!node) return null
-
-      if (node[valueProp] === value) return node
-      const parent = node[parentProp]
-      if (parent)
-        return self.findParentByValue(parent, value, valueProp, parentProp)
-
-      return null
-    }
-
-    self.sortByProp = function (
-      arr: any[],
-      prop: string,
-      up: boolean,
-      itemsProp: string
-    ): void {
-      const value: 1 | -1 = up ? 1 : -1
-      arr.sort((a, b) => {
-        const first = a[prop].toLowerCase()
-        const second = b[prop].toLowerCase()
-        return first < second ? value : first > second ? -value : 0
-      })
-
-      for (let i = 0; i < arr.length; i++) {
-        const item: any = arr[i]
-
-        if (item[itemsProp]?.length) {
-          self.sortByProp(item[itemsProp], prop, up, itemsProp)
-        }
-      }
-    }
-
-    self.calcCount = function (
-        arr: any[],
-        itemsProp: string
-    ): number {
-      if (!arr) return 0
-      let res = 0
-
-      for (let i = 0; i < arr.length; i++) {
-        const item: any = arr[i]
-        res++
-
-        if (item[itemsProp]?.length) {
-          res += self.calcCount(item[itemsProp], itemsProp)
-        }
-      }
-      return res
-    }
-
-    return self
-  }.call({})
-
-  return {
-    provide: {
-      recursion,
-    },
-  }
-})
+export default defineNuxtPlugin(() => {
+  const recursion = function () {
+    const self: any = {}
+
+    self.find = function (
+      arr: any[],
+      value: any,
+      valueProp: string,
+      itemsProp: string
+    ) {
+      let result = null
+      if (!arr) {
+        return result
+      }
+
+      for (let i = 0; i < arr.length; i++) {
+        const item = arr[i]
+        if (item[valueProp] === value) {
+          result = item
+          break
+        }
+        if (item[itemsProp].length) {
+          result = self.find(item.nodes, value, valueProp, itemsProp)
+          if (result) {
+            break
+          }
+        }
+      }
+      return result
+    }
+    self.findParentNodeByType = function (
+      node: any,
+      types: string[],
+      valueProp: string,
+      parentProp: string
+    ) {
+      if (!node[parentProp] || types.includes(node[valueProp])) {
+        return node
+      }
+
+      if (types.includes(node[parentProp][valueProp])) {
+        return node[parentProp]
+      }
+
+      return self.findParentNodeByType(
+        node[parentProp],
+        types,
+        valueProp,
+        parentProp
+      )
+    }
+
+    self.findAndShow = function (
+      arr: any[],
+      values: any[],
+      valueProps: string[],
+      itemsProp: string
+    ): boolean {
+      if (!arr) return false
+      let res = false
+
+      for (let i = 0; i < arr.length; i++) {
+        const item: any = arr[i]
+
+        const isFind = values.every(
+          (value, index) => value === item[valueProps[index]]
+        )
+        if (isFind) {
+          item.nodesShow = !item.nodesShow // TODO сейчас хардом написано nodesShow, нужно сделать динамически
+          res = true
+          break
+        }
+
+        if (item[itemsProp]?.length) {
+          self.findAndShow(item.nodes, values, valueProps, itemsProp)
+        }
+      }
+      return res
+    }
+
+    self.toggleAll = function (
+      arr: any[],
+      valueProp: string,
+      itemsProp: string,
+      isShow: boolean
+    ): void {
+      if (!arr) return
+
+      for (let i = 0; i < arr.length; i++) {
+        const item: any = arr[i]
+
+        item[valueProp] = isShow
+
+        if (item[itemsProp]?.length) {
+          self.toggleAll(item.nodes, valueProp, itemsProp, isShow)
+        }
+      }
+    }
+
+    self.findAndRemove = function (
+      arr: any[],
+      values: any[],
+      valueProps: string[],
+      itemsProp: string
+    ): boolean {
+      if (!arr) return false
+      let res = false
+
+      for (let i = 0; i < arr.length; i++) {
+        const item: any = arr[i]
+
+        const isFind = values.some(
+          (value, index) => value === item[valueProps[index]]
+        )
+        if (isFind) {
+          arr.splice(i, 1)
+          i--
+          res = true
+        }
+
+        if (item[itemsProp]?.length) {
+          self.findAndRemove(item[itemsProp], values, valueProps, itemsProp)
+        }
+      }
+      return res
+    }
+    self.findAndMove = function (
+      arr: any[],
+      values: any[],
+      valueProps: string[],
+      itemsProp: string,
+      moveArr: any,
+      findIndex: string
+    ) {
+      let result = null
+      if (!arr) return result
+
+      for (let i = 0; i < arr.length; i++) {
+        const item: any = arr[i]
+
+        const isFind = values.every(
+          (value, index) => value === item[valueProps[index]]
+        )
+
+        if (isFind) {
+          // Remove from the original position
+          const moveItem = arr.splice(i, 1)[0]
+          const index = moveArr[itemsProp].findLastIndex(
+            (x) => x.type === findIndex
+          )
+          moveArr[itemsProp].splice(index + 1, 0, moveItem)
+
+          result = moveItem
+          break
+        }
+
+        if (item[itemsProp]?.length) {
+          result = self.findAndMove(
+            item[itemsProp],
+            values,
+            valueProps,
+            itemsProp,
+            moveArr,
+            findIndex
+          )
+          if (result) break
+        }
+      }
+      return result
+    }
+
+    self.findAndActivate = function (
+      arr: any[],
+      values: any[],
+      valueProps: string[],
+      itemsProp: string
+    ): boolean {
+      if (!arr) return false
+      let res = false
+
+      for (let i = 0; i < arr.length; i++) {
+        const item = arr[i]
+        const isActive = values.every(
+          (value, index) => value === item[valueProps[index]]
+        )
+        item.isActive = isActive
+        if (isActive) {
+          res = true
+        }
+
+        if (item[itemsProp]?.length) {
+          const isFindInChild = self.findAndActivate(
+            item.nodes,
+            values,
+            valueProps,
+            itemsProp
+          )
+          if (!res) res = isFindInChild
+        }
+      }
+      return res
+    }
+
+    // TODO изменить nodes и сделать динамичной
+    self.filtrationTreeByExpectedTypeRecursion = (
+      node: any,
+      expectedType: string | string[]
+    ): any[] | null | any => {
+      if (!node.nodes.length) return { ...node }
+
+      const result = []
+
+      for (let i = 0; i < node.nodes.length; i++) {
+        const item = { ...node.nodes[i] }
+
+        // Проверка, является ли тип ожидаемым типом или массивом ожидаемых типов
+        if (
+          (typeof expectedType === 'string' && item.type === expectedType) ||
+          (Array.isArray(expectedType) && expectedType.includes(item.type))
+        ) {
+          result.push(
+            self.filtrationTreeByExpectedTypeRecursion(item, expectedType)
+          )
+        } else {
+          item.nodes = []
+        }
+      }
+      node.nodes = result
+      return { ...node }
+    }
+
+    self.createAbsolutePathRecursion = (
+      node: any,
+      valueProp: string,
+      parentProp: string
+    ): string => {
+      if (!node) return ''
+
+      const parentPath = self.createAbsolutePathRecursion(
+        node[parentProp],
+        valueProp,
+        parentProp
+      )
+      return (parentPath ? `${parentPath}/` : '') + node[valueProp]
+    }
+
+    self.findParentByValue = (
+      node: any,
+      value: any,
+      valueProp: string,
+      parentProp: string
+    ): any | null => {
+      if (!node) return null
+
+      if (node[valueProp] === value) return node
+      const parent = node[parentProp]
+      if (parent)
+        return self.findParentByValue(parent, value, valueProp, parentProp)
+
+      return null
+    }
+
+    self.sortByProp = function (
+      arr: any[],
+      prop: string,
+      up: boolean,
+      itemsProp: string
+    ): void {
+      const value: 1 | -1 = up ? 1 : -1
+      arr.sort((a, b) => {
+        const first = a[prop].toLowerCase()
+        const second = b[prop].toLowerCase()
+        return first < second ? value : first > second ? -value : 0
+      })
+
+      for (let i = 0; i < arr.length; i++) {
+        const item: any = arr[i]
+
+        if (item[itemsProp]?.length) {
+          self.sortByProp(item[itemsProp], prop, up, itemsProp)
+        }
+      }
+    }
+
+    self.calcCount = function (
+        arr: any[],
+        itemsProp: string
+    ): number {
+      if (!arr) return 0
+      let res = 0
+
+      for (let i = 0; i < arr.length; i++) {
+        const item: any = arr[i]
+        res++
+
+        if (item[itemsProp]?.length) {
+          res += self.calcCount(item[itemsProp], itemsProp)
+        }
+      }
+      return res
+    }
+
+    return self
+  }.call({})
+
+  return {
+    provide: {
+      recursion,
+    },
+  }
+})