@dargmuesli/nuxt-cookie-control 8.6.1 → 9.0.0

package/dist/module.json

@@ -1,12 +1,12 @@
 {
   "name": "@dargmuesli/nuxt-cookie-control",
-  "version": "8.6.1",
+  "version": "9.0.0",
   "configKey": "cookieControl",
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
   "builder": {
-    "@nuxt/module-builder": "0.8.4",
+    "@nuxt/module-builder": "1.0.0",
     "unbuild": "unknown"
   }
 }

package/dist/module.mjs

@@ -16,8 +16,7 @@ const execSrcReplacements = (src, replacements) => {
       throw new TypeError(
         "[vite-plugin-replace]: The replacement option 'to' is not of type 'string' or 'Function'"
       );
-    } else
-      src = src.replace(replacement.from, replacement.to);
+    } else src = src.replace(replacement.from, replacement.to);
   }
   return src;
 };
@@ -105,7 +104,7 @@ const DEFAULTS = {
 };
 
 const name = "@dargmuesli/nuxt-cookie-control";
-const version = "8.6.1";
+const version = "9.0.0";
 
 const resolver = createResolver(import.meta.url);
 const runtimeDir = resolver.resolve("./runtime");
@@ -216,8 +215,7 @@ const loadLocales = async (moduleOptions) => {
   moduleOptions.locales = [];
   for (const locale of locales) {
     const text = await import(pathToFileURL(await resolvePath(resolve(runtimeDir, "locale", locale))).href).then((r) => r.default || r);
-    if (!text)
-      throw new Error(`Could not import text for locale ${locale}`);
+    if (!text) throw new Error(`Could not import text for locale ${locale}`);
     moduleOptions.locales.push(locale);
     moduleOptions.localeTexts[locale] = {
       ...text,

package/dist/runtime/components/ClientOnlyPrerender.vue

@@ -5,9 +5,8 @@
   </ClientOnly>
 </template>
 
-<script setup lang="ts">
-import { useRuntimeConfig } from '#app'
-
-const runtimeConfig = useRuntimeConfig()
-const isPrerendered = runtimeConfig.public.cookieControl._isPrerendered
+<script setup>
+import { useRuntimeConfig } from "#app";
+const runtimeConfig = useRuntimeConfig();
+const isPrerendered = runtimeConfig.public.cookieControl._isPrerendered;
 </script>

package/dist/runtime/components/ClientOnlyPrerender.vue.d.ts

@@ -0,0 +1,19 @@
+declare const isPrerendered: any;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_1: {}, __VLS_8: {};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_8) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<{}, {
+    isPrerendered: typeof isPrerendered;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/CookieControl.vue

@@ -16,13 +16,13 @@
             <div class="cookieControl__BarButtons">
               <button
                 type="button"
-                @click="accept()"
+                @click="acceptAll()"
                 v-text="localeStrings?.accept"
               />
               <button
                 v-if="moduleOptions.isAcceptNecessaryButtonEnabled"
                 type="button"
-                @click="decline()"
+                @click="acceptNecessary()"
                 v-text="localeStrings?.decline"
               />
               <button
@@ -76,11 +76,8 @@
                 <template v-if="moduleOptions.cookies[cookieType].length">
                   <h2
                     v-text="
-                      localeStrings &&
-                      (cookieType === CookieType.NECESSARY
-                        ? localeStrings.cookiesNecessary
-                        : localeStrings.cookiesOptional)
-                    "
+  localeStrings && (cookieType === CookieType.NECESSARY ? localeStrings.cookiesNecessary : localeStrings.cookiesOptional)
+"
                   />
                   <ul>
                     <li
@@ -91,25 +88,22 @@
                         <div class="cookieControl__ModalInputWrapper">
                           <input
                             v-if="
-                              cookieType === CookieType.NECESSARY &&
-                              cookie.name !== 'functional'
-                            "
-                            :id="resolveTranslatable(cookie.name, props.locale)"
+  cookieType === CookieType.NECESSARY && cookie.name !== 'functional'
+"
+                            :id="resolveTranslatable(cookie.name, locale)"
                             type="checkbox"
                             disabled
                             checked
                           />
                           <input
                             v-else
-                            :id="resolveTranslatable(cookie.name, props.locale)"
+                            :id="resolveTranslatable(cookie.name, locale)"
                             type="checkbox"
                             :checked="
-                              isConsentGiven === undefined
-                                ? cookie.isPreselected
-                                : getCookieIds(localCookiesEnabled).includes(
-                                    cookie.id,
-                                  )
-                            "
+  isConsentGiven === void 0 ? cookie.isPreselected : getCookieIds(localCookiesEnabled).includes(
+    cookie.id
+  )
+"
                             @change="toogleCookie(cookie)"
                           />
                           <button type="button" @click="toggleButton($event)">
@@ -117,9 +111,7 @@
                           </button>
                           <label
                             class="cookieControl__ModalCookieName"
-                            :for="
-                              resolveTranslatable(cookie.name, props.locale)
-                            "
+                            :for="resolveTranslatable(cookie.name, locale)"
                             tabindex="0"
                             @keydown="toggleLabel($event)"
                           >
@@ -129,16 +121,12 @@
                             </span>
                             <span
                               v-if="
-                                moduleOptions.isCookieIdVisible &&
-                                cookie.targetCookieIds
-                              "
+  moduleOptions.isCookieIdVisible && cookie.targetCookieIds
+"
                             >
                               <br />
                               {{
-                                'IDs: ' +
-                                cookie.targetCookieIds
-                                  .map((id) => `"${id}"`)
-                                  .join(', ')
+                                "IDs: " + cookie.targetCookieIds.map((id) => `"${id}"`).join(", ")
                               }}
                             </span>
                             <template
@@ -146,18 +134,16 @@
                             >
                               <span
                                 v-for="entry in Object.entries(
-                                  cookie.links || {},
-                                )"
+  cookie.links || {}
+)"
                                 :key="entry[0]"
                               >
                                 <br />
                                 <NuxtLink
                                   :to="entry[0]"
                                   @click="
-                                    !entry[0].toLowerCase().startsWith('http')
-                                      ? (isModalActive = false)
-                                      : null
-                                  "
+  !entry[0].toLowerCase().startsWith('http') ? isModalActive = false : null
+"
                                 >
                                   {{ entry[1] || entry[0] }}
                                 </NuxtLink>
@@ -174,32 +160,32 @@
                 <button
                   type="button"
                   @click="
-                    () => {
-                      acceptPartial()
-                      isModalActive = false
-                    }
-                  "
+  () => {
+    acceptPartial();
+    isModalActive = false;
+  }
+"
                   v-text="localeStrings?.save"
                 />
                 <button
                   type="button"
                   @click="
-                    () => {
-                      accept()
-                      isModalActive = false
-                    }
-                  "
+  () => {
+    acceptNecessary();
+    isModalActive = false;
+  }
+"
                   v-text="localeStrings?.acceptAll"
                 />
                 <button
                   v-if="!moduleOptions.isModalForced"
                   type="button"
                   @click="
-                    () => {
-                      declineAll()
-                      isModalActive = false
-                    }
-                  "
+  () => {
+    acceptNone();
+    isModalActive = false;
+  }
+"
                   v-text="localeStrings?.declineAll"
                 />
               </div>
@@ -211,243 +197,186 @@
   </ClientOnlyPrerender>
 </template>
 
-<script setup lang="ts">
-import { ref, computed, onBeforeMount, watch } from 'vue'
-
-import ClientOnlyPrerender from '#cookie-control/components/ClientOnlyPrerender.vue'
-import { COOKIE_ID_SEPARATOR } from '#cookie-control/constants'
+<script setup>
+import { ref, computed, onBeforeMount, watch } from "vue";
+import { COOKIE_ID_SEPARATOR } from "#cookie-control/constants";
 import {
   getAllCookieIdsString,
   getCookieIds,
   removeCookie,
-  resolveTranslatable,
-} from '#cookie-control/methods'
-import setCssVariables from '#cookie-control/set-vars'
-import {
-  type Cookie,
-  CookieType,
-  type Locale,
-  type Translatable,
-} from '#cookie-control/types'
-import { useCookieControl, useCookie, useNuxtApp } from '#imports'
-
-interface Props {
-  locale?: Locale
-}
-const props = withDefaults(defineProps<Props>(), {
-  locale: 'en',
-})
-
+  resolveTranslatable
+} from "#cookie-control/methods";
+import setCssVariables from "#cookie-control/set-vars";
+import { useCookieControl, useCookie, useNuxtApp } from "#imports";
+const { locale = "en" } = defineProps({
+  locale: {
+    type: String,
+    required: false
+  }
+});
 const {
   cookiesEnabled,
   cookiesEnabledIds,
   isConsentGiven,
   isModalActive,
-  moduleOptions,
-} = useCookieControl()
-const nuxtApp = useNuxtApp()
-
-// data
-const expires = new Date(Date.now() + moduleOptions.cookieExpiryOffsetMs)
-const localCookiesEnabled = ref([...(cookiesEnabled.value || [])])
-const allCookieIdsString = getAllCookieIdsString(moduleOptions)
+  moduleOptions
+} = useCookieControl();
+const nuxtApp = useNuxtApp();
+const expires = new Date(Date.now() + moduleOptions.cookieExpiryOffsetMs);
+const localCookiesEnabled = ref([...cookiesEnabled.value || []]);
+const allCookieIdsString = getAllCookieIdsString(moduleOptions);
 const cookieIsConsentGiven = useCookie(moduleOptions.cookieNameIsConsentGiven, {
   expires,
-  ...moduleOptions.cookieOptions,
-})
-
+  ...moduleOptions.cookieOptions
+});
 const cookieCookiesEnabledIds = useCookie(
   moduleOptions.cookieNameCookiesEnabledIds,
   {
     expires,
-    ...moduleOptions.cookieOptions,
-  },
-)
-
-// computations
+    ...moduleOptions.cookieOptions
+  }
+);
 const isSaved = computed(
-  () =>
-    getCookieIds(cookiesEnabled.value || [])
-      .sort()
-      .join(COOKIE_ID_SEPARATOR) !==
-    getCookieIds(localCookiesEnabled.value).sort().join(COOKIE_ID_SEPARATOR),
-)
-const localeStrings = computed(() => moduleOptions.localeTexts[props.locale])
-
-// methods
-const accept = () => {
+  () => getCookieIds(cookiesEnabled.value || []).sort().join(COOKIE_ID_SEPARATOR) !== getCookieIds(localCookiesEnabled.value).sort().join(COOKIE_ID_SEPARATOR)
+);
+const localeStrings = computed(() => moduleOptions.localeTexts[locale]);
+const acceptAll = () => {
   setCookies({
     isConsentGiven: true,
-    cookiesOptionalEnabled: moduleOptions.cookies.optional,
-  })
-}
+    cookiesOptionalEnabled: moduleOptions.cookies.optional
+  });
+};
 const acceptPartial = () => {
-  const localCookiesEnabledIds = getCookieIds(localCookiesEnabled.value)
-
+  const localCookiesEnabledIds = getCookieIds(localCookiesEnabled.value);
   setCookies({
     isConsentGiven: true,
     cookiesOptionalEnabled: [
       ...moduleOptions.cookies.necessary,
-      ...moduleOptions.cookies.optional,
-    ].filter((cookie) => localCookiesEnabledIds.includes(cookie.id)),
-  })
-}
-const decline = () => {
+      ...moduleOptions.cookies.optional
+    ].filter((cookie) => localCookiesEnabledIds.includes(cookie.id))
+  });
+};
+const acceptNecessary = () => {
   setCookies({
     isConsentGiven: true,
-    cookiesOptionalEnabled: moduleOptions.cookies.necessary,
-  })
-}
-const declineAll = () => {
+    cookiesOptionalEnabled: moduleOptions.cookies.necessary
+  });
+};
+const acceptNone = () => {
   setCookies({
     isConsentGiven: false,
-    cookiesOptionalEnabled: [],
-  })
-}
-const getDescription = (description: Translatable) =>
-  `${
-    moduleOptions.isDashInDescriptionEnabled === false ? '' : '-'
-  } ${resolveTranslatable(description, props.locale)}`
-const getName = (name: Translatable) => {
-  return name === 'functional'
-    ? localeStrings.value?.cookiesFunctional
-    : resolveTranslatable(name, props.locale)
-}
+    cookiesOptionalEnabled: []
+  });
+};
+const getDescription = (description) => `${moduleOptions.isDashInDescriptionEnabled === false ? "" : "-"} ${resolveTranslatable(description, locale)}`;
+const getName = (name) => {
+  return name === "functional" ? localeStrings.value?.cookiesFunctional : resolveTranslatable(name, locale);
+};
 const init = () => {
-  nuxtApp.$cookies.locale.value = props.locale
-}
+  nuxtApp.$cookies.locale.value = locale;
+};
 const onModalClick = () => {
   if (moduleOptions.closeModalOnClickOutside) {
-    isModalActive.value = false
+    isModalActive.value = false;
   }
-}
+};
 const setCookies = ({
   cookiesOptionalEnabled: cookiesOptionalEnabledNew,
-  isConsentGiven: isConsentGivenNew,
-}: {
-  cookiesOptionalEnabled: Cookie[]
-  isConsentGiven: boolean
+  isConsentGiven: isConsentGivenNew
 }) => {
-  isConsentGiven.value = isConsentGivenNew // must come before an update to `cookiesEnabled`
-  cookiesEnabled.value = isConsentGivenNew
-    ? [
-        ...moduleOptions.cookies.necessary,
-        ...moduleOptions.cookies.optional.filter((cookieOptional: Cookie) =>
-          cookiesOptionalEnabledNew.includes(cookieOptional),
-        ),
-      ]
-    : []
-  cookiesEnabledIds.value = isConsentGivenNew
-    ? getCookieIds(cookiesEnabled.value)
-    : []
-}
-const toggleButton = ($event: MouseEvent) => {
-  ;(
-    ($event.target as HTMLButtonElement | null)
-      ?.nextSibling as HTMLLabelElement | null
-  )?.click()
-}
-const toogleCookie = (cookie: Cookie) => {
-  const cookieIndex = getCookieIds(localCookiesEnabled.value).indexOf(cookie.id)
-
+  isConsentGiven.value = isConsentGivenNew;
+  cookiesEnabled.value = isConsentGivenNew ? [
+    ...moduleOptions.cookies.necessary,
+    ...moduleOptions.cookies.optional.filter(
+      (cookieOptional) => cookiesOptionalEnabledNew.includes(cookieOptional)
+    )
+  ] : [];
+  cookiesEnabledIds.value = isConsentGivenNew ? getCookieIds(cookiesEnabled.value) : [];
+};
+const toggleButton = ($event) => {
+  ;
+  $event.target?.nextSibling?.click();
+};
+const toogleCookie = (cookie) => {
+  const cookieIndex = getCookieIds(localCookiesEnabled.value).indexOf(cookie.id);
   if (cookieIndex < 0) {
-    localCookiesEnabled.value.push(cookie)
+    localCookiesEnabled.value.push(cookie);
   } else {
-    localCookiesEnabled.value.splice(cookieIndex, 1)
+    localCookiesEnabled.value.splice(cookieIndex, 1);
   }
-}
-const toggleLabel = ($event: KeyboardEvent) => {
-  if ($event.key === ' ') ($event.target as HTMLLabelElement | null)?.click()
-}
-
-// lifecycle
+};
+const toggleLabel = ($event) => {
+  if ($event.key === " ") $event.target?.click();
+};
 onBeforeMount(() => {
   if (moduleOptions.colors) {
-    const variables: Record<string, string> = {}
-
+    const variables = {};
     for (const key in moduleOptions.colors) {
-      variables[`cookie-control-${key}`] = `${moduleOptions.colors[key]}`
+      variables[`cookie-control-${key}`] = `${moduleOptions.colors[key]}`;
     }
-
-    setCssVariables(variables)
+    setCssVariables(variables);
   }
-
   if (moduleOptions.isModalForced && !isConsentGiven.value) {
-    isModalActive.value = true
+    isModalActive.value = true;
   }
-})
+});
 watch(
   () => cookiesEnabled.value,
   (current, _previous) => {
-    localCookiesEnabled.value = [...(current || [])]
-
+    localCookiesEnabled.value = [...current || []];
     if (isConsentGiven.value) {
       cookieCookiesEnabledIds.value = getCookieIds(current || []).join(
-        COOKIE_ID_SEPARATOR,
-      )
-
+        COOKIE_ID_SEPARATOR
+      );
       for (const cookieEnabled of current || []) {
-        if (!cookieEnabled.src) continue
-
-        const script = document.createElement('script')
-        script.src = cookieEnabled.src
-
-        const headElement = document.getElementsByTagName('head')[0]
-        if (!headElement) return
-
-        headElement.appendChild(script)
+        if (!cookieEnabled.src) continue;
+        const script = document.createElement("script");
+        script.src = cookieEnabled.src;
+        const headElement = document.getElementsByTagName("head")[0];
+        if (!headElement) return;
+        headElement.appendChild(script);
       }
     } else {
-      cookieCookiesEnabledIds.value = undefined
+      cookieCookiesEnabledIds.value = void 0;
     }
-
-    // delete formerly enabled cookies that are now disabled
     const cookiesOptionalDisabled = moduleOptions.cookies.optional.filter(
-      (cookieOptional) => !(current || []).includes(cookieOptional),
-    )
-
+      (cookieOptional) => !(current || []).includes(cookieOptional)
+    );
     for (const cookieOptionalDisabled of cookiesOptionalDisabled) {
-      if (!cookieOptionalDisabled.targetCookieIds) continue
-
+      if (!cookieOptionalDisabled.targetCookieIds) continue;
       for (const cookieOptionalDisabledId of cookieOptionalDisabled.targetCookieIds) {
-        removeCookie(cookieOptionalDisabledId)
+        removeCookie(cookieOptionalDisabledId);
       }
-
       if (cookieOptionalDisabled.src) {
         for (const script of [
           ...document.head.querySelectorAll(
-            `script[src="${cookieOptionalDisabled.src}"]`,
-          ),
+            `script[src="${cookieOptionalDisabled.src}"]`
+          )
         ]) {
-          script.parentNode?.removeChild(script)
+          script.parentNode?.removeChild(script);
         }
       }
     }
   },
-  { deep: true },
-)
-
+  { deep: true }
+);
 watch(isConsentGiven, (current, _previous) => {
-  if (current === undefined) {
-    cookieIsConsentGiven.value = undefined
+  if (current === void 0) {
+    cookieIsConsentGiven.value = void 0;
   } else {
-    cookieIsConsentGiven.value = current ? allCookieIdsString : '0'
+    cookieIsConsentGiven.value = current ? allCookieIdsString : "0";
   }
-})
-
+});
 watch(
-  () => props.locale,
-  (locale) => {
-    nuxtApp.$cookies.locale.value = locale
-  },
-)
-
-// initialization
-init()
-
+  () => locale,
+  (locale2) => {
+    nuxtApp.$cookies.locale.value = locale2;
+  }
+);
+init();
 defineExpose({
-  accept,
+  accept: acceptAll,
   acceptPartial,
-  decline,
-})
+  decline: acceptNecessary
+});
 </script>

package/dist/runtime/components/CookieControl.vue.d.ts

@@ -0,0 +1,223 @@
+import ClientOnlyPrerender from '#cookie-control/components/ClientOnlyPrerender.vue';
+import { getCookieIds, resolveTranslatable } from '#cookie-control/methods';
+import { type Cookie, CookieType, type Locale, type Translatable } from '#cookie-control/types';
+type __VLS_Props = {
+    locale?: Locale;
+};
+declare const isConsentGiven: import("vue").Ref<boolean | undefined, boolean | undefined>, isModalActive: import("vue").Ref<boolean, boolean>, moduleOptions: import("#cookie-control/types").ModuleOptions;
+declare const localCookiesEnabled: import("vue").Ref<{
+    description?: string | {
+        ar?: string | undefined;
+        az?: string | undefined;
+        be?: string | undefined;
+        bg?: string | undefined;
+        ca?: string | undefined;
+        cs?: string | undefined;
+        da?: string | undefined;
+        de?: string | undefined;
+        en?: string | undefined;
+        es?: string | undefined;
+        fi?: string | undefined;
+        fr?: string | undefined;
+        hr?: string | undefined;
+        hu?: string | undefined;
+        id?: string | undefined;
+        it?: string | undefined;
+        ja?: string | undefined;
+        km?: string | undefined;
+        ko?: string | undefined;
+        lt?: string | undefined;
+        nl?: string | undefined;
+        no?: string | undefined;
+        oc?: string | undefined;
+        pt?: string | undefined;
+        pl?: string | undefined;
+        ro?: string | undefined;
+        rs?: string | undefined;
+        ru?: string | undefined;
+        sk?: string | undefined;
+        sl?: string | undefined;
+        sv?: string | undefined;
+        tr?: string | undefined;
+        uk?: string | undefined;
+        "zh-CN"?: string | undefined;
+    } | undefined;
+    id: string;
+    isPreselected?: boolean | undefined;
+    name: string | {
+        ar?: string | undefined;
+        az?: string | undefined;
+        be?: string | undefined;
+        bg?: string | undefined;
+        ca?: string | undefined;
+        cs?: string | undefined;
+        da?: string | undefined;
+        de?: string | undefined;
+        en?: string | undefined;
+        es?: string | undefined;
+        fi?: string | undefined;
+        fr?: string | undefined;
+        hr?: string | undefined;
+        hu?: string | undefined;
+        id?: string | undefined;
+        it?: string | undefined;
+        ja?: string | undefined;
+        km?: string | undefined;
+        ko?: string | undefined;
+        lt?: string | undefined;
+        nl?: string | undefined;
+        no?: string | undefined;
+        oc?: string | undefined;
+        pt?: string | undefined;
+        pl?: string | undefined;
+        ro?: string | undefined;
+        rs?: string | undefined;
+        ru?: string | undefined;
+        sk?: string | undefined;
+        sl?: string | undefined;
+        sv?: string | undefined;
+        tr?: string | undefined;
+        uk?: string | undefined;
+        "zh-CN"?: string | undefined;
+    };
+    links?: Record<string, string | null> | undefined;
+    src?: string | undefined;
+    targetCookieIds?: string[] | undefined;
+}[], Cookie[] | {
+    description?: string | {
+        ar?: string | undefined;
+        az?: string | undefined;
+        be?: string | undefined;
+        bg?: string | undefined;
+        ca?: string | undefined;
+        cs?: string | undefined;
+        da?: string | undefined;
+        de?: string | undefined;
+        en?: string | undefined;
+        es?: string | undefined;
+        fi?: string | undefined;
+        fr?: string | undefined;
+        hr?: string | undefined;
+        hu?: string | undefined;
+        id?: string | undefined;
+        it?: string | undefined;
+        ja?: string | undefined;
+        km?: string | undefined;
+        ko?: string | undefined;
+        lt?: string | undefined;
+        nl?: string | undefined;
+        no?: string | undefined;
+        oc?: string | undefined;
+        pt?: string | undefined;
+        pl?: string | undefined;
+        ro?: string | undefined;
+        rs?: string | undefined;
+        ru?: string | undefined;
+        sk?: string | undefined;
+        sl?: string | undefined;
+        sv?: string | undefined;
+        tr?: string | undefined;
+        uk?: string | undefined;
+        "zh-CN"?: string | undefined;
+    } | undefined;
+    id: string;
+    isPreselected?: boolean | undefined;
+    name: string | {
+        ar?: string | undefined;
+        az?: string | undefined;
+        be?: string | undefined;
+        bg?: string | undefined;
+        ca?: string | undefined;
+        cs?: string | undefined;
+        da?: string | undefined;
+        de?: string | undefined;
+        en?: string | undefined;
+        es?: string | undefined;
+        fi?: string | undefined;
+        fr?: string | undefined;
+        hr?: string | undefined;
+        hu?: string | undefined;
+        id?: string | undefined;
+        it?: string | undefined;
+        ja?: string | undefined;
+        km?: string | undefined;
+        ko?: string | undefined;
+        lt?: string | undefined;
+        nl?: string | undefined;
+        no?: string | undefined;
+        oc?: string | undefined;
+        pt?: string | undefined;
+        pl?: string | undefined;
+        ro?: string | undefined;
+        rs?: string | undefined;
+        ru?: string | undefined;
+        sk?: string | undefined;
+        sl?: string | undefined;
+        sv?: string | undefined;
+        tr?: string | undefined;
+        uk?: string | undefined;
+        "zh-CN"?: string | undefined;
+    };
+    links?: Record<string, string | null> | undefined;
+    src?: string | undefined;
+    targetCookieIds?: string[] | undefined;
+}[]>;
+declare const isSaved: import("vue").ComputedRef<boolean>;
+declare const localeStrings: import("vue").ComputedRef<Partial<import("#cookie-control/types").LocaleStrings> | undefined>;
+declare const acceptAll: () => void;
+declare const acceptPartial: () => void;
+declare const acceptNecessary: () => void;
+declare const acceptNone: () => void;
+declare const getDescription: (description: Translatable) => string;
+declare const getName: (name: Translatable) => string | undefined;
+declare const onModalClick: () => void;
+declare const toggleButton: ($event: MouseEvent) => void;
+declare const toogleCookie: (cookie: Cookie) => void;
+declare const toggleLabel: ($event: KeyboardEvent) => void;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_9: {}, __VLS_11: {}, __VLS_17: {}, __VLS_19: {
+    cookie: any;
+};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    bar?: (props: typeof __VLS_9) => any;
+} & {
+    controlButton?: (props: typeof __VLS_11) => any;
+} & {
+    modal?: (props: typeof __VLS_17) => any;
+} & {
+    cookie?: (props: typeof __VLS_19) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<__VLS_Props, {
+    ClientOnlyPrerender: typeof ClientOnlyPrerender;
+    getCookieIds: typeof getCookieIds;
+    resolveTranslatable: typeof resolveTranslatable;
+    CookieType: typeof CookieType;
+    isConsentGiven: typeof isConsentGiven;
+    isModalActive: typeof isModalActive;
+    moduleOptions: typeof moduleOptions;
+    localCookiesEnabled: typeof localCookiesEnabled;
+    isSaved: typeof isSaved;
+    localeStrings: typeof localeStrings;
+    acceptAll: typeof acceptAll;
+    acceptPartial: typeof acceptPartial;
+    acceptNecessary: typeof acceptNecessary;
+    acceptNone: typeof acceptNone;
+    getDescription: typeof getDescription;
+    getName: typeof getName;
+    onModalClick: typeof onModalClick;
+    toggleButton: typeof toggleButton;
+    toogleCookie: typeof toogleCookie;
+    toggleLabel: typeof toggleLabel;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    accept: () => void;
+    acceptPartial: () => void;
+    decline: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/CookieIframe.vue

@@ -20,24 +20,17 @@
   </ClientOnlyPrerender>
 </template>
 
-<script setup lang="ts">
-import { computed } from 'vue'
-
-import type { Cookie } from '#cookie-control/types'
-import ClientOnlyPrerender from '#cookie-control/components/ClientOnlyPrerender.vue'
-import { useNuxtApp, useCookieControl } from '#imports'
-
-const { cookiesEnabled, isModalActive, moduleOptions } = useCookieControl()
-const nuxtApp = useNuxtApp()
-
-// computations
+<script setup>
+import { computed } from "vue";
+import { useNuxtApp, useCookieControl } from "#imports";
+const { cookiesEnabled, isModalActive, moduleOptions } = useCookieControl();
+const nuxtApp = useNuxtApp();
 const isCookieFunctionalEnabled = computed(
-  () =>
-    (cookiesEnabled.value || []).filter(
-      (cookieEnabled: Cookie) => cookieEnabled.name === 'functional',
-    ).length > 0,
-)
+  () => (cookiesEnabled.value || []).filter(
+    (cookieEnabled) => cookieEnabled.name === "functional"
+  ).length > 0
+);
 const localeStrings = computed(
-  () => moduleOptions.localeTexts[nuxtApp.$cookies.locale.value],
-)
+  () => moduleOptions.localeTexts[nuxtApp.$cookies.locale.value]
+);
 </script>

package/dist/runtime/components/CookieIframe.vue.d.ts

@@ -0,0 +1,23 @@
+import ClientOnlyPrerender from '#cookie-control/components/ClientOnlyPrerender.vue';
+declare const isModalActive: import("vue").Ref<boolean, boolean>;
+declare const isCookieFunctionalEnabled: import("vue").ComputedRef<boolean>;
+declare const localeStrings: import("vue").ComputedRef<Partial<import("#cookie-control/types").LocaleStrings> | undefined>;
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_5: {};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    iframe?: (props: typeof __VLS_5) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<{}, {
+    ClientOnlyPrerender: typeof ClientOnlyPrerender;
+    isModalActive: typeof isModalActive;
+    isCookieFunctionalEnabled: typeof isCookieFunctionalEnabled;
+    localeStrings: typeof localeStrings;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/locale/index.d.ts

@@ -1 +1 @@
-export declare const locales: import("../types").LocaleStrings[];
+export declare const locales: import("../types.js").LocaleStrings[];

package/dist/types.d.mts

@@ -1,7 +1,7 @@
 import type { NuxtModule } from '@nuxt/schema'
 
-import type { default as Module } from './module.js'
+import type { default as Module } from './module.mjs'
 
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-export { default } from './module.js'
+export { default } from './module.mjs'

package/package.json

@@ -14,24 +14,24 @@
     "@commitlint/cli": "19.8.0",
     "@commitlint/config-conventional": "19.8.0",
     "@dargmuesli/nuxt-cookie-control": "link:",
-    "@nuxt/eslint-config": "1.2.0",
-    "@nuxt/module-builder": "0.8.4",
-    "@nuxt/schema": "3.16.1",
+    "@nuxt/eslint-config": "1.3.0",
+    "@nuxt/module-builder": "1.0.0",
+    "@nuxt/schema": "3.16.2",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/git": "10.0.1",
     "@semantic-release/github": "11.0.1",
     "@semantic-release/npm": "12.0.1",
     "@semantic-release/release-notes-generator": "14.0.3",
-    "eslint": "9.23.0",
+    "eslint": "9.24.0",
     "eslint-config-prettier": "10.1.1",
-    "eslint-plugin-prettier": "5.2.5",
+    "eslint-plugin-prettier": "5.2.6",
     "husky": "9.1.7",
     "lint-staged": "15.5.0",
-    "nuxt": "3.16.1",
+    "nuxt": "3.16.2",
     "prettier": "3.5.3",
     "semantic-release": "24.2.3",
-    "vite": "6.2.3",
+    "vite": "6.2.5",
     "vue": "3.5.13",
     "vue-tsc": "2.2.8",
     "webpack": "5.98.0"
@@ -41,15 +41,10 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs",
-      "types": "./dist/types.d.ts"
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
     },
-    "./runtime/*": {
-      "import": "./dist/runtime/*.js",
-      "require": "./dist/runtime/*.js",
-      "types": "./dist/runtime/*.d.ts"
-    }
+    "./runtime/*": "./dist/runtime/*"
   },
   "files": [
     "dist/**/*"
@@ -64,38 +59,44 @@
     "nuxt gdpr consent"
   ],
   "license": "MIT",
-  "main": "./dist/module.cjs",
   "maintainers": [
     "Jonas Thelemann"
   ],
   "name": "@dargmuesli/nuxt-cookie-control",
-  "packageManager": "pnpm@10.7.0",
-  "publishConfig": {
-    "access": "public"
-  },
+  "packageManager": "pnpm@10.7.1",
   "pnpm": {
     "ignoredBuiltDependencies": [
+      "@parcel/watcher",
       "esbuild"
     ],
     "overrides": {
       "typescript": "5.6.3"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": "https://github.com/dargmuesli/nuxt-cookie-control",
   "resolutions": {
-    "@nuxt/kit": "3.16.1"
+    "@nuxt/kit": "3.16.2"
   },
   "scripts": {
     "build": "nuxt-module-build build",
     "dev": "pnpm --dir playground run dev",
     "lint": "pnpm run lint:js && pnpm run lint:ts",
-    "lint:fix": "pnpm run lint:js --fix . && pnpm run lint:ts --fix",
+    "lint:fix": "pnpm run lint:js --fix .",
     "lint:js": "eslint --cache",
     "lint:ts": "vue-tsc --noEmit",
     "prepack": "pnpm build",
     "prepare": "husky && nuxt-module-build prepare"
   },
   "type": "module",
-  "types": "./dist/types.d.ts",
-  "version": "8.6.1"
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "version": "9.0.0"
 }

package/dist/module.cjs

@@ -1,5 +0,0 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
-}
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -1,68 +0,0 @@
-import * as _nuxt_schema from '@nuxt/schema';
-import { CookieOptions } from 'nuxt/app';
-
-type Locale = 'ar' | 'az' | 'be' | 'bg' | 'ca' | 'cs' | 'da' | 'de' | 'en' | 'es' | 'fi' | 'fr' | 'hr' | 'hu' | 'id' | 'it' | 'ja' | 'km' | 'ko' | 'lt' | 'nl' | 'no' | 'oc' | 'pt' | 'pl' | 'ro' | 'rs' | 'ru' | 'sk' | 'sv' | 'tr' | 'uk' | 'zh-CN';
-type PartialRecord<K extends string | number | symbol, T> = Partial<Record<K, T>>;
-type Translatable = string | PartialRecord<Locale, string>;
-interface Cookie {
-    description?: Translatable;
-    id: string;
-    isPreselected?: boolean;
-    name: Translatable;
-    links?: Record<string, string | null>;
-    src?: string;
-    targetCookieIds?: string[];
-}
-interface LocaleStrings {
-    accept: string;
-    acceptAll: string;
-    bannerDescription: string;
-    bannerTitle: string;
-    close: string;
-    cookiesFunctional: string;
-    cookiesNecessary: string;
-    cookiesOptional: string;
-    iframeBlocked: string;
-    decline: string;
-    declineAll: string;
-    here: string;
-    manageCookies: string;
-    save: string;
-    settingsUnsaved: string;
-}
-interface ModuleOptions {
-    _isPrerendered: boolean | undefined;
-    barPosition: 'top-left' | 'top-right' | 'top-full' | 'bottom-left' | 'bottom-right' | 'bottom-full';
-    closeModalOnClickOutside: boolean;
-    colors: false | Record<string, unknown>;
-    cookieExpiryOffsetMs: number;
-    cookieNameCookiesEnabledIds: string;
-    cookieNameIsConsentGiven: string;
-    cookies: {
-        necessary: Cookie[];
-        optional: Cookie[];
-    };
-    cookieOptions: CookieOptions & {
-        readonly?: false;
-    };
-    isAcceptNecessaryButtonEnabled: boolean;
-    isControlButtonEnabled: boolean;
-    isCookieIdVisible: boolean;
-    isCssEnabled: boolean;
-    isCssPonyfillEnabled: boolean;
-    isDashInDescriptionEnabled: boolean;
-    isIframeBlocked: boolean;
-    isModalForced: boolean;
-    locales: Locale[];
-    localeTexts: PartialRecord<Locale, Partial<LocaleStrings>>;
-}
-
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
-
-declare module '@nuxt/schema' {
-    interface PublicRuntimeConfig {
-        cookieControl: ModuleOptions;
-    }
-}
-
-export { _default as default };

package/dist/types.d.ts

@@ -1,7 +0,0 @@
-import type { NuxtModule } from '@nuxt/schema'
-
-import type { default as Module } from './module'
-
-export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
-
-export { default } from './module'