@davra/ui-core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/src/stores/devices.test.ts

@@ -1,149 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useDevicesStore } from './devices'
-import devicesService from '~/services/devicesService'
-import type { Device } from '~/types'
-vi.mock('~/services/davraApi')
-
-describe('Devices Store', () => {
-  beforeEach(() => {
-    // creates a fresh pinia and make it active so it's automatically picked
-    // up by any useStore() call without having to pass it to it:
-    // `useStore(pinia)`
-    setActivePinia(createPinia())
-  })
-
-  it('should fetch devices by UUIDs and update the collection', async () => {
-    const store = useDevicesStore()
-
-    // Mock the DevicesService
-    const mockedDevice = { UUID: '123', name: 'Mocked device' } as Device
-    const mockedDevicesRequest = { records: [mockedDevice], totalRecords: 1 }
-    const mockedGetDeviceByUUIDs = vi.spyOn(devicesService, 'getDeviceByUUIDs').mockResolvedValue(mockedDevicesRequest)
-
-    // Call the store method
-    await store.pullDevicesByUUIDs(['123'], false)
-
-    // Check the result
-    expect(mockedGetDeviceByUUIDs).toHaveBeenCalledWith(['123'])
-    expect(store.devicesCollection).toEqual({ 123: mockedDevice })
-  })
-
-  it('pullDevicesByUUIDs should fetch devices by UUIDs and update the collection and purge the previous records', async () => {
-    const store = useDevicesStore()
-    store.devicesCollection = { qwe124: { UUID: 'qwe124', name: 'Mocked device' } as Device }
-    // Mock the DevicesService
-    const mockedDevice = { UUID: '123', name: 'Mocked device' } as Device
-    const mockedDevicesRequest = { records: [mockedDevice], totalRecords: 1 }
-    const mockedGetDeviceByUUIDs = vi.spyOn(devicesService, 'getDeviceByUUIDs').mockResolvedValue(mockedDevicesRequest)
-
-    // Call the store method
-    const result = await store.pullDevicesByUUIDs(['qwe124', '123'], true)
-
-    // Check the result
-    expect(mockedGetDeviceByUUIDs).toHaveBeenCalledWith(['qwe124', '123'])
-    expect(store.devicesCollection).toEqual({ 123: mockedDevice })
-    expect(result).toEqual(mockedDevicesRequest)
-  })
-
-  it('pullDevicesByUUIDs should return empty records when the api throw an error', async () => {
-    const store = useDevicesStore()
-    store.devicesCollection = { qwe124: { UUID: 'qwe124', name: 'Mocked device' } as Device }
-    // Mock the DevicesService
-    const mockedGetDeviceByUUIDs = vi.spyOn(devicesService, 'getDeviceByUUIDs').mockRejectedValue(new Error('ERROR'))
-
-    // Call the store method
-    await store.pullDevicesByUUIDs(['qwe124', '123'], true)
-
-    // Check the result
-    expect(mockedGetDeviceByUUIDs).toHaveBeenCalledWith(['qwe124', '123'])
-    expect(store.devicesCollection).toEqual({})
-  })
-
-  it('pullDevices should fetch devices and update the collection', async () => {
-    const store = useDevicesStore()
-
-    // Mock the DevicesService
-    const mockedDevice = { UUID: '123', name: 'Mocked device' } as Device
-    const mockedDevicesRequest = { totalRecords: 1, records: [mockedDevice] }
-    const mockedGetDevices = vi.spyOn(devicesService, 'getDevices').mockResolvedValue(mockedDevicesRequest)
-
-    // Call the store method
-    const result = await store.pullDevices(0, 10, '', '')
-
-    // Check the result
-    expect(mockedGetDevices).toHaveBeenCalledWith(0, 10, '', '')
-    expect(store.devicesCollection).toEqual({ 123: mockedDevice })
-    expect(result).toEqual(mockedDevicesRequest)
-  })
-
-  it('pullDevices should return empty records when the api throw an error', async () => {
-    const store = useDevicesStore()
-
-    // Mock the DevicesService
-    const mockedGetDevices = vi.spyOn(devicesService, 'getDevices').mockRejectedValue(new Error('ERROR'))
-
-    // Call the store method
-    const result = await store.pullDevices(0, 10, '', '')
-
-    // Check the result
-    expect(mockedGetDevices).toHaveBeenCalledWith(0, 10, '', '')
-    expect(store.devicesCollection).toEqual({})
-    expect(result).toEqual({
-      totalRecords: 0,
-      records: [],
-    })
-  })
-
-  it('getDeviceFromUUID should fetch devices and update the collection', async () => {
-    const store = useDevicesStore()
-
-    // Mock the DevicesService
-    const mockedDevice = { UUID: '123', name: 'Mocked device' } as Device
-    const mockedGetDevices = vi.spyOn(devicesService, 'getDeviceByUUID').mockResolvedValue(mockedDevice)
-
-    // Call the store method
-    const result = await store.getDeviceFromUUID('123')
-
-    // Check the result
-    expect(mockedGetDevices).toHaveBeenCalledWith('123')
-    expect(store.devicesCollection).toEqual({ 123: mockedDevice })
-    expect(result).toEqual(mockedDevice)
-  })
-
-  it('getDeviceFromUUID should return the device if it is already in the cache', async () => {
-    const store = useDevicesStore()
-    store.devicesCollection = { 123: { UUID: '123', name: 'Mocked device' } as Device }
-
-    // Mock the DevicesService
-    const mockedDevice = { UUID: '123', name: 'Mocked device' } as Device
-    const mockedGetDevices = vi.spyOn(devicesService, 'getDeviceByUUID').mockResolvedValue(mockedDevice)
-
-    // Call the store method
-    const result = await store.getDeviceFromUUID('123')
-
-    // Check the result
-    expect(mockedGetDevices).not.toHaveBeenCalled()
-    expect(store.devicesCollection).toEqual({ 123: mockedDevice })
-    expect(result).toEqual(mockedDevice)
-  })
-
-  it('getDeviceFromUUID should return empty records when the api throw an error', async () => {
-    const store = useDevicesStore()
-
-    // Mock the DevicesService
-    const mockedGetDevices = vi.spyOn(devicesService, 'getDeviceByUUID').mockRejectedValue(new Error('ERROR'))
-
-    // Call the store method
-    const result = await store.getDeviceFromUUID('123')
-
-    // Check the result
-    expect(mockedGetDevices).toHaveBeenCalledWith('123')
-    expect(store.devicesCollection).toEqual({ })
-    expect(result).toEqual(null)
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-})

package/src/stores/devices.ts

@@ -1,78 +0,0 @@
-import { acceptHMRUpdate, defineStore } from 'pinia'
-import type { Ref } from 'vue'
-import DevicesService from '~/services/devicesService'
-import type { Device } from '~/types'
-
-export const useDevicesStore = defineStore('devices', () => {
-  const devicesCollection: Ref<{ [UUID: string]: Device }> = ref({})
-
-  const pullDevicesByUUIDs = async (uuids: string[], forceClear = false) => {
-    if (forceClear) {
-      uuids.forEach((uuid) => {
-        delete devicesCollection.value[uuid]
-      })
-    }
-    try {
-      const devicesRequest = await DevicesService.getDeviceByUUIDs(uuids)
-      devicesRequest.records.forEach((device: Device) => {
-        // may need to sanitize the devices
-        devicesCollection.value[device.UUID] = device
-      })
-      return devicesRequest
-    }
-    catch (err) {
-      return {
-        totalRecords: 0,
-        records: [],
-      }
-    }
-  }
-
-  const pullDevices = async (start: number, limit: number, sort: string, filters: string) => {
-    try {
-      const devicesRequest = await DevicesService.getDevices(start, limit, sort, filters)
-      devicesRequest.records.forEach((device: Device) => {
-        // may need to sanitize the devices
-        devicesCollection.value[device.UUID] = device
-      })
-      return devicesRequest
-    }
-    catch (err) {
-      return {
-        totalRecords: 0,
-        records: [],
-      }
-    }
-  }
-
-  const getDeviceFromUUID = async (uuid: string, fromCache?: boolean) => {
-    const deviceCache = devicesCollection.value[uuid]
-    if (deviceCache) {
-      return deviceCache
-    }
-    else if (!fromCache) {
-      try {
-        const device = await DevicesService.getDeviceByUUID(uuid)
-        if (device) {
-          devicesCollection.value[device.UUID] = device
-          return device
-        }
-      }
-      catch (err) {
-        return null
-      }
-    }
-    else {
-      return null
-    }
-  }
-
-  return {
-    pullDevicesByUUIDs,
-    pullDevices,
-    devicesCollection,
-    getDeviceFromUUID,
-  }
-})
-if (import.meta.hot)
-  import.meta.hot.accept(acceptHMRUpdate(useDevicesStore, import.meta.hot))

package/src/stores/index.ts

@@ -1,12 +0,0 @@
-
-export { useAlertMessagesStore } from './alertMessages'
-
-export { useUserSessionStore } from './userSession'
-
-export { useDevicesStore } from './devices'
-export { useTwinsStore } from './twins'
-export { useLabelsStore } from './labels'
-export { useTwinTypesStore } from './twinTypes'
-export { useMetricsStore } from './metrics'
-
-

package/src/stores/labels.test.ts

@@ -1,72 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useLabelsStore } from './labels'
-import { useTwinTypesStore } from './twinTypes'
-import labelsService from '~/services/labelsService'
-
-describe('Labels Store', () => {
-  beforeEach(() => {
-    // creates a fresh pinia and make it active so it's automatically picked
-    // up by any useStore() call without having to pass it to it:
-    // `useStore(pinia)`
-    vi.mock('~/services/davraApi')
-    setActivePinia(createPinia())
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('init store with empty setting', () => {
-    const labelsStore = useLabelsStore()
-    expect(labelsStore.labels).toEqual([])
-  })
-
-  it('pullLabels to an empty store', async () => {
-    const mockLabels = ['label1', 'label2']
-
-    const labelStore = useLabelsStore()
-
-    const spyGetLabels = vi.spyOn(labelsService, 'getLabels').mockResolvedValue(mockLabels)
-
-    await labelStore.pullLabels()
-
-    expect(spyGetLabels).toHaveBeenCalledOnce()
-
-    expect(labelStore.labels).toEqual(mockLabels)
-  })
-
-  it('updateLabels to an empty store', async () => {
-    const mockLabels = { label3: 'hi' }
-    const mockTwinTypes = { _id: '5fbd141b5d07a511c71dec1c', name: 'twinType1', description: 'sample description', labels: {}, customAttributes: {}, tenantId: 'ruban', UUID: '33b4de5a-800e-4314-9c2b-bcb3d30f37e8', created: 1606226971844, owner: '04fdbec2a4a7477b856c63fc128f3ca8' }
-
-    const labelStore = useLabelsStore()
-    const twinStores = useTwinTypesStore()
-    twinStores.twinTypes = [mockTwinTypes]
-    const spyGetLabels = vi.spyOn(labelsService, 'getLabels').mockResolvedValue(['label3'])
-    const spyCreateLabels = vi.spyOn(labelsService, 'createLabel').mockResolvedValue(true)
-
-    await labelStore.updateLabels(mockLabels)
-
-    expect(spyGetLabels).toHaveBeenCalledOnce()
-    expect(spyCreateLabels).toHaveBeenLastCalledWith(mockLabels, [mockTwinTypes.name])
-  })
-
-  it('handle an error without crashing', async () => {
-    const mockTwinTypes = { _id: '5fbd141b5d07a511c71dec1c', name: 'twinType1', description: 'sample description', labels: {}, customAttributes: {}, tenantId: 'ruban', UUID: '33b4de5a-800e-4314-9c2b-bcb3d30f37e8', created: 1606226971844, owner: '04fdbec2a4a7477b856c63fc128f3ca8' }
-
-    const twinStores = useTwinTypesStore()
-    twinStores.twinTypes = [mockTwinTypes]
-    const labelStore = useLabelsStore()
-    const mError = new Error('Unable to retrieve twintypes')
-    const spyGetLabels = vi.spyOn(labelsService, 'getLabels').mockRejectedValueOnce(mError)
-    const spyCreateLabel = vi.spyOn(labelsService, 'createLabel').mockRejectedValueOnce(mError)
-    await labelStore.pullLabels()
-    expect(spyGetLabels).toHaveBeenCalledOnce()
-
-    await labelStore.updateLabels({ test: 'qwe' })
-    expect(spyCreateLabel).toHaveBeenCalledOnce()
-
-    expect(labelStore.labels).toEqual([])
-  })
-})

package/src/stores/labels.ts

@@ -1,39 +0,0 @@
-import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
-import type { Ref } from 'vue'
-import { useTwinTypesStore } from './twinTypes'
-import LabelsService from '~/services/labelsService'
-export const useLabelsStore = defineStore('labels', () => {
-  const labels: Ref<string[]> = ref([])
-
-  const pullLabels = async () => {
-    try {
-      const labelsRequest = await LabelsService.getLabels()
-      labels.value = labelsRequest
-    }
-    catch {
-
-    }
-  }
-
-  const updateLabels = async (labels: { [key: string]: string }) => {
-    const { twinTypeNames } = storeToRefs(useTwinTypesStore())
-    try {
-      await LabelsService.createLabel(labels, twinTypeNames.value)
-      await pullLabels()
-    }
-    catch {
-
-    }
-  }
-
-  // init store
-  pullLabels()
-
-  return {
-    labels,
-    pullLabels,
-    updateLabels,
-  }
-})
-if (import.meta.hot)
-  import.meta.hot.accept(acceptHMRUpdate(useLabelsStore, import.meta.hot))

package/src/stores/metrics.test.ts

@@ -1,116 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useMetricsStore } from './metrics'
-import MetricsService from '~/services/metricsService'
-import MetricCountersService from '~/services/metricsCountersService'
-import type { Metric } from '~/types'
-
-describe('Labels Store', () => {
-  beforeEach(() => {
-    // creates a fresh pinia and make it active so it's automatically picked
-    // up by any useStore() call without having to pass it to it:
-    // `useStore(pinia)`
-    setActivePinia(createPinia())
-  })
-
-  afterEach(() => {
-  })
-
-  it('init store with empty setting', () => {
-    const metricsStore = useMetricsStore()
-    expect(metricsStore.metrics).toEqual([])
-  })
-
-  it('pullMetrics to an empty store', async () => {
-    const mockMetrics = [{
-      name: '43040_100',
-      label: 'Memory',
-    },
-    {
-      name: '43040_101',
-      label: 'CPU',
-    }]
-
-    const metricsStore = useMetricsStore()
-
-    const spyGetLabels = vi.spyOn(MetricsService, 'getMetrics').mockResolvedValue(mockMetrics)
-
-    await metricsStore.pullMetrics()
-
-    expect(spyGetLabels).toHaveBeenCalledOnce()
-
-    expect(metricsStore.metrics).toEqual(mockMetrics)
-  })
-
-  it('pullMetricsCounters to an empty store', async () => {
-    const mockMetricsCounter = [{
-      name: '43040_100',
-      count: 111,
-      metadata: {},
-      values: [],
-    },
-    {
-      name: '43040_101',
-      count: 121,
-      metadata: {},
-      values: [],
-
-    }]
-
-    const spyGetLabelsCounter = vi.spyOn(MetricCountersService, 'getMetricsCounters').mockResolvedValue(mockMetricsCounter)
-
-    const metricsStore = useMetricsStore()
-
-    await metricsStore.pullMetricsCounters()
-
-    expect(spyGetLabelsCounter).toHaveBeenCalledTimes(1)
-
-    expect(metricsStore.metricsCounters).toEqual(mockMetricsCounter)
-  })
-  it('pullMetricsCounters with an API ERROR', async () => {
-    const spyGetLabelsCounter = vi.spyOn(MetricCountersService, 'getMetricsCounters').mockRejectedValue(new Error('Error!'))
-
-    const metricsStore = useMetricsStore()
-
-    await metricsStore.pullMetricsCounters()
-
-    expect(spyGetLabelsCounter).toHaveBeenCalledTimes(1)
-
-    expect(metricsStore.metricsCounters).toEqual([])
-  })
-
-  it('saveMetric to an empty store', async () => {
-    const mockMetric: Metric = {
-      name: 'test',
-      label: 'test1',
-    }
-    const spyGetMetric = vi.spyOn(MetricsService, 'getMetrics').mockResolvedValue([])
-    const spyCreateMetric = vi.spyOn(MetricsService, 'postMetric').mockResolvedValue({})
-    const spyGetLabelsCounter = vi.spyOn(MetricCountersService, 'getMetricsCounters').mockResolvedValue([])
-
-    const metricsStore = useMetricsStore()
-
-    await metricsStore.saveMetric(mockMetric)
-
-    expect(spyGetMetric).toHaveBeenCalledTimes(2)
-    expect(spyGetLabelsCounter).toHaveBeenCalledTimes(1)
-    expect(spyCreateMetric).toHaveBeenLastCalledWith(mockMetric)
-  })
-  it('saveMetric to with an API ERROR', async () => {
-    const mockMetric: Metric = {
-      name: 'test',
-      label: 'test1',
-    }
-    const spyGetMetric = vi.spyOn(MetricsService, 'getMetrics').mockResolvedValue([])
-    const spyCreateMetric = vi.spyOn(MetricsService, 'postMetric').mockRejectedValue(new Error('API ERROR!'))
-    const spyGetLabelsCounter = vi.spyOn(MetricCountersService, 'getMetricsCounters').mockResolvedValue([])
-
-    const metricsStore = useMetricsStore()
-
-    expect(await metricsStore.saveMetric(mockMetric)).toEqual(false)
-
-    expect(spyGetMetric).toHaveBeenCalledTimes(2)
-    expect(spyGetLabelsCounter).toHaveBeenCalledTimes(1)
-    expect(spyCreateMetric).toHaveBeenLastCalledWith(mockMetric)
-  })
-})

package/src/stores/metrics.ts

@@ -1,71 +0,0 @@
-import { acceptHMRUpdate, defineStore } from 'pinia'
-import type { Ref } from 'vue'
-import MetricsService from '~/services/metricsService'
-import MetricCountersService from '~/services/metricsCountersService'
-import type { Metric, MetricCounter } from '~/types'
-export const useMetricsStore = defineStore('metrics', () => {
-  const metrics: Ref<Metric[]> = ref([])
-  const metricsCounters: Ref<MetricCounter[]> = ref([])
-
-  const getMetricCounter: ComputedRef<(metricName: string) => MetricCounter | undefined > = computed(() => {
-    return (metricName: string) => {
-      return metricsCounters.value?.find((metricCounter: MetricCounter) => metricCounter.name === metricName)
-    }
-  })
-
-  const metricsArr = computed(() => metrics.value.map(m => ({ title: `${m.label} ${m.name}`, label: m.label, value: m.name })))
-
-  const pullMetrics = async (ifEmpty?: boolean) => {
-    if (ifEmpty && metrics.value.length)
-      return
-
-    try {
-      const metricsRequest = await MetricsService.getMetrics()
-      metrics.value = metricsRequest
-    }
-    catch (err: any) {
-      useAlertMessagesStore().setSnackbarMessage(err, 'error')
-    }
-  }
-
-  const pullMetricsCounters = async () => {
-    try {
-      const metricsRequest = await MetricCountersService.getMetricsCounters()
-      metricsCounters.value = metricsRequest
-    }
-    catch (err: any) {
-      useAlertMessagesStore().setSnackbarMessage(err, 'error')
-    }
-  }
-
-  const saveMetric = async (metric: Metric) => {
-    let res = false
-    try {
-      await MetricsService.postMetric(metric)
-      res = true
-      useAlertMessagesStore().setSnackbarMessage(`Metric ${metric.name} successfully saved`, 'success')
-    }
-    catch (err: any) {
-      useAlertMessagesStore().setSnackbarMessage(err, 'error')
-    }
-    await pullMetrics()
-    await pullMetricsCounters()
-
-    return res
-  }
-
-  // init store
-  pullMetrics()
-
-  return {
-    metrics,
-    metricsCounters,
-    pullMetrics,
-    pullMetricsCounters,
-    getMetricCounter,
-    saveMetric,
-    metricsArr,
-  }
-})
-if (import.meta.hot)
-  import.meta.hot.accept(acceptHMRUpdate(useMetricsStore, import.meta.hot))

package/src/stores/twinTypes.test.ts

@@ -1,71 +0,0 @@
-import { createPinia, setActivePinia } from 'pinia'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useTwinTypesStore } from './twinTypes'
-import twinTypesService from '~/services/twinTypesService'
-vi.mock('~/services/davraApi')
-
-describe('Twintypes Store', () => {
-  beforeEach(() => {
-    // creates a fresh pinia and make it active so it's automatically picked
-    // up by any useStore() call without having to pass it to it:
-    // `useStore(pinia)`
-    setActivePinia(createPinia())
-    vi.spyOn(twinTypesService, 'getTwinTypes').mockResolvedValue([])
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('init store with empty setting', () => {
-    const twintypeStore = useTwinTypesStore()
-    expect(twintypeStore.twinTypes).toEqual([])
-  })
-
-  it('pullTwinTypes to an empty store', async () => {
-    const mockTwinTypes = [{
-      _id: '5fb7fdd919ed592dd321d767',
-      tenantId: 'ruban',
-      UUID: 'e8cc8e7d-900b-49da-b3df-43dceb101690',
-      created: 1605893593664,
-      owner: '451e5a4868b3fd5bda206fc82e436ac3',
-      name: 'stateful_incident',
-      description: 'Default type for stateful incidents. Do not delete.',
-      customAttributes: {},
-    },
-    {
-      _id: '5fbd141f5d07a570541dec20',
-      name: 'testTypes',
-      description: 'sample description',
-      labels: {},
-      customAttributes: {
-        testAttribute: 'x',
-      },
-      tenantId: 'ruban',
-      UUID: 'de68d333-7cd6-45ff-bfb4-d7d55b99eec5',
-      created: 1606226975987,
-      owner: '451e5a4868b3fd5bda206fc82e436ac3',
-    }]
-
-    const labelStore = useTwinTypesStore()
-
-    const spyGetTwinTypes = vi.spyOn(twinTypesService, 'getTwinTypes').mockResolvedValue(mockTwinTypes)
-
-    await labelStore.pullTwinTypes()
-
-    expect(spyGetTwinTypes).toHaveBeenCalledOnce()
-
-    expect(labelStore.twinTypes).toEqual(mockTwinTypes)
-    expect(labelStore.twinTypeNames).toEqual(['stateful_incident', 'testTypes'])
-  })
-
-  it('handle an error without crashing', async () => {
-    const labelStore = useTwinTypesStore()
-    const mError = new Error('Unable to retrieve twintypes')
-    const spyGetTwinTypes = vi.spyOn(twinTypesService, 'getTwinTypes').mockRejectedValueOnce(mError)
-    await labelStore.pullTwinTypes()
-    expect(spyGetTwinTypes).toHaveBeenCalledOnce()
-
-    expect(labelStore.twinTypes).toEqual([])
-  })
-})

package/src/stores/twinTypes.ts

@@ -1,36 +0,0 @@
-import { acceptHMRUpdate, defineStore } from 'pinia'
-import type { Ref } from 'vue'
-import TwinTypesService from '~/services/twinTypesService'
-import type { TwinType } from '~/types'
-
-export const useTwinTypesStore = defineStore('twinTypes', () => {
-  const twinTypes: Ref<TwinType[]> = ref([])
-
-  const twinTypeNames = computed(() => {
-    return twinTypes.value.map(twinType => twinType.name)
-  })
-  const twinTypeSelectArray = computed(() => {
-    return twinTypes.value.map((twintype: any) => ({ value: twintype.UUID, label: twintype.name }))
-  })
-
-  const pullTwinTypes = async () => {
-    try {
-      const twinTypesRequest = await TwinTypesService.getTwinTypes()
-      twinTypes.value = twinTypesRequest
-    }
-    catch {
-    }
-  }
-
-  // init store
-  pullTwinTypes()
-
-  return {
-    twinTypes,
-    pullTwinTypes,
-    twinTypeNames,
-    twinTypeSelectArray,
-  }
-})
-if (import.meta.hot)
-  import.meta.hot.accept(acceptHMRUpdate(useTwinTypesStore, import.meta.hot))