@davra/ui-core 1.0.0-alpha.1

package/src/stores/devices.test.ts

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,12 @@
+
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,36 @@
+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))