@frigear-nu/cookie-consent 0.0.0-stage → 0.0.1

package/dist/module.d.mts

@@ -0,0 +1,128 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+/** A string, or a map of locale code -> string (`{ da: '...', en: '...' }`). */
+type Localized = string | Record<string, string>;
+/** A cookie (or similar storage entry) set under a category - listed in the preferences dialog for GDPR transparency. */
+interface ConsentCookie {
+    name: string;
+    provider?: string;
+    purpose?: Localized;
+    /** Human readable, e.g. `'1 year'` or `'Session'`. */
+    duration?: string;
+}
+interface ConsentCategory {
+    key: string;
+    /** Always on and not switchable (strictly necessary cookies). */
+    required?: boolean;
+    /** Pre-selected state in the preferences dialog. Never applied without the user saving. Default `false`. */
+    defaultEnabled?: boolean;
+    /** Defaults to the i18n key `cookieConsent.categories.<key>.label`. */
+    label?: Localized;
+    /** Defaults to the i18n key `cookieConsent.categories.<key>.description`. */
+    description?: Localized;
+    cookies?: ConsentCookie[];
+}
+interface ConsentMessages {
+    description: string;
+    accept: string;
+    reject: string;
+    preferences: string;
+    expand: string;
+    manage: string;
+    save: string;
+    preferencesTitle: string;
+    preferencesDescription: string;
+    required: string;
+    policy: string;
+    cookies: string;
+}
+interface ModuleOptions {
+    /** Name of the consent cookie. Default `cookie-consent`. */
+    cookieName?: string;
+    /** Cookie lifetime in seconds. Default 180 days. */
+    maxAge?: number;
+    /** Manual version. Changing it asks every visitor again. The category set is hashed into the version automatically. */
+    version?: string;
+    /** Categories to show. Defaults to `necessary` (required), `analytics` and `marketing`. Other modules add more via `extendCookieConsent`. */
+    categories?: ConsentCategory[];
+    /** Routes where the banner is hidden. Default `['/authorize']`. */
+    excludeRoutes?: string[];
+    /** Collapse the banner into a round button once scrolled this many px (`true` = 80, `false` = never). Default `true`. */
+    collapseOnScroll?: boolean | number;
+    /** Link to the cookie/privacy policy shown in the banner. */
+    policyUrl?: string;
+    /**
+     * Store the consent on the signed-in user (`@frigear-nu/users` + `@nuxthub/core` required).
+     * Default: `true` when `@frigear-nu/users` is installed.
+     */
+    persistToUser?: boolean;
+}
+interface PublicModuleOptions {
+    cookieName: string;
+    maxAge: number;
+    version: string;
+    categories: ConsentCategory[];
+    excludeRoutes: string[];
+    collapseThreshold: number | false;
+    policyUrl?: string;
+    persistToUser: boolean;
+}
+/** What is stored in the consent cookie and (for signed-in users) in the database. */
+interface ConsentState {
+    /** Consent version the choice was made against. */
+    v: string;
+    /** Epoch milliseconds when the choice was made. */
+    ts: number;
+    categories: Record<string, boolean>;
+}
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig {
+    cookieConsent?: ModuleOptions
+  }
+
+  interface NuxtOptions {
+    cookieConsent?: ModuleOptions & {
+      _categories?: ConsentCategory[]
+    }
+  }
+
+  interface PublicRuntimeConfig {
+    cookieConsent?: PublicModuleOptions
+  }
+
+  interface NuxtHooks {
+    /** Called every time `extendCookieConsent` registers categories. */
+    'cookie-consent:extend': (categories: ConsentCategory[]) => void
+    /**
+     * Called once after every module has set up, with the final merged category list. Mutate the
+     * array to adjust it; the consent version is derived from it afterwards.
+     */
+    'cookie-consent:resolved': (categories: ConsentCategory[]) => void
+  }
+}
+
+declare module '#app' {
+  interface RuntimeNuxtHooks {
+    /** Called on the client when the visitor saves a choice (accept, reject, preferences or withdraw). */
+    'cookie-consent:change': (state: ConsentState | null, previous: ConsentState | null) => void
+    /** Called once on the client with the stored consent (or `null` if still undecided). */
+    'cookie-consent:ready': (state: ConsentState | null) => void
+  }
+}
+
+declare module 'nitropack' {
+  interface NitroRuntimeHooks {
+    /** Called on the server after a signed-in user's consent was stored. */
+    'cookie-consent:saved': (payload: {
+      userId: number | string
+      state: ConsentState
+      acceptedAt: number
+    }) => void | Promise<void>
+  }
+}
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ConsentCategory, ConsentCookie, ConsentMessages, ConsentState, Localized, ModuleOptions, PublicModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@frigear-nu/cookie-consent",
+  "configKey": "cookieConsent",
+  "version": "0.0.1",
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,61 @@
+import { defineNuxtModule, createResolver, hasNuxtModule, addImports, addServerImports, addComponentsDir, addServerHandler } from '@nuxt/kit';
+import { registerModule, registerLocales, extendDatabaseTable } from '@frigear-nu/module-kit/utils';
+import { mergeCategories, DEFAULT_CATEGORIES, computeVersion } from '../dist/runtime/utils/consent.js';
+
+const DEFAULT_MAX_AGE = 60 * 60 * 24 * 180;
+const module$1 = defineNuxtModule({
+  meta: { name: "@frigear-nu/cookie-consent", configKey: "cookieConsent" },
+  defaults: {
+    cookieName: "cookie-consent",
+    maxAge: DEFAULT_MAX_AGE,
+    excludeRoutes: ["/authorize"],
+    collapseOnScroll: true
+  },
+  moduleDependencies: {
+    "@frigear-nu/module-kit": { version: ">=0.0.1" }
+  },
+  async setup(options, nuxt) {
+    registerModule("@frigear-nu/cookie-consent", nuxt);
+    const resolver = createResolver(import.meta.url);
+    registerLocales(nuxt, resolver.resolve("./runtime/i18n/lang"));
+    const persistToUser = (options.persistToUser ?? true) && hasNuxtModule("@frigear-nu/users");
+    addImports([
+      { name: "useCookieConsent", from: resolver.resolve("./runtime/app/composables/useCookieConsent") },
+      { name: "onCookieConsent", from: resolver.resolve("./runtime/app/composables/useCookieConsent") },
+      { name: "useConsentT", from: resolver.resolve("./runtime/app/composables/useConsentT") }
+    ]);
+    addServerImports([
+      { name: "getCookieConsent", from: resolver.resolve("./runtime/server/utils/consent") },
+      { name: "hasCookieConsent", from: resolver.resolve("./runtime/server/utils/consent") }
+    ]);
+    addComponentsDir({ path: resolver.resolve("./runtime/app/components") });
+    if (persistToUser) {
+      addServerHandler({ route: "/api/cookie-consent", method: "get", handler: resolver.resolve("./runtime/server/routes/cookie-consent/index.get") });
+      addServerHandler({ route: "/api/cookie-consent", method: "post", handler: resolver.resolve("./runtime/server/routes/cookie-consent/index.post") });
+      extendDatabaseTable(nuxt, {
+        name: "users",
+        resolver,
+        file: (dialect) => `./runtime/server/db/schema.${dialect}`
+      });
+    }
+    nuxt.hook("modules:done", async () => {
+      const categories = mergeCategories(
+        options.categories ?? DEFAULT_CATEGORIES,
+        nuxt.options.cookieConsent?._categories ?? []
+      );
+      await nuxt.callHook("cookie-consent:resolved", categories);
+      nuxt.options.runtimeConfig.public.cookieConsent = {
+        cookieName: options.cookieName,
+        maxAge: options.maxAge,
+        version: computeVersion(options.version, categories),
+        categories,
+        excludeRoutes: options.excludeRoutes ?? [],
+        collapseThreshold: options.collapseOnScroll === false ? false : typeof options.collapseOnScroll === "number" ? options.collapseOnScroll : 80,
+        policyUrl: options.policyUrl,
+        persistToUser
+      };
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/app/components/CookieConsentBanner.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/CookieConsentBanner.vue

@@ -0,0 +1,98 @@
+<script setup>
+import { useWindowScroll } from "@vueuse/core";
+const { config, hasResponded, acceptAll, rejectAll, openPreferences, hydrateFromUser } = useCookieConsent();
+const { t } = useConsentT();
+const route = useRoute();
+const excluded = computed(() => config.excludeRoutes.includes(route.path));
+const open = computed(() => !hasResponded.value && !excluded.value);
+const { y } = useWindowScroll();
+const scrolledDown = computed(() => config.collapseThreshold !== false && y.value > config.collapseThreshold);
+const isManuallyExpanded = ref(false);
+const collapsed = computed(() => scrolledDown.value && !isManuallyExpanded.value);
+watch(scrolledDown, (isDown) => {
+  if (!isDown) isManuallyExpanded.value = false;
+});
+onMounted(() => {
+  hydrateFromUser();
+  if (config.persistToUser) watch(useUserSession().loggedIn, hydrateFromUser);
+  useNuxtApp().callHook("cookie-consent:ready", useCookieConsent().consent.value);
+});
+</script>
+
+<template>
+  <ClientOnly>
+    <Transition name="cookie-fab">
+      <button
+        v-if="open && collapsed"
+        class="cc-fab"
+        :aria-label="t('expand')"
+        data-testid="cookie-consent-fab"
+        @click="isManuallyExpanded = true"
+      >
+        <UIcon
+          name="i-lucide-cookie"
+          class="cc-fab-icon"
+        />
+      </button>
+    </Transition>
+
+    <Transition name="cookie-slide">
+      <div
+        v-if="open && !collapsed"
+        class="cc-wrap"
+        role="dialog"
+        :aria-label="t('preferencesTitle')"
+        data-testid="cookie-consent-banner"
+      >
+        <div class="cc-banner">
+          <div class="cc-badge">
+            <UIcon
+              name="i-lucide-cookie"
+              class="cc-badge-icon"
+            />
+          </div>
+          <div class="cc-content">
+            <p class="cc-text">
+              {{ t("description") }}
+              <NuxtLink
+                v-if="config.policyUrl"
+                :to="config.policyUrl"
+                class="cc-link"
+              >
+                {{ t("policy") }}
+              </NuxtLink>
+            </p>
+            <div class="cc-actions">
+              <UButton
+                color="neutral"
+                variant="ghost"
+                :label="t('preferences')"
+                data-testid="cookie-consent-preferences"
+                @click="openPreferences"
+              />
+              <UButton
+                color="neutral"
+                variant="outline"
+                :label="t('reject')"
+                data-testid="cookie-consent-reject"
+                @click="rejectAll"
+              />
+              <UButton
+                color="primary"
+                :label="t('accept')"
+                data-testid="cookie-consent-accept"
+                @click="acceptAll"
+              />
+            </div>
+          </div>
+        </div>
+      </div>
+    </Transition>
+
+    <CookieConsentPreferences />
+  </ClientOnly>
+</template>
+
+<style scoped>
+.cc-wrap{display:flex;inset:auto 0 0 0;justify-content:center;pointer-events:none;position:fixed;z-index:50}.cc-banner{border-radius:1rem 1rem 0 0;box-shadow:0 -8px 30px rgba(0,0,0,.25);color:var(--ui-text);pointer-events:auto;position:relative;width:92vw}.cc-badge,.cc-banner{background:var(--ui-bg);border:1px solid color-mix(in oklab,var(--ui-primary) 70%,transparent)}.cc-badge{align-items:center;border-radius:9999px;display:flex;justify-content:center;left:1rem;padding:.25rem;position:absolute;top:-.875rem}.cc-badge-icon{color:var(--ui-primary);height:1.25rem;width:1.25rem}.cc-content{align-items:center;display:flex;flex-direction:column;gap:1rem;justify-content:space-between;padding:1.25rem 1rem 1rem}.cc-text{color:var(--ui-text-muted);font-size:.875rem;margin:0}.cc-link{text-decoration:underline}.cc-actions{display:flex;flex-shrink:0;flex-wrap:wrap;gap:.5rem}@media (min-width:640px){.cc-content{flex-direction:row}}.cc-fab{align-items:center;background:var(--ui-bg);border:1px solid var(--ui-border);border-radius:9999px;bottom:1rem;box-shadow:0 10px 25px rgba(0,0,0,.3);cursor:pointer;display:flex;height:3.5rem;justify-content:center;left:1rem;position:fixed;width:3.5rem;z-index:50}.cc-fab:hover{opacity:.9}.cc-fab-icon{color:var(--ui-primary);height:1.75rem;width:1.75rem}.cookie-slide-enter-active,.cookie-slide-leave-active{transition:transform .3s ease,opacity .3s ease}.cookie-slide-enter-from,.cookie-slide-leave-to{opacity:0;transform:translateY(100%)}.cookie-fab-enter-active,.cookie-fab-leave-active{transition:opacity .2s ease,transform .2s ease}.cookie-fab-enter-from,.cookie-fab-leave-to{opacity:0;transform:scale(.5)}
+</style>

package/dist/runtime/app/components/CookieConsentBanner.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/CookieConsentManage.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/CookieConsentManage.vue

@@ -0,0 +1,19 @@
+<script setup>
+const { openPreferences } = useCookieConsent();
+const { t } = useConsentT();
+</script>
+
+<template>
+  <button
+    type="button"
+    :class="['cc-manage', { 'cc-manage-text': !$slots.default }]"
+    data-testid="cookie-consent-manage"
+    @click="openPreferences"
+  >
+    <slot>{{ t("manage") }}</slot>
+  </button>
+</template>
+
+<style scoped>
+.cc-manage{background:none;border:0;color:inherit;cursor:pointer;padding:0}.cc-manage-text{text-decoration:underline}
+</style>

package/dist/runtime/app/components/CookieConsentManage.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/CookieConsentPreferences.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/CookieConsentPreferences.vue

@@ -0,0 +1,102 @@
+<script setup>
+const { categories, consent, isPreferencesOpen, save, acceptAll, rejectAll } = useCookieConsent();
+const { t, label, description, localize } = useConsentT();
+const choices = ref({});
+watch(isPreferencesOpen, (isOpen) => {
+  if (!isOpen) return;
+  choices.value = Object.fromEntries(categories.map((category) => [
+    category.key,
+    category.required ? true : consent.value?.categories[category.key] ?? category.defaultEnabled ?? false
+  ]));
+}, { immediate: true });
+</script>
+
+<template>
+  <UModal
+    v-model:open="isPreferencesOpen"
+    :title="t('preferencesTitle')"
+    :description="t('preferencesDescription')"
+  >
+    <template #body>
+      <div
+        class="cc-list"
+        data-testid="cookie-consent-preferences-dialog"
+      >
+        <div
+          v-for="category in categories"
+          :key="category.key"
+          class="cc-item"
+        >
+          <div class="cc-row">
+            <div>
+              <p class="cc-label">
+                {{ label(category) }}
+              </p>
+              <p class="cc-desc">
+                {{ description(category) }}
+              </p>
+            </div>
+            <span
+              v-if="category.required"
+              class="cc-required"
+            >{{ t("required") }}</span>
+            <USwitch
+              v-else
+              v-model="choices[category.key]"
+              :aria-label="label(category)"
+              :data-testid="`cookie-consent-toggle-${category.key}`"
+            />
+          </div>
+          <details
+            v-if="category.cookies?.length"
+            class="cc-details"
+          >
+            <summary class="cc-summary">
+              {{ t("cookies") }} ({{ category.cookies.length }})
+            </summary>
+            <ul class="cc-cookies">
+              <li
+                v-for="cookie in category.cookies"
+                :key="cookie.name"
+              >
+                <code>{{ cookie.name }}</code>
+                <span v-if="cookie.provider"> · {{ cookie.provider }}</span>
+                <span v-if="cookie.duration"> · {{ cookie.duration }}</span>
+                <span
+                  v-if="cookie.purpose"
+                  class="cc-purpose"
+                >{{ localize(cookie.purpose) }}</span>
+              </li>
+            </ul>
+          </details>
+        </div>
+      </div>
+    </template>
+    <template #footer>
+      <div class="cc-footer">
+        <UButton
+          color="neutral"
+          variant="outline"
+          :label="t('reject')"
+          @click="rejectAll"
+        />
+        <UButton
+          color="neutral"
+          variant="outline"
+          :label="t('accept')"
+          @click="acceptAll"
+        />
+        <UButton
+          color="primary"
+          :label="t('save')"
+          data-testid="cookie-consent-save"
+          @click="save(choices)"
+        />
+      </div>
+    </template>
+  </UModal>
+</template>
+
+<style scoped>
+.cc-list{display:flex;flex-direction:column;gap:1rem}.cc-item{border:1px solid var(--ui-border);border-radius:.5rem;padding:.75rem}.cc-row{align-items:flex-start;display:flex;gap:1rem;justify-content:space-between}.cc-label{font-weight:500;margin:0}.cc-desc{font-size:.875rem;margin:0}.cc-desc,.cc-purpose,.cc-required,.cc-summary{color:var(--ui-text-muted)}.cc-required{flex-shrink:0;font-size:.75rem}.cc-details{font-size:.875rem;margin-top:.5rem}.cc-summary{cursor:pointer}.cc-cookies{display:flex;flex-direction:column;gap:.25rem;list-style:none;margin:.25rem 0 0;padding:0}.cc-purpose{display:block}.cc-footer{display:flex;flex-wrap:wrap;gap:.5rem;justify-content:flex-end;width:100%}
+</style>

package/dist/runtime/app/components/CookieConsentPreferences.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/composables/index.d.ts

@@ -0,0 +1,2 @@
+export { useCookieConsent, onCookieConsent } from './useCookieConsent.js';
+export { useConsentT } from './useConsentT.js';

package/dist/runtime/app/composables/index.js

@@ -0,0 +1,2 @@
+export { useCookieConsent, onCookieConsent } from "./useCookieConsent.js";
+export { useConsentT } from "./useConsentT.js";

package/dist/runtime/app/composables/useConsentT.d.ts

@@ -0,0 +1,8 @@
+import type { ConsentCategory, ConsentMessages, Localized } from '../../../types.js';
+export declare function useConsentT(): {
+    locale: any;
+    t: (key: keyof ConsentMessages) => any;
+    label: (category: ConsentCategory) => string;
+    description: (category: ConsentCategory) => string;
+    localize: (value: Localized | undefined, fallback?: string) => string;
+};

package/dist/runtime/app/composables/useConsentT.js

@@ -0,0 +1,37 @@
+import { localize } from "../../utils/consent.js";
+const EN = {
+  description: "We use cookies to improve your experience. Choose which categories you allow.",
+  accept: "Accept all",
+  reject: "Reject all",
+  preferences: "Preferences",
+  expand: "Show cookie consent",
+  manage: "Manage cookies",
+  save: "Save choices",
+  preferencesTitle: "Cookie preferences",
+  preferencesDescription: "Choose which cookies you allow. You can change this at any time.",
+  required: "Always on",
+  policy: "Read more",
+  cookies: "Cookies"
+};
+const EN_CATEGORIES = {
+  necessary: { label: "Necessary", description: "Required for the site to work, such as keeping you signed in. Cannot be disabled." },
+  analytics: { label: "Analytics", description: "Helps us understand how the site is used so we can improve it." },
+  marketing: { label: "Marketing", description: "Used for social media integrations and relevant content." }
+};
+export function useConsentT() {
+  const tm = useModuleT("cookieConsent");
+  const nuxtApp = useNuxtApp();
+  const locale = computed(() => nuxtApp.$i18n?.locale?.value ?? "en");
+  function categoryText(category, field) {
+    const explicit = category[field];
+    if (explicit) return localize(explicit, locale.value);
+    return tm(`categories.${category.key}.${field}`, EN_CATEGORIES[category.key]?.[field] ?? (field === "label" ? category.key : ""));
+  }
+  return {
+    locale,
+    t: (key) => tm(key, EN[key]),
+    label: (category) => categoryText(category, "label"),
+    description: (category) => categoryText(category, "description"),
+    localize: (value, fallback = "") => localize(value, locale.value, fallback)
+  };
+}

package/dist/runtime/app/composables/useCookieConsent.d.ts

@@ -0,0 +1,22 @@
+import type { ConsentState } from '../../../types.js';
+export declare function useCookieConsent(): {
+    config: any;
+    categories: any;
+    consent: any;
+    hasResponded: any;
+    isAllowed: (key: string) => boolean;
+    acceptAll: () => Promise<ConsentState>;
+    rejectAll: () => Promise<ConsentState>;
+    save: (choices: Record<string, boolean>) => Promise<ConsentState>;
+    reset: () => Promise<void>;
+    hydrateFromUser: () => Promise<void>;
+    isPreferencesOpen: any;
+    openPreferences: () => void;
+} | undefined;
+/**
+ * Runs `callback` once the visitor has granted `category` - immediately if they already did, or as
+ * soon as they do. The optional return value is called when consent is withdrawn.
+ *
+ *     onCookieConsent("analytics", () => { startTracking(); return () => stopTracking() })
+ */
+export declare function onCookieConsent(category: string, callback: () => (() => void) | undefined): any;

package/dist/runtime/app/composables/useCookieConsent.js

@@ -0,0 +1,85 @@
+import { acceptAllChoices, buildConsent, normalizeConsent, rejectAllChoices } from "../../utils/consent.js";
+const createCookieConsent = (nuxtApp) => {
+  const config = useRuntimeConfig().public.cookieConsent;
+  const cookie = useCookie(config.cookieName, {
+    maxAge: config.maxAge,
+    path: "/",
+    sameSite: "lax",
+    secure: !import.meta.dev,
+    default: () => null
+  });
+  const consent = computed(() => normalizeConsent(cookie.value, config.categories, config.version));
+  const hasResponded = computed(() => !!consent.value);
+  const categories = config.categories;
+  const isPreferencesOpen = useState("cookie-consent:preferences", () => false);
+  const isAllowed = (key) => consent.value?.categories[key] === true;
+  async function persistToUser(state) {
+    if (!config.persistToUser) return;
+    const { loggedIn } = useUserSession();
+    if (!loggedIn.value) return;
+    try {
+      await $fetch("/api/cookie-consent", { method: "POST", body: { categories: state.categories, version: state.v } });
+    } catch (error) {
+      console.warn("[cookie-consent] Failed to store consent on the user.", error);
+    }
+  }
+  async function save(choices) {
+    const previous = consent.value;
+    const state = buildConsent(categories, config.version, choices);
+    cookie.value = state;
+    isPreferencesOpen.value = false;
+    await nuxtApp.callHook("cookie-consent:change", state, previous);
+    await persistToUser(state);
+    return state;
+  }
+  const acceptAll = () => save(acceptAllChoices(categories));
+  const rejectAll = () => save(rejectAllChoices(categories));
+  async function reset() {
+    const previous = consent.value;
+    const state = buildConsent(categories, config.version, rejectAllChoices(categories));
+    cookie.value = null;
+    await nuxtApp.callHook("cookie-consent:change", null, previous);
+    await persistToUser(state);
+  }
+  async function hydrateFromUser() {
+    if (!config.persistToUser || hasResponded.value) return;
+    const { loggedIn } = useUserSession();
+    if (!loggedIn.value) return;
+    try {
+      const { consent: stored } = await $fetch("/api/cookie-consent");
+      const state = normalizeConsent(stored, config.categories, config.version, stored?.ts);
+      if (state) {
+        cookie.value = state;
+        await nuxtApp.callHook("cookie-consent:change", state, null);
+      }
+    } catch {
+    }
+  }
+  const openPreferences = () => {
+    isPreferencesOpen.value = true;
+  };
+  return { config, categories, consent, hasResponded, isAllowed, acceptAll, rejectAll, save, reset, hydrateFromUser, isPreferencesOpen, openPreferences };
+};
+const instances = /* @__PURE__ */ new WeakMap();
+export function useCookieConsent() {
+  const nuxtApp = useNuxtApp();
+  let instance = instances.get(nuxtApp);
+  if (!instance) {
+    instance = nuxtApp.runWithContext(() => effectScope(true).run(() => createCookieConsent(nuxtApp)));
+    instances.set(nuxtApp, instance);
+  }
+  return instance;
+}
+export function onCookieConsent(category, callback) {
+  const { isAllowed } = useCookieConsent();
+  let cleanup;
+  const stop = watch(() => isAllowed(category), (allowed) => {
+    if (allowed && !cleanup) cleanup = callback();
+    else if (!allowed && cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+  }, { immediate: true, flush: "sync" });
+  if (getCurrentScope()) onScopeDispose(stop);
+  return stop;
+}

package/dist/runtime/i18n/lang/da.json

@@ -0,0 +1,30 @@
+{
+  "cookieConsent": {
+    "description": "Vi bruger cookies for at forbedre din oplevelse. Vælg hvilke kategorier du tillader.",
+    "accept": "Acceptér alle",
+    "reject": "Afvis alle",
+    "preferences": "Indstillinger",
+    "expand": "Vis cookie-samtykke",
+    "manage": "Administrér cookies",
+    "save": "Gem valg",
+    "preferencesTitle": "Cookie-indstillinger",
+    "preferencesDescription": "Vælg hvilke cookies du tillader. Du kan til enhver tid ændre det.",
+    "required": "Altid aktiv",
+    "policy": "Læs mere",
+    "cookies": "Cookies",
+    "categories": {
+      "necessary": {
+        "label": "Nødvendige",
+        "description": "Påkrævet for at siden fungerer, f.eks. at holde dig logget ind. Kan ikke slås fra."
+      },
+      "analytics": {
+        "label": "Statistik",
+        "description": "Hjælper os med at forstå, hvordan siden bruges, så vi kan forbedre den."
+      },
+      "marketing": {
+        "label": "Markedsføring",
+        "description": "Bruges til integration med sociale medier og relevant indhold."
+      }
+    }
+  }
+}

package/dist/runtime/i18n/lang/en.json

@@ -0,0 +1,30 @@
+{
+  "cookieConsent": {
+    "description": "We use cookies to improve your experience. Choose which categories you allow.",
+    "accept": "Accept all",
+    "reject": "Reject all",
+    "preferences": "Preferences",
+    "expand": "Show cookie consent",
+    "manage": "Manage cookies",
+    "save": "Save choices",
+    "preferencesTitle": "Cookie preferences",
+    "preferencesDescription": "Choose which cookies you allow. You can change this at any time.",
+    "required": "Always on",
+    "policy": "Read more",
+    "cookies": "Cookies",
+    "categories": {
+      "necessary": {
+        "label": "Necessary",
+        "description": "Required for the site to work, such as keeping you signed in. Cannot be disabled."
+      },
+      "analytics": {
+        "label": "Analytics",
+        "description": "Helps us understand how the site is used so we can improve it."
+      },
+      "marketing": {
+        "label": "Marketing",
+        "description": "Used for social media integrations and relevant content."
+      }
+    }
+  }
+}

package/dist/runtime/server/db/schema.sqlite.d.ts

@@ -0,0 +1,62 @@
+export declare const users: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "users";
+    schema: undefined;
+    columns: {
+        cookieConsentAcceptedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "cookie_consent_accepted_at";
+            tableName: "users";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cookieConsentVersion: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "cookie_consent_version";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        cookieConsentCategories: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "cookie_consent_categories";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/runtime/server/db/schema.sqlite.js

@@ -0,0 +1,9 @@
+import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
+export const users = sqliteTable("users", {
+  // When the user last responded to the cookie banner (epoch ms) - proof of consent for GDPR.
+  cookieConsentAcceptedAt: integer("cookie_consent_accepted_at"),
+  // The consent version (manual version + category-set hash) the choice was made against.
+  cookieConsentVersion: text("cookie_consent_version"),
+  // JSON of exactly what was granted, e.g. {"necessary":true,"analytics":false}.
+  cookieConsentCategories: text("cookie_consent_categories")
+});

package/dist/runtime/server/routes/cookie-consent/index.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/cookie-consent/index.get.js

@@ -0,0 +1,12 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  const [row] = await db.select({
+    acceptedAt: schema.users.cookieConsentAcceptedAt,
+    version: schema.users.cookieConsentVersion,
+    categories: schema.users.cookieConsentCategories
+  }).from(schema.users).where(eq(schema.users.id, user.id));
+  if (!row?.acceptedAt || !row.version || !row.categories) return { consent: null };
+  return { consent: { v: row.version, ts: row.acceptedAt, categories: JSON.parse(row.categories) } };
+});

package/dist/runtime/server/routes/cookie-consent/index.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/cookie-consent/index.post.js

@@ -0,0 +1,30 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { buildConsent } from "../../../utils/consent.js";
+import { getCookieConsentConfig } from "../../utils/consent.js";
+const bodySchema = z.object({
+  categories: z.record(z.string(), z.boolean()),
+  version: z.string()
+});
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  const config = getCookieConsentConfig(event);
+  const body = await readValidatedBody(event, bodySchema.parse);
+  if (body.version !== config.version) {
+    throw createError({ statusCode: 409, statusMessage: "Outdated cookie consent version." });
+  }
+  const known = new Set(config.categories.map((category) => category.key));
+  const unknown = Object.keys(body.categories).filter((key) => !known.has(key));
+  if (unknown.length) {
+    throw createError({ statusCode: 400, statusMessage: `Unknown categories: ${unknown.join(", ")}` });
+  }
+  const state = buildConsent(config.categories, config.version, body.categories);
+  await db.update(schema.users).set({
+    cookieConsentAcceptedAt: state.ts,
+    cookieConsentVersion: state.v,
+    cookieConsentCategories: JSON.stringify(state.categories)
+  }).where(eq(schema.users.id, user.id));
+  await useNitroApp().hooks.callHook("cookie-consent:saved", { userId: user.id, state, acceptedAt: state.ts });
+  return state;
+});

package/dist/runtime/server/utils/consent.d.ts

@@ -0,0 +1,8 @@
+import type { H3Event } from 'h3';
+import type { ConsentState, PublicModuleOptions } from '../../../types.js';
+/** The resolved public module options (categories, version, cookie name, ...). */
+export declare function getCookieConsentConfig(event: H3Event): PublicModuleOptions | undefined;
+/** Reads the visitor's current consent from the request cookie (`null` = undecided / outdated). */
+export declare function getCookieConsent(event: H3Event): ConsentState | null;
+/** Whether the visitor granted `category` - use to gate tracking in SSR / API code. */
+export declare function hasCookieConsent(event: H3Event, category: string): boolean;

package/dist/runtime/server/utils/consent.js

@@ -0,0 +1,19 @@
+import { normalizeConsent } from "../../utils/consent.js";
+export function getCookieConsentConfig(event) {
+  return useRuntimeConfig(event).public.cookieConsent;
+}
+export function getCookieConsent(event) {
+  const config = getCookieConsentConfig(event);
+  if (!config) return null;
+  const raw = getCookie(event, config.cookieName);
+  if (!raw) return null;
+  let parsed = raw;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+  }
+  return normalizeConsent(parsed, config.categories, config.version);
+}
+export function hasCookieConsent(event, category) {
+  return getCookieConsent(event)?.categories[category] === true;
+}

package/dist/runtime/utils/consent.d.ts

@@ -0,0 +1,18 @@
+import type { ConsentCategory, ConsentState } from '../../types.js';
+export declare const DEFAULT_CATEGORIES: ConsentCategory[];
+/** Merges categories by key: earlier labels win, cookies are concatenated, `required` is sticky. */
+export declare function mergeCategories(...lists: ConsentCategory[][]): ConsentCategory[];
+/** Small stable string hash (djb2) - used to derive the consent version from the category set. */
+export declare function hashString(input: string): string;
+export declare function computeVersion(manualVersion: string | undefined, categories: ConsentCategory[]): string;
+/** Builds a state: required categories are always granted, unknown keys are dropped. */
+export declare function buildConsent(categories: ConsentCategory[], version: string, choices: Record<string, boolean>, now?: number): ConsentState;
+export declare function acceptAllChoices(categories: ConsentCategory[]): Record<string, boolean>;
+export declare function rejectAllChoices(categories: ConsentCategory[]): Record<string, boolean>;
+/**
+ * Turns whatever the cookie holds into a valid state for the *current* version, or `null` when the
+ * visitor must be asked again (nothing stored, malformed, or made against another version).
+ * The old app's `accepted` / `rejected` strings are migrated.
+ */
+export declare function normalizeConsent(raw: unknown, categories: ConsentCategory[], version: string, now?: number): ConsentState | null;
+export declare function localize(value: string | Record<string, string> | undefined, locale: string, fallback?: string): string;

package/dist/runtime/utils/consent.js

@@ -0,0 +1,61 @@
+export const DEFAULT_CATEGORIES = [
+  { key: "necessary", required: true },
+  { key: "analytics" },
+  { key: "marketing" }
+];
+export function mergeCategories(...lists) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const category of lists.flat()) {
+    const existing = byKey.get(category.key);
+    if (!existing) {
+      byKey.set(category.key, { ...category, cookies: [...category.cookies ?? []] });
+      continue;
+    }
+    existing.required = existing.required || category.required;
+    existing.defaultEnabled = existing.defaultEnabled ?? category.defaultEnabled;
+    existing.label = existing.label ?? category.label;
+    existing.description = existing.description ?? category.description;
+    const known = new Set((existing.cookies ?? []).map((cookie) => cookie.name));
+    existing.cookies = [...existing.cookies ?? [], ...(category.cookies ?? []).filter((cookie) => !known.has(cookie.name))];
+  }
+  return [...byKey.values()];
+}
+export function hashString(input) {
+  let hash = 5381;
+  for (let index = 0; index < input.length; index++) {
+    hash = (hash << 5) + hash + input.charCodeAt(index) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+export function computeVersion(manualVersion, categories) {
+  const fingerprint = categories.map((category) => `${category.key}:${category.required ? 1 : 0}:${(category.cookies ?? []).map((cookie) => cookie.name).sort().join(",")}`).sort().join("|");
+  return `${manualVersion ?? "1"}-${hashString(fingerprint)}`;
+}
+export function buildConsent(categories, version, choices, now = Date.now()) {
+  return {
+    v: version,
+    ts: now,
+    categories: Object.fromEntries(
+      categories.map((category) => [category.key, category.required ? true : choices[category.key] === true])
+    )
+  };
+}
+export function acceptAllChoices(categories) {
+  return Object.fromEntries(categories.map((category) => [category.key, true]));
+}
+export function rejectAllChoices(categories) {
+  return Object.fromEntries(categories.map((category) => [category.key, !!category.required]));
+}
+export function normalizeConsent(raw, categories, version, now = Date.now()) {
+  if (raw === "accepted") return buildConsent(categories, version, acceptAllChoices(categories), now);
+  if (raw === "rejected") return buildConsent(categories, version, rejectAllChoices(categories), now);
+  if (!raw || typeof raw !== "object") return null;
+  const state = raw;
+  if (state.v !== version || typeof state.ts !== "number" || !state.categories || typeof state.categories !== "object") return null;
+  return buildConsent(categories, version, state.categories, state.ts);
+}
+export function localize(value, locale, fallback = "") {
+  if (!value) return fallback;
+  if (typeof value === "string") return value;
+  return value[locale] ?? value[locale.split("-")[0]] ?? value.en ?? Object.values(value)[0] ?? fallback;
+}

package/dist/runtime/utils/extend.d.ts

@@ -0,0 +1,11 @@
+import type { Nuxt } from '@nuxt/schema';
+import type { ConsentCategory } from '../../types.js';
+/**
+ * Lets another module contribute consent categories (or cookies to an existing one) during its own
+ * `setup()`. Registrations are merged by `key` once every module has set up, so order doesn't
+ * matter. Adding a category or cookie changes the consent version and re-prompts visitors.
+ */
+export declare function extendCookieConsent(nuxt: Nuxt, extension: {
+    categories: ConsentCategory[];
+}): void;
+export declare const defineConsentCategory: <T extends ConsentCategory>(category: T) => T;

package/dist/runtime/utils/extend.js

@@ -0,0 +1,7 @@
+export function extendCookieConsent(nuxt, extension) {
+  nuxt.options.cookieConsent ||= {};
+  nuxt.options.cookieConsent._categories ||= [];
+  nuxt.options.cookieConsent._categories.push(...extension.categories);
+  void nuxt.callHook("cookie-consent:extend", extension.categories);
+}
+export const defineConsentCategory = (category) => category;

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

@@ -0,0 +1,3 @@
+export { extendCookieConsent, defineConsentCategory } from './extend.js';
+export { DEFAULT_CATEGORIES, mergeCategories, computeVersion, buildConsent, normalizeConsent, acceptAllChoices, rejectAllChoices, localize, } from './consent.js';
+export type { ConsentCategory, ConsentCookie, ConsentState, Localized } from '../../types.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,11 @@
+export { extendCookieConsent, defineConsentCategory } from "./extend.js";
+export {
+  DEFAULT_CATEGORIES,
+  mergeCategories,
+  computeVersion,
+  buildConsent,
+  normalizeConsent,
+  acceptAllChoices,
+  rejectAllChoices,
+  localize
+} from "./consent.js";

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ConsentCategory, type ConsentCookie, type ConsentMessages, type ConsentState, type Localized, type ModuleOptions, type PublicModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "@frigear-nu/cookie-consent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "description": "GDPR cookie consent banner with categories - modules contribute categories (extendCookieConsent), apps gate scripts on consent, and the choice is stored as proof on the user.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/cookie-consent"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./utils": {
+      "types": "./dist/runtime/utils/index.d.ts",
+      "import": "./dist/runtime/utils/index.js",
+      "default": "./dist/runtime/utils/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "dependencies": {
+    "@frigear-nu/module-kit": "0.1.0",
+    "@libsql/client": "^0.18.0",
+    "@nuxt/kit": "^4.6.0",
+    "@vueuse/core": "^15.0.0",
+    "drizzle-kit": "^0.31.11",
+    "drizzle-orm": "^0.45.3",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "@frigear-nu/users": ">=0.0.1",
+    "@nuxthub/core": "^0.10.8",
+    "@nuxt/ui": "^4.10.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/ui": {
+      "optional": true
+    },
+    "@frigear-nu/users": {
+      "optional": true
+    },
+    "@nuxthub/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@frigear-nu/users": "1.0.2",
+    "@nuxt/devtools": "^3.4.2",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.6.0",
+    "@nuxt/test-utils": "^4.3.2",
+    "@nuxt/ui": "^4.11.0",
+    "@nuxthub/core": "^0.10.8",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.10.0",
+    "nuxt": "^4.6.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1",
+    "vue-tsc": "^3.3.11"
+  },
+  "scripts": {
+    "postinstall": "nuxt-module-build build --stub && nuxt prepare",
+    "build": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.