@tilli-pro/cookieconsent-plugin 0.1.9 → 0.1.11

package/dist/config/gui-options/html-components/TilliXCallout.js

@@ -0,0 +1,28 @@
+"use client";
+import assets from "../../../assets";
+const translations = {
+    de: {
+        poweredByTilliX: "unterstützt von tilliX",
+    },
+    en: {
+        poweredByTilliX: "powered by tilliX",
+    },
+    es: {
+        poweredByTilliX: "impulsado por tilliX",
+    },
+    fr: {
+        poweredByTilliX: "propulsé par tilliX",
+    },
+    it: {
+        poweredByTilliX: "alimentato da tilliX",
+    },
+};
+export default (lang = "en", inPrefs) => `
+<!-- "powered by tilliX" callout -->
+<div style="${!inPrefs ? "margin-left: auto; " : ""}margin-top: auto; margin-bottom: auto">
+  <abbr title="${translations[lang].poweredByTilliX}" style="${inPrefs ? "margin-right: 1em" : "margin-left: 1.3rem"}; display: flex; align-items: center">
+    <a href="https://tilli.pro" target="_blank" style="display: inline-block; background-image: none">
+      <img src="data:image/svg+xml;charset=utf8,${encodeURIComponent(assets.logo)}" alt="tilli" style="height: 1em; width: auto; min-height: 1em; min-width: 1em; vertical-align: middle" />
+    </a>
+  </abbr>
+</div>`;

package/dist/config/gui-options/html-components/assets/CookieIcon.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (centered?: boolean | (1 | 0), scale?: number, topOffset?: number, rightOffset?: number) => string;
+export default _default;
+//# sourceMappingURL=CookieIcon.d.ts.map

package/dist/config/gui-options/html-components/assets/CookieIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CookieIcon.d.ts","sourceRoot":"","sources":["../../../../../src/config/gui-options/html-components/assets/CookieIcon.ts"],"names":[],"mappings":"oCAKa,OAAO,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,+DAI3B,MAAM;AALT,wBAUS"}

package/dist/config/gui-options/html-components/assets/CookieIcon.js

@@ -0,0 +1,10 @@
+"use client";
+import assets from "../../../../assets";
+export default (centered /* 😉 */, scale = 0.6667, // -> 0.6667 ((100 * n)%)
+topOffset = 0, // -> -0.25 (em)
+rightOffset = 0) => `
+<span style="display: inline-block; vertical-align: middle; transform: scale(${scale}); transform-origin: top left; margin-right: ${((centered ? -0.5 : -0.25) + rightOffset).toFixed(4)}em; height: 1em${topOffset ? `; margin-top: ${topOffset.toFixed(4)}em` : ""};">
+  ${assets.cookie}
+  <!-- invisible "🍪" icon (used for copy-paste/a11y purposes) -->
+  <span style="max-width: 0; max-height: 0; opacity: 0; position: absolute">🍪</span>
+</span>`;

package/dist/config/gui-options/index.d.ts

@@ -0,0 +1,18 @@
+/** IMPORTANT NOTES FOR GDPR COMPLIANCE:
+ * > the "Accept" and "Reject" buttons should be equally weighted in terms of size, color, and font. This means that the buttons should be equally accessible and prominent– `equalWeightButtons` must be `true`. */
+declare const _default: {
+    consentModal: {
+        layout: "box";
+        position: "bottom left";
+        equalWeightButtons: true;
+        flipButtons: false;
+    };
+    preferencesModal: {
+        layout: "box";
+        position: "right";
+        equalWeightButtons: true;
+        flipButtons: false;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/gui-options/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/gui-options/index.ts"],"names":[],"mappings":"AAEA;oNACoN;;;;;;;;;;;;;;;AAEpN,wBAauB"}

package/dist/config/gui-options/index.js

@@ -0,0 +1,16 @@
+/** IMPORTANT NOTES FOR GDPR COMPLIANCE:
+ * > the "Accept" and "Reject" buttons should be equally weighted in terms of size, color, and font. This means that the buttons should be equally accessible and prominent– `equalWeightButtons` must be `true`. */
+export default {
+    consentModal: {
+        layout: "box",
+        position: "bottom left",
+        equalWeightButtons: true, // IMPORTANT: MUST BE `true` TO BE GDPR-COMPLIANT
+        flipButtons: false,
+    },
+    preferencesModal: {
+        layout: "box",
+        position: "right", // not in use since we use "box" (aka a modal)– if we use "bar" (aka a drawer), this will be used
+        equalWeightButtons: true, // IMPORTANT: MUST BE `true` TO BE GDPR-COMPLIANT
+        flipButtons: false,
+    },
+};

package/dist/config/gui-options/scripts/cookiePrefsButtonDragObserver.d.ts

@@ -0,0 +1,20 @@
+/**
+ * attach a MutationObserver the **first time** the user hovers over–
+ * enabling a limited "drag up" functionality for the floating button.
+ *  > this is a purposeful UX enhancement to allow users to move the button
+ *    out of the way in case it’s blocking content/functionality underneath.
+ *
+ * @usage simply attach this function to the `onmouseover` event of the floating button.
+ * @see {@link ./injectManageCookiePrefsButton.tsx HTMLDivElement["onmouseover"]} for the full implementation.
+ */
+declare const _default: <IsTouch extends boolean = false>() => HTMLDivElement[IsTouch extends true ? "ontouchstart" : "onmouseover"];
+export default _default;
+export type HTMLDivElementWithDragObserver = HTMLDivElement & {
+    _startX?: number | null;
+    _startY?: number | null;
+};
+/** determine whether the user "tapped" or "dragged" (open prefs if "tapped") */
+export declare const ontouchend: HTMLDivElementWithDragObserver["ontouchend"];
+/** store the touch start coordinates */
+export declare const ontouchstart: HTMLDivElementWithDragObserver["ontouchstart"];
+//# sourceMappingURL=cookiePrefsButtonDragObserver.d.ts.map

package/dist/config/gui-options/scripts/cookiePrefsButtonDragObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookiePrefsButtonDragObserver.d.ts","sourceRoot":"","sources":["../../../../src/config/gui-options/scripts/cookiePrefsButtonDragObserver.ts"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;yBAuHG,OAAO,SAAS,OAAO,eAAe,cAAc,CAAC,OAAO,SAAS,IAAI,GAC3E,cAAc,GACd,aAAa,CAAC;AAxHlB,wBAwHoB;AAEpB,MAAM,MAAM,8BAA8B,GAAG,cAAc,GAAG;IAC5D,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,UAAU,EA0BlB,8BAA8B,CAAC,YAAY,CAAC,CAAC;AAElD,wCAAwC;AACxC,eAAO,MAAM,YAAY,EAOpB,8BAA8B,CAAC,cAAc,CAAC,CAAC"}

package/dist/config/gui-options/scripts/cookiePrefsButtonDragObserver.js

@@ -0,0 +1,143 @@
+"use client";
+import { showPreferences } from "@tilli-pro/cookieconsent";
+import { buttonId } from "../html-components/ManageCookiePrefsButton";
+/**
+ * attach a MutationObserver the **first time** the user hovers over–
+ * enabling a limited "drag up" functionality for the floating button.
+ *  > this is a purposeful UX enhancement to allow users to move the button
+ *    out of the way in case it’s blocking content/functionality underneath.
+ *
+ * @usage simply attach this function to the `onmouseover` event of the floating button.
+ * @see {@link ./injectManageCookiePrefsButton.tsx HTMLDivElement["onmouseover"]} for the full implementation.
+ */
+export default (function (e) {
+    /** we store a data-attribute (`hasTilliCookiePrefsDragObserverInit`) to avoid reattaching
+     * the logic on multiple hovers -- this ensures the script is only initiated once. */
+    if (this.dataset.hasTilliCookiePrefsDragObserverInit === "true")
+        return;
+    this.dataset.hasTilliCookiePrefsDragObserverInit = "true";
+    let isDragging = false;
+    let startY = 0;
+    let initialBottomPx = 0;
+    let hasListeners = false; // track whether we've attached the events yet
+    /** we'll dynamically calculate these values on the first drag */
+    let lowestBottomPx = 0;
+    let highestBottomPx = 0;
+    // DRAG LOGIC
+    function onMouseDown(e) {
+        if (e.button !== 0)
+            return; // only drag on left-click
+        e.preventDefault();
+        isDragging = true;
+        startY = e.clientY;
+        /** on each new drag, read the button’s *current* bottom */
+        const buttonStyle = window.getComputedStyle(this);
+        initialBottomPx = parseFloat(buttonStyle.bottom) || 16;
+    }
+    function onMouseMove(e) {
+        if (!isDragging)
+            return;
+        /** positive delta => pointer moving down => button goes up */
+        const dragDelta = startY - e.clientY;
+        let newBottomPx = initialBottomPx + dragDelta;
+        /** clamp between lowestBottomPx and highestBottomPx */
+        if (newBottomPx < lowestBottomPx)
+            newBottomPx = lowestBottomPx;
+        if (newBottomPx > highestBottomPx)
+            newBottomPx = highestBottomPx;
+        this.style.bottom = `${newBottomPx}px`;
+    }
+    function onMouseUp() {
+        isDragging = false;
+    }
+    // [mobile (touch) support]
+    // - we also want to allow dragging on touch devices
+    // - we're using the same logic as mouse dragging, but with touch events
+    function onTouchStart(e) {
+        if (e.touches?.length !== 1)
+            return; // only drag with one finger
+        e.preventDefault();
+        isDragging = true;
+        startY = e.touches[0]?.clientY ?? startY;
+        const buttonStyle = window.getComputedStyle(this);
+        initialBottomPx = parseFloat(buttonStyle.bottom) || 16;
+    }
+    function onTouchMove(e) {
+        if (!isDragging)
+            return;
+        if (!e.touches?.[0])
+            return;
+        const dragDelta = startY - e.touches[0].clientY;
+        let newBottomPx = initialBottomPx + dragDelta;
+        if (newBottomPx < lowestBottomPx)
+            newBottomPx = lowestBottomPx;
+        if (newBottomPx > highestBottomPx)
+            newBottomPx = highestBottomPx;
+        this.style.bottom = `${newBottomPx}px`;
+    }
+    function onTouchEnd() {
+        isDragging = false;
+    }
+    function attachDragEvents(buttonEl) {
+        if (hasListeners)
+            return; // only attach once
+        hasListeners = true;
+        /** determine max drag distance (based on button height) */
+        const buttonStyle = window.getComputedStyle(buttonEl);
+        const originalBottomPx = parseFloat(buttonStyle.bottom) || 16; // fallback to ~1rem
+        const buttonHeightPx = parseFloat(buttonStyle.height) || 32; // fallback to ~2rem
+        const maxDragPx = buttonHeightPx * 1.1; // added 10% extra to be safe
+        /** the user can drag from the original position (lowestBottomPx) up by that computed distance (highestBottomPx). */
+        lowestBottomPx = originalBottomPx;
+        highestBottomPx = originalBottomPx + maxDragPx;
+        /** attach the mouse events for dragging */
+        buttonEl.addEventListener("mousedown", onMouseDown.bind(buttonEl));
+        document.addEventListener("mousemove", onMouseMove.bind(buttonEl));
+        document.addEventListener("mouseup", onMouseUp);
+        // [mobile (touch) support]
+        buttonEl.addEventListener("touchstart", onTouchStart.bind(buttonEl));
+        document.addEventListener("touchmove", onTouchMove.bind(buttonEl));
+        document.addEventListener("touchend", onTouchEnd);
+    }
+    // MUTATION OBSERVER – for if the button is removed/re-added
+    const observer = new MutationObserver(() => {
+        const button = document.getElementById(buttonId);
+        if (!button) {
+            hasListeners = false; // if button was removed, reset flags
+            isDragging = false;
+            return;
+        }
+        attachDragEvents(button);
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    /** if the button is already present, attach drag events immediately */
+    const button = document.getElementById(buttonId);
+    if (button)
+        attachDragEvents(button);
+});
+/** determine whether the user "tapped" or "dragged" (open prefs if "tapped") */
+export const ontouchend = function ontouchend(e) {
+    const touch = e.changedTouches[0];
+    const { clientX: endX, clientY: endY } = touch ?? {};
+    if (!endX || !endY)
+        return;
+    /** retrieve stored start coordinates */
+    const startX = this._startX ?? endX;
+    const startY = this._startY ?? endY;
+    /** threshold for "same spot" */
+    const threshold = 10; // maximum allowable movement (in pixels)
+    /** make sure the user ended their touch in *relatively* the "same spot" as they started */
+    if (Math.abs(endX - startX) <= threshold &&
+        Math.abs(endY - startY) <= threshold)
+        /** user ended the touch near where it started, open preferences */
+        showPreferences(); /** prefer over `data-cc="show-preferencesModal"` -- @see https://cookieconsent.orestbida.com/reference/api-reference.html#showpreferences */
+    /** reset coordinates to avoid future issues */
+    this._startX = null;
+    this._startY = null;
+};
+/** store the touch start coordinates */
+export const ontouchstart = function ontouchstart(e) {
+    const touch = e.touches[0];
+    this._startX = touch?.clientX;
+    this._startY = touch?.clientY;
+};

package/dist/config/gui-options/scripts/forceDisableReactRemoveScroll.d.ts

@@ -0,0 +1,17 @@
+/**
+ * force the "React Remove Scroll" wheel listener to be passive or not.
+ *
+ * @param isPassive - Set `true` to make it `{ passive: true }`,
+ *                    `false` for `{ passive: false }`.
+ */
+export declare function forceDisableReactRemoveScroll(isPassive: boolean, debug?: boolean): void;
+/**
+ * inject event listeners for CookieConsent's modal show/hide events,
+ * toggling the "React Remove Scroll" listener's passive state.
+ *
+ * listens for:
+ *  - "cc:onModalShow": If "preferencesModal", we set passive = true.
+ *  - "cc:onModalHide": If "preferencesModal", we set passive = false.
+ */
+export declare function injectReactRemoveScrollToggle(): void;
+//# sourceMappingURL=forceDisableReactRemoveScroll.d.ts.map

package/dist/config/gui-options/scripts/forceDisableReactRemoveScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forceDisableReactRemoveScroll.d.ts","sourceRoot":"","sources":["../../../../src/config/gui-options/scripts/forceDisableReactRemoveScroll.ts"],"names":[],"mappings":"AAmFA;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,OAAO,EAClB,KAAK,UAAQ,QA8Bd;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CAoBpD"}

package/dist/config/gui-options/scripts/forceDisableReactRemoveScroll.js

@@ -0,0 +1,97 @@
+"use client";
+// IMPORTANT: this is a fix to force-disable the "React Remove Scroll" wheel listener -- this handles the edge case where there's a shadcn (radix-ui) dialog open underneath the cookie banner's "manage preferences" dialog, which prevents the user from scrolling within the manage prefs dialog.
+/** IMPORTANT: this is what we'll be looking for in the listener's source code -- @see https://github.com/theKashey/react-remove-scroll/blob/master/src/SideEffect.tsx#L107-L145 */
+const DISTINCTIVE_SUBSTRINGS = ["shards", "noIsolation"];
+const eventListenersMap = new WeakMap();
+let isPatched = false; // ensure patching happens only ONCE.
+/** 🦧 monkey(orangutan)-patch `addEventListener` and `removeEventListener` to track listeners. */
+function patchEventListeners() {
+    if (isPatched)
+        return; // prevent multiple patches
+    isPatched = true;
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalAddEventListener = EventTarget.prototype.addEventListener;
+    EventTarget.prototype.addEventListener = function (type, listener, options) {
+        let records = eventListenersMap.get(this);
+        if (!records) {
+            records = [];
+            eventListenersMap.set(this, records);
+        }
+        records.push({ type, listener, options });
+        originalAddEventListener.call(this, type, listener, options);
+    };
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalRemoveEventListener = EventTarget.prototype.removeEventListener;
+    EventTarget.prototype.removeEventListener = function (type, listener, options) {
+        const records = eventListenersMap.get(this);
+        if (records) {
+            const index = records.findIndex((r) => r.type === type && r.listener === listener && r.options === options);
+            if (index !== -1) {
+                records.splice(index, 1);
+                if (records.length === 0)
+                    eventListenersMap.delete(this);
+            }
+        }
+        originalRemoveEventListener.call(this, type, listener, options);
+    };
+}
+/** attempt to find the "React Remove Scroll" wheel listeners by searching for unique strings in its source code */
+const findReactRemoveScrollListeners = () => 
+/** find all matching listeners that have ALL required substrings */
+(eventListenersMap.get(document) ?? []).filter((record) => {
+    if (record.type === "wheel" ||
+        record.type === "touchmove" ||
+        record.type === "touchstart" ||
+        record.type === "pointerdown" ||
+        record.type === "click") {
+        const fnStr = record.listener.toString();
+        return DISTINCTIVE_SUBSTRINGS.every((sub) => fnStr.includes(sub));
+    }
+    return false;
+});
+/**
+ * force the "React Remove Scroll" wheel listener to be passive or not.
+ *
+ * @param isPassive - Set `true` to make it `{ passive: true }`,
+ *                    `false` for `{ passive: false }`.
+ */
+export function forceDisableReactRemoveScroll(isPassive, debug = false) {
+    const targets = findReactRemoveScrollListeners();
+    if (!targets || targets.length === 0) {
+        if (debug)
+            console.debug('No matching "React Remove Scroll" listener found.');
+        return;
+    }
+    /** remove the existing listener */
+    for (const target of targets) {
+        document.removeEventListener(target.type, target.listener, target.options);
+        /** re-add with the new passive value */
+        document.addEventListener(target.type, target.listener, {
+            ...(typeof target.options === "boolean" ? {} : target.options),
+            passive: isPassive,
+        });
+        if (debug)
+            console.debug(`"React Remove Scroll" ${target.type} listener set to passive: ${isPassive} (aka, we've ${isPassive ? "bypassed" : "re-enabled"} it)`);
+    }
+}
+/**
+ * inject event listeners for CookieConsent's modal show/hide events,
+ * toggling the "React Remove Scroll" listener's passive state.
+ *
+ * listens for:
+ *  - "cc:onModalShow": If "preferencesModal", we set passive = true.
+ *  - "cc:onModalHide": If "preferencesModal", we set passive = false.
+ */
+export function injectReactRemoveScrollToggle() {
+    patchEventListeners(); // ensure patching happens only once
+    window.addEventListener("cc:onModalShow", (event) => {
+        const { detail } = event ?? {};
+        if (detail?.modalName === "preferencesModal")
+            forceDisableReactRemoveScroll(true); // force passive
+    });
+    window.addEventListener("cc:onModalHide", (event) => {
+        const { detail } = event ?? {};
+        if (detail?.modalName === "preferencesModal")
+            forceDisableReactRemoveScroll(false); // force non-passive
+    });
+}

package/dist/config/gui-options/scripts/injectManageCookiePrefsButton.d.ts

@@ -0,0 +1,5 @@
+/** injects the floating cookie consent "manage preferences" icon button into the DOM */
+declare const inject: () => HTMLDivElement;
+declare const _default: () => ReturnType<typeof inject>;
+export default _default;
+//# sourceMappingURL=injectManageCookiePrefsButton.d.ts.map

package/dist/config/gui-options/scripts/injectManageCookiePrefsButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectManageCookiePrefsButton.d.ts","sourceRoot":"","sources":["../../../../src/config/gui-options/scripts/injectManageCookiePrefsButton.ts"],"names":[],"mappings":"AAaA,wFAAwF;AACxF,QAAA,MAAM,MAAM,QAAO,cAkBlB,CAAC;8BACiB,UAAU,CAAC,OAAO,MAAM,CAAC;AAA5C,wBAgBI"}

package/dist/config/gui-options/scripts/injectManageCookiePrefsButton.js

@@ -0,0 +1,31 @@
+"use client";
+import { showPreferences } from "@tilli-pro/cookieconsent";
+import ManageCookiePrefsButton, { containerId, } from "../html-components/ManageCookiePrefsButton";
+import cookiePrefsButtonDragObserver, { ontouchend, ontouchstart, } from "./cookiePrefsButtonDragObserver";
+/** injects the floating cookie consent "manage preferences" icon button into the DOM */
+const inject = () => {
+    const container = document.body.appendChild(Object.assign(document.createElement("div"), {
+        id: containerId,
+        innerHTML: ManageCookiePrefsButton( /* TODO: __LANGUAGE__ */),
+        onclick: showPreferences /** prefer over `data-cc="show-preferencesModal"` -- @see https://cookieconsent.orestbida.com/reference/api-reference.html#showpreferences */,
+        onmouseover: cookiePrefsButtonDragObserver,
+        // [mobile (touch) support]
+        ontouchend,
+        ontouchstart,
+    }));
+    /** load drag observer upon DOM injection (unfortunate fix to prevent the need for 2x "ontouchstart" events) */
+    cookiePrefsButtonDragObserver.call(container);
+    return container;
+};
+export default () => ((container) => {
+    /** observe the DOM (to handle the case where the injected manage prefs button somehow gets removed) */
+    new MutationObserver(() => {
+        const alreadyInjected = !!document.getElementById(containerId) ||
+            document.body.contains(container);
+        if (alreadyInjected)
+            return;
+        /** if the container is no longer in <body>, re-inject */
+        container = inject();
+    }).observe(document.body, { childList: true, subtree: true });
+    return container;
+})(document.getElementById(containerId) ?? inject());

package/dist/config/index.d.ts

@@ -0,0 +1,227 @@
+declare const _default: {
+    revision: number;
+    guiOptions: {
+        consentModal: {
+            layout: "box";
+            position: "bottom left";
+            equalWeightButtons: true;
+            flipButtons: false;
+        };
+        preferencesModal: {
+            layout: "box";
+            position: "right";
+            equalWeightButtons: true;
+            flipButtons: false;
+        };
+    };
+    categories: {
+        necessary: {
+            enabled: true;
+            readOnly: true;
+            services: {
+                tilliX: {
+                    label: string;
+                    cookies: import("./cookies/types").CookieTableItem[];
+                };
+            };
+        };
+        functional: {
+            services: {
+                tilliX: {
+                    label: string;
+                    cookies: import("./cookies/types").CookieTableItem[];
+                };
+            };
+            autoClear: {
+                cookies: {
+                    name: RegExp;
+                }[];
+            };
+        };
+        analytics: {
+            services: {
+                datadog: {
+                    label: string;
+                    cookies: import("./cookies/types").CookieTableItem[];
+                };
+            };
+            autoClear: {
+                cookies: {
+                    name: RegExp;
+                }[];
+            };
+        };
+    };
+    language: {
+        default: string;
+        autoDetect: "browser";
+        translations: {
+            de: {
+                consentModal: {
+                    title: string;
+                    description: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    showPreferencesBtn: string;
+                    revisionMessage: string;
+                    footer: string;
+                };
+                preferencesModal: {
+                    title: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    savePreferencesBtn: string;
+                    closeIconLabel: string;
+                    sections: ({
+                        title: string;
+                        description: string;
+                        linkedCategory?: undefined;
+                        cookieTable?: undefined;
+                    } | {
+                        title: string;
+                        description: string;
+                        linkedCategory: string;
+                        cookieTable: {
+                            headers: import("./cookies/types").CookieTableHeaders;
+                            body: import("./cookies/types").CookieTableItem[];
+                        };
+                    })[];
+                };
+            };
+            en: {
+                consentModal: {
+                    title: string;
+                    description: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    showPreferencesBtn: string;
+                    revisionMessage: string;
+                    footer: string;
+                };
+                preferencesModal: {
+                    title: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    savePreferencesBtn: string;
+                    closeIconLabel: string;
+                    sections: ({
+                        title: string;
+                        description: string;
+                        linkedCategory?: undefined;
+                        cookieTable?: undefined;
+                    } | {
+                        title: string;
+                        description: string;
+                        linkedCategory: string;
+                        cookieTable: {
+                            headers: import("./cookies/types").CookieTableHeaders;
+                            body: import("./cookies/types").CookieTableItem[];
+                        };
+                    })[];
+                };
+            };
+            es: {
+                consentModal: {
+                    title: string;
+                    description: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    showPreferencesBtn: string;
+                    revisionMessage: string;
+                    footer: string;
+                };
+                preferencesModal: {
+                    title: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    savePreferencesBtn: string;
+                    closeIconLabel: string;
+                    sections: ({
+                        title: string;
+                        description: string;
+                        linkedCategory?: undefined;
+                        cookieTable?: undefined;
+                    } | {
+                        title: string;
+                        description: string;
+                        linkedCategory: string;
+                        cookieTable: {
+                            headers: import("./cookies/types").CookieTableHeaders;
+                            body: import("./cookies/types").CookieTableItem[];
+                        };
+                    })[];
+                };
+            };
+            fr: {
+                consentModal: {
+                    title: string;
+                    description: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    showPreferencesBtn: string;
+                    revisionMessage: string;
+                    footer: string;
+                };
+                preferencesModal: {
+                    title: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    savePreferencesBtn: string;
+                    closeIconLabel: string;
+                    sections: ({
+                        title: string;
+                        description: string;
+                        linkedCategory?: undefined;
+                        cookieTable?: undefined;
+                    } | {
+                        title: string;
+                        description: string;
+                        linkedCategory: string;
+                        cookieTable: {
+                            headers: import("./cookies/types").CookieTableHeaders;
+                            body: import("./cookies/types").CookieTableItem[];
+                        };
+                    })[];
+                };
+            };
+            it: {
+                consentModal: {
+                    title: string;
+                    description: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    showPreferencesBtn: string;
+                    revisionMessage: string;
+                    footer: string;
+                };
+                preferencesModal: {
+                    title: string;
+                    acceptAllBtn: string;
+                    acceptNecessaryBtn: string;
+                    savePreferencesBtn: string;
+                    closeIconLabel: string;
+                    sections: ({
+                        title: string;
+                        description: string;
+                        linkedCategory?: undefined;
+                        cookieTable?: undefined;
+                    } | {
+                        title: string;
+                        description: string;
+                        linkedCategory: string;
+                        cookieTable: {
+                            headers: import("./cookies/types").CookieTableHeaders;
+                            body: import("./cookies/types").CookieTableItem[];
+                        };
+                    })[];
+                };
+            };
+        };
+    };
+    cookie: {
+        name: string;
+    };
+    hideFromBots: boolean;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,wBAOgC"}

package/dist/config/index.js

@@ -0,0 +1,13 @@
+import { env } from "~/_env";
+import { COOKIE_PREFERENCES_COOKIE_NAME, REVISION } from "../_consts";
+import categories from "./categories";
+import guiOptions from "./gui-options";
+import translations from "./translations";
+export default {
+    revision: REVISION,
+    guiOptions,
+    categories,
+    language: { default: "en", autoDetect: "browser", translations },
+    cookie: { name: COOKIE_PREFERENCES_COOKIE_NAME },
+    hideFromBots: env.NODE_ENV === "production", // disabled in local dev to enable ui-testing (via Playwright)
+};