@sigmaott/base-next 1.0.6

package/src/composables/useQueryAssets.ts

@@ -0,0 +1,56 @@
+import type { MaybeRef } from '@vueuse/shared'
+import { QueryKeys } from '../enums'
+
+export function useQueryAssets(params: MaybeRef<Record<string, any>>, enabled: MaybeRef<boolean>, refetchOnWindowFocus = true) {
+  return useQuery(
+    [QueryKeys.ASSET, params],
+    () => $libraryApi('api/library/assets', { query: params.value }),
+    {
+      enabled,
+      keepPreviousData: true,
+      refetchOnWindowFocus,
+      select: (res) => {
+        return {
+          ...res,
+          data: res.data.map(item => ({
+            ...item,
+            thumbUri: getAssetURI(item.thumbUri, ASSET_DEV_URL),
+            uri: getAssetURI(item.uri, ASSET_DEV_URL),
+          })) || [],
+        }
+      },
+    },
+  )
+}
+
+// 👉 - Transform assetIds to assetInfo
+export function useTransformAssetData(_assetIds) {
+  const assetIds = toRef(_assetIds)
+  const q = computed(() => {
+    return {
+      q: JSON.stringify({
+        id: { $in: assetIds.value },
+      }),
+      page: 1,
+      perPage: assetIds.value.length || 10,
+    }
+  })
+  const enabled = computed(() => assetIds.value.length > 0)
+  const { data } = useQueryAssets(q, enabled, false)
+
+  const assetInfo = computed(() => {
+    return assetIds.value.map(id => data?.value?.data.find(item => item.id === id) || '/logo') || []
+  })
+
+  const assetInfoObject = computed(() => {
+    return assetIds.value.reduce((acc, id) => {
+      const asset = data?.value?.data.find(item => item.id === id)
+      if (asset)
+        acc[id] = asset
+
+      return acc
+    }, {} as Record<string, any>)
+  })
+
+  return { assetInfo, assetInfoObject }
+}

package/src/composables/useQueryParams.ts

@@ -0,0 +1,20 @@
+import type { WritableComputedRef } from 'vue'
+
+/**
+ * Transform reactive 'q' string parameter for API request
+ * @param qRaw - The raw query string
+ * @param defaultValue - The default value for query string
+ */
+export function useQueryParams(
+  qRaw: Ref<string | undefined> | WritableComputedRef<string | undefined>,
+  defaultValue?: Record<string, any>,
+) {
+  // if not qRaw, set it as default value
+  const q = ref<Record<string, any>>(qRaw.value ? JSON.parse(qRaw.value || '{}') : defaultValue)
+
+  watch(q, (newVal) => {
+    qRaw.value = JSON.stringify(newVal)
+  }, { immediate: true, deep: true })
+
+  return q
+}

package/src/composables/useRouteParams.ts

@@ -0,0 +1,36 @@
+import destr from 'destr'
+import type { MaybeRefOrGetter, Ref } from 'vue'
+import { defu } from 'defu'
+
+export function useRouteParams<T extends object, K extends object>(
+  defaultValue: T,
+  additionValue?: K,
+  disabledSync?: MaybeRefOrGetter<boolean>,
+): Ref<T & K> {
+  const router = useRouter()
+
+  function getQuery() {
+    const query = klona(router.currentRoute.value.query)
+    const filter = !toValue(disabledSync) ? destr(query.filter) : defaultValue
+    return defu(additionValue, filter, defaultValue)
+  }
+
+  const reactiveQuery = ref(getQuery()) as Ref<T & K>
+
+  watch(reactiveQuery, (newValue) => {
+    if (!toValue(disabledSync)) {
+      const newQuery = klona(newValue) as any
+      // remove property from additionValue
+      Object.keys(additionValue || {}).forEach(key => delete newQuery[key])
+      const query = router.currentRoute.value.query
+
+      router.push({ query: { ...query, filter: JSON.stringify(newQuery) } })
+    }
+  }, { deep: true })
+
+  onMounted(() => {
+    reactiveQuery.value = getQuery()
+  })
+
+  return reactiveQuery
+}

package/src/composables/useRouteQueries.ts

@@ -0,0 +1,54 @@
+import { objectMap } from '@antfu/utils'
+import { objectPick } from '@vueuse/core'
+import { defu } from 'defu'
+
+export function useRouteQueries<T extends object>(
+  defaultValue: T,
+) {
+  const router = useRouter()
+
+  function getQuery() {
+    const query = router.currentRoute.value.query
+    const queryState = objectPick(query, Object.keys(defaultValue)) as T
+    return objectMap(queryState, (k, v) => {
+      let value: any = v
+      try {
+        value = JSON.parse(v)
+      }
+      catch {
+        value = v
+      }
+      return [k, value]
+    })
+  }
+
+  const reactiveQuery = reactive(defu(getQuery(), defaultValue))
+
+  watch(() => reactiveQuery, (newValue) => {
+    const newQuery = objectMap(newValue, (k, v) => [k, JSON.stringify(v)])
+    const query = router.currentRoute.value.query
+    router.push({ query: { ...query, ...newQuery } })
+  }, { deep: true })
+
+  onActivated(() => {
+    Object.assign(reactiveQuery, { ...getQuery() })
+  })
+
+  return toRefs(reactiveQuery)
+}
+
+export const useHistoryLength = createSharedComposable(() => {
+  const initialLength = window.history.length
+  const historyLength = ref(window.history.length)
+
+  const canGoBack = computed(() => historyLength.value - initialLength > 0)
+  return { historyLength, canGoBack }
+})
+
+// Put at the root component: App.vue
+export function useHistoryLengthProvider() {
+  const { historyLength } = useHistoryLength()
+  useRouter().afterEach(() => {
+    historyLength.value = window.history.length
+  })
+}

package/src/composables/useRouterHistory.ts

@@ -0,0 +1,76 @@
+import { getQuery, withQuery } from 'ufo'
+
+export function useRouterHistory() {
+  const router = useRouter()
+  const route = useRoute()
+
+  /**
+   * Navigate to a new route while storing the current route for back navigation
+   */
+  function navigateWithHistory(options: { path: string, query?: Record<string, any> }) {
+    router.push({
+      path: options.path,
+      query: {
+        ...options.query,
+        from: route.fullPath,
+      },
+    })
+  }
+
+  // Navigate to a new route while caching the query
+
+  function navigateWithCache(options: { path: string, query?: Record<string, any> }) {
+    router.push({
+      path: options.path,
+      query: {
+        ...route.query,
+      },
+    })
+  }
+
+  /**
+   * Navigate back to the previous route or fallback path
+   */
+  function navigateBack(fallbackPath = '/') {
+    const query = getQuery(fallbackPath)
+    console.log('🚀 ~ navigateBack ~ withQuery(route.query.from, query):', withQuery(route.query.from, query))
+    if (route.query.from) {
+      router.push(withQuery(route.query.from, query))
+    }
+    else {
+      router.push(fallbackPath)
+    }
+  }
+
+  /**
+   * Get the previous route path if it exists
+   */
+  const previousRoute = computed(() => route.query.from as string | undefined)
+
+  /**
+   * Check if there's a previous route to go back to
+   */
+  const hasPreviousRoute = computed(() => !!route.query.from)
+
+  /**
+   * Replace current route while preserving history
+   */
+  function replaceWithHistory(path: string, query: Record<string, any> = {}) {
+    router.replace({
+      path,
+      query: {
+        ...query,
+        from: route.query.from as string,
+      },
+    })
+  }
+
+  return {
+    navigateWithHistory,
+    navigateBack,
+    replaceWithHistory,
+    navigateWithCache,
+    previousRoute,
+    hasPreviousRoute,
+  }
+}

package/src/composables/useSearchQuery.ts

@@ -0,0 +1,27 @@
+import { debouncedWatch } from '@vueuse/core'
+
+interface QuerySearch {
+  $regex: string
+  $options: string
+}
+
+interface Options {
+  debounce: number
+}
+
+export function useSearchQuery(query: Ref<string>,
+  cb: (newQuery?: QuerySearch) => void,
+  options: Options = { debounce: 250 }) {
+  const newQuery = ref()
+  debouncedWatch(
+    query,
+    ($query) => {
+      newQuery.value = $query ? { $regex: $query, $options: 'i' } : undefined
+      if (newQuery.value)
+        cb(newQuery.value)
+      else
+        cb(undefined)
+    },
+    { deep: true, debounce: options.debounce },
+  )
+}

package/src/composables/useTooltipEllipsis.ts

@@ -0,0 +1,12 @@
+export function useTooltipEllipsis() {
+  const disabledTooltip = ref(true)
+  function mouseEnter(event) {
+    if (event.target.offsetWidth < event.target.scrollWidth)
+      disabledTooltip.value = false
+
+    else if (event.target.offsetHeight < event.target.scrollHeight)
+      disabledTooltip.value = false
+    else disabledTooltip.value = true
+  }
+  return { mouseEnter, disabledTooltip }
+}

package/src/constants/env.ts

@@ -0,0 +1,11 @@
+export const ENV = {
+  VITE_HOST: import.meta.env.VITE_HOST as string,
+  VITE_BASE_URL: import.meta.env.VITE_BASE_URL as string,
+  VITE_BASE_PATH: import.meta.env.VITE_BASE_PATH as string,
+  DEV: import.meta.env.DEV as boolean,
+  PROD: import.meta.env.PROD as boolean,
+  NUXT_PUBLIC_API_BASE: window.__NUXT__.config.public.apiBase as string,
+}
+
+export const ASSET_DEV_URL
+= isSubApp || import.meta.env.DEV ? ENV.NUXT_PUBLIC_API_BASE : undefined

package/src/constants/filterable.ts

@@ -0,0 +1,32 @@
+export type TimeRange =
+  'Today' | 'Yesterday' | 'This week' | 'This month'
+  | 'Last 7 days' | 'last_14_days' | 'Last 30 days' | 'custom'
+
+export const TimeRangeOptions = [
+  { label: 'Custom', value: 'custom', key: 'custom' },
+  // { label: 'All time', value: 'all_time', key: 'all_time' },
+  { label: 'Today', value: 'Today', key: 'today' },
+  { label: 'Yesterday', value: 'Yesterday', key: 'yesterday' },
+  { label: 'This week', value: 'This week', key: 'this_week' },
+  { label: 'This month', value: 'This month', key: 'this_month' },
+  // { label: 'This year', value: 'This year', key: 'this_year' },
+  { label: 'Last 7 days', value: 'Last 7 days', key: 'last_7_days' },
+  { label: 'Last 30 days', value: 'Last 30 days', key: 'last_30_days' },
+  // { label: 'Last year', value: 'Last year', key: 'last_year' },
+]
+
+export type TimeUnit = 'hour' | 'day' | 'week' | 'month' | 'year'
+
+export const TimeUnitOptions = [
+  { label: 'Hour', value: 'hour', disabled: true },
+  { label: 'Day', value: 'day' },
+  { label: 'Week', value: 'week' },
+  { label: 'Month', value: 'month', disabled: true },
+  // { label: 'Year', value: 'year' },
+]
+
+export interface FilterDimensionForm {
+  'Events.channelId': string
+  'Events.subChannel'?: string
+  'Events.vastId'?: string
+}

package/src/constants/languageCode.ts

@@ -0,0 +1,185 @@
+export const iso639_3 = {
+  'Abkhazian': 'abk',
+  'Afar': 'aar',
+  'Afrikaans': 'afr',
+  'Akan': 'aka',
+  'Albanian': 'sqi',
+  'Amharic': 'amh',
+  'Arabic': 'ara',
+  'Aragonese': 'arg',
+  'Armenian': 'hye',
+  'Assamese': 'asm',
+  'Avaric': 'ava',
+  'Avestan': 'ave',
+  'Aymara': 'aym',
+  'Azerbaijani': 'aze',
+  'Bambara': 'bam',
+  'Bashkir': 'bak',
+  'Basque': 'eus',
+  'Belarusian': 'bel',
+  'Bengali': 'ben',
+  'Bislama': 'bis',
+  'Bosnian': 'bos',
+  'Breton': 'bre',
+  'Bulgarian': 'bul',
+  'Burmese': 'mya',
+  'Catalan': 'cat',
+  'Chamorro': 'cha',
+  'Chechen': 'che',
+  'Chichewa': 'nya',
+  'Chinese': 'zho',
+  'Church': 'chu',
+  'Chuvash': 'chv',
+  'Cornish': 'cor',
+  'Corsican': 'cos',
+  'Cree': 'cre',
+  'Croatian': 'hrv',
+  'Czech': 'ces',
+  'Danish': 'dan',
+  'Divehi': 'div',
+  'Dutch': 'nld',
+  'Dzongkha': 'dzo',
+  'English': 'eng',
+  'Esperanto': 'epo',
+  'Estonian': 'est',
+  'Ewe': 'ewe',
+  'Faroese': 'fao',
+  'Fijian': 'fij',
+  'Finnish': 'fin',
+  'French': 'fra',
+  'Western': 'fry',
+  'Fulah': 'ful',
+  'Gaelic': 'gla',
+  'Galician': 'glg',
+  'Ganda': 'lug',
+  'Georgian': 'kat',
+  'German': 'deu',
+  'Greek': 'ell',
+  'Kalaallisut': 'kal',
+  'Guarani': 'grn',
+  'Gujarati': 'guj',
+  'Haitian': 'hat',
+  'Hausa': 'hau',
+  'Hebrew': 'heb',
+  'Herero': 'her',
+  'Hindi': 'hin',
+  'Hiri': 'hmo',
+  'Hungarian': 'hun',
+  'Icelandic': 'isl',
+  'Ido': 'ido',
+  'Igbo': 'ibo',
+  'Indonesian': 'ind',
+  'Interlingua': 'ina',
+  'Interlingue': 'ile',
+  'Inuktitut': 'iku',
+  'Inupiaq': 'ipk',
+  'Irish': 'gle',
+  'Italian': 'ita',
+  'Japanese': 'jpn',
+  'Javanese': 'jav',
+  'Kannada': 'kan',
+  'Kanuri': 'kau',
+  'Kashmiri': 'kas',
+  'Kazakh': 'kaz',
+  'Central': 'khm',
+  'Kikuyu': 'kik',
+  'Kinyarwanda': 'kin',
+  'Kirghiz': 'kir',
+  'Komi': 'kom',
+  'Kongo': 'kon',
+  'Korean': 'kor',
+  'Kuanyama': 'kua',
+  'Kurdish': 'kur',
+  'Lao': 'lao',
+  'Latin': 'lat',
+  'Latvian': 'lav',
+  'Limburgan': 'lim',
+  'Lingala': 'lin',
+  'Lithuanian': 'lit',
+  'Luba-Katanga': 'lub',
+  'Luxembourgish': 'ltz',
+  'Macedonian': 'mkd',
+  'Malagasy': 'mlg',
+  'Malay': 'msa',
+  'Malayalam': 'mal',
+  'Maltese': 'mlt',
+  'Manx': 'glv',
+  'Maori': 'mri',
+  'Marathi': 'mar',
+  'Marshallese': 'mah',
+  'Mongolian': 'mon',
+  'Nauru': 'nau',
+  'Navajo': 'nav',
+  'North': 'nde',
+  'South': 'nbl',
+  'Ndonga': 'ndo',
+  'Nepali': 'nep',
+  'Norwegian': 'nno',
+  'Sichuan': 'iii',
+  'Occitan': 'oci',
+  'Ojibwa': 'oji',
+  'Oriya': 'ori',
+  'Oromo': 'orm',
+  'Ossetian': 'oss',
+  'Pali': 'pli',
+  'Pashto': 'pus',
+  'Persian': 'fas',
+  'Polish': 'pol',
+  'Portuguese': 'por',
+  'Punjabi': 'pan',
+  'Quechua': 'que',
+  'Romanian': 'ron',
+  'Romansh': 'roh',
+  'Rundi': 'run',
+  'Russian': 'rus',
+  'Northern': 'sme',
+  'Samoan': 'smo',
+  'Sango': 'sag',
+  'Sanskrit': 'san',
+  'Sardinian': 'srd',
+  'Serbian': 'srp',
+  'Shona': 'sna',
+  'Sindhi': 'snd',
+  'Sinhala': 'sin',
+  'Slovak': 'slk',
+  'Slovenian': 'slv',
+  'Somali': 'som',
+  'Southern': 'sot',
+  'Spanish': 'spa',
+  'Sundanese': 'sun',
+  'Swahili': 'swa',
+  'Swati': 'ssw',
+  'Swedish': 'swe',
+  'Tagalog': 'tgl',
+  'Tahitian': 'tah',
+  'Tajik': 'tgk',
+  'Tamil': 'tam',
+  'Tatar': 'tat',
+  'Telugu': 'tel',
+  'Thai': 'tha',
+  'Tibetan': 'bod',
+  'Tigrinya': 'tir',
+  'Tonga': 'ton',
+  'Tsonga': 'tso',
+  'Tswana': 'tsn',
+  'Turkish': 'tur',
+  'Turkmen': 'tuk',
+  'Twi': 'twi',
+  'Uighur': 'uig',
+  'Ukrainian': 'ukr',
+  'Urdu': 'urd',
+  'Uzbek': 'uzb',
+  'Venda': 'ven',
+  'Vietnamese': 'vie',
+  'Volapük': 'vol',
+  'Walloon': 'wln',
+  'Welsh': 'cym',
+  'Wolof': 'wol',
+  'Xhosa': 'xho',
+  'Yiddish': 'yid',
+  'Yoruba': 'yor',
+  'Zhuang': 'zha',
+  'Zulu': 'zul',
+}
+
+export const langOptions = computed(() => Object.entries(iso639_3))

package/src/constants/micro.ts

@@ -0,0 +1 @@
+export const isSubApp = window.__MICRO_APP_ENVIRONMENT__ ?? window.__POWERED_BY_WUJIE__ ?? false

package/src/constants/queryKeys.ts

@@ -0,0 +1,11 @@
+export const QueryKeys = {
+  PaymentPlan: 'PaymentPlan',
+  AppBillingInfo: 'AppBillingInfo',
+  Noti: '/api/notification/notification',
+  LibraryProfile: 'LibraryProfile',
+  LibraryPreset: 'LibraryPreset',
+  LibraryPresetDetail: 'LibraryPresetDetail',
+  App: 'App',
+  InputDetail: 'InputDetail',
+
+}

package/src/constants/regex.ts

@@ -0,0 +1,8 @@
+export const SPECIAL_CHARACTERS = /[`!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?~]/
+export const SPECIAL_CHARACTERS_NAME = /[`!@#$%^&*()+\=[\]{};':"\\|,.<>/?~\s]/
+export const SPECIAL_CHARACTERS_NAME_NO_DASH_UNDERLINE = /[`!@#$%^&*()+\=[\]{};':"\\|,<>\/?~\s.]/
+
+export const SPECIAL_CHARACTERS_NO_DASH = /[`!@#$%^&*()+=[\]{};':"\\|,.<>/?~]/
+export const SPECIAL_CHARACTERS_NO_DASH_UNDERLINE = /[`!@#$%^&*()+\=[\]{};':"\\|,<>/?~]/
+export const WORD_NO_CONTAINT_ACCENTED_CHARACTERS = /^[a-z0-9A-Z_-]*$/
+export const WORD_REGEX_FULL = /^[a-zA-Z0-9\-_\s]*$/

package/src/constants/storage.ts

@@ -0,0 +1,41 @@
+import { useStorage } from '@vueuse/core'
+import { StorageKeys } from '../enums'
+
+export const TOKEN_STORAGE = useStorage(StorageKeys.TOKEN, '', window.parent?.localStorage || localStorage)
+export const TOKEN_TEMP_STORAGE = useStorage(StorageKeys.__TOKEN_TEMP_STORAGE__, '', window.parent?.localStorage || localStorage)
+export const ADMIN_TOKEN_STORAGE = useStorage(StorageKeys.__ADMIN_TOKEN_STORAGE__, '')
+export const APP_ID_STORAGE = useStorage(StorageKeys.APP_ID, '', window.parent?.sessionStorage || sessionStorage)
+// NOTE: APP_DETAIL_STORAGE = [info, permission]
+export const APP_DETAIL_STORAGE = useStorage(StorageKeys.__APP_DETAIL_STORAGE__, {}, window.parent?.sessionStorage || sessionStorage) as Ref<[any, any]>
+export const ALERTS_TRANSCODE_STORAGE = useStorage(StorageKeys.__ALERTS_TRANSCODE_STORAGE__, {}, window.parent?.sessionStorage || sessionStorage)
+export const SERVER_ADD_LICENSE = useStorage(StorageKeys.__SERVER_ADD_LICENSE__, {}, window.parent?.sessionStorage || sessionStorage)
+export const PAYMENT_METHOD_STORAGE = useStorage(StorageKeys.__PAYMENT_METHOD_STORAGE__, {}, window.parent?.sessionStorage || sessionStorage)
+export const TOKEN_PROP_STORAGE = useStorage(StorageKeys.TOKEN_PROP, '', window.parent?.localStorage || localStorage)
+export const __LANGUAGE__ = useStorage(StorageKeys.__LANGUAGE__, 'en', window.parent?.localStorage || localStorage)
+export const __IS_DARK__ = useStorage(StorageKeys.__IS_DARK__, true, window.parent?.localStorage || localStorage)
+export const SOCIAL_LOGIN_REDIRECT = useStorage('__SOCIAL_LOGIN_REDIRECT__', '')
+export const asideCollapsed = useStorage(StorageKeys.__ASIDE_COLLAPSED__, false, window.parent?.localStorage || localStorage)
+
+const languagesMap: Record<string, string> = {
+  vi: 'vi-VN',
+  en: 'en-US',
+}
+export const TIMEZONE_USER = computed(() => {
+  return APP_DETAIL_STORAGE.value?.[1]?.user?.timezone
+})
+export const HEADER_TOKEN = computed(() => {
+  const commonHeader = {
+    'Accept-Language': languagesMap[__LANGUAGE__.value],
+  }
+  if (TOKEN_STORAGE.value && TOKEN_PROP_STORAGE.value) {
+    return {
+      ...commonHeader,
+      [TOKEN_PROP_STORAGE.value]: `${TOKEN_STORAGE.value}`,
+      ...(APP_ID_STORAGE.value ? { 'X-App-Id': APP_ID_STORAGE.value } : {}),
+    }
+  }
+
+  return {
+    ...commonHeader,
+  }
+})

package/src/enums/index.ts

@@ -0,0 +1,24 @@
+export const QueryKeys = {
+  CHANNEL: 'api/lrm/channels',
+  EVENT: 'api/lrm/events',
+  ASSET: 'api/library/assets',
+  PROGRAM: 'api/lrm/programs',
+  TRANSCODE_CHANNEL: 'TRANSCODE_CHANNEL',
+  EVENT_CHANNEL: 'api/transcode/event-channels',
+  FAST_CHANNEL: 'api/playout/fast-channels',
+}
+
+export const StorageKeys = {
+  __ASIDE_COLLAPSED__: '__ASIDE_COLLAPSED__',
+  TOKEN: '__TOKEN__',
+  __ADMIN_TOKEN_STORAGE__: '__ADMIN_TOKEN_STORAGE__',
+  APP_ID: '__APP_ID__',
+  TOKEN_PROP: '__TOKEN_PROP__',
+  __LANGUAGE__: '__LANGUAGE__',
+  __IS_DARK__: '__IS_DARK__',
+  __APP_DETAIL_STORAGE__: '__APP_DETAIL_STORAGE__',
+  __TOKEN_TEMP_STORAGE__: '__TOKEN_TEMP_STORAGE__',
+  __ALERTS_TRANSCODE_STORAGE__: '__ALERTS_TRANSCODE_STORAGE__',
+  __PAYMENT_METHOD_STORAGE__: '__PAYMENT_METHOD_STORAGE__',
+  __SERVER_ADD_LICENSE__: '__SERVER_ADD_LICENSE__',
+}

package/src/layouts/empty.vue

@@ -0,0 +1,7 @@
+<script lang="ts" setup>
+import '../assets/global.css'
+</script>
+
+<template>
+  <slot />
+</template>

package/src/modules/api-party/kit.ts

@@ -0,0 +1,30 @@
+import { relative } from 'pathe'
+import { addTemplate, createResolver, useNuxt } from '@nuxt/kit'
+
+export function extendTypes(
+  module: string,
+  template: (options: { typesPath: string }) => string | Promise<string>,
+) {
+  const nuxt = useNuxt()
+  const { resolve } = createResolver(import.meta.url)
+
+  addTemplate({
+    filename: `module/${module}.d.ts`,
+    getContents: async () => {
+      const typesPath = relative(
+        resolve(nuxt.options.rootDir, nuxt.options.buildDir, 'module'),
+        resolve('runtime/types'),
+      )
+      const s = await template({ typesPath })
+      return `
+// Generated by ${module}
+${s}`.trimStart()
+    },
+  })
+
+  nuxt.hooks.hook('prepare:types', ({ references }) => {
+    references.push({
+      path: resolve(nuxt.options.buildDir, `module/${module}.d.ts`),
+    })
+  })
+}