@nortic/citronkaka-ui 0.0.2-beta.32

package/dist/index-B7HVnsDG.js

@@ -0,0 +1,301 @@
+const m = { BASE_URL: "/", DEV: !1, DOMAIN: "localhost", MODE: "development", NODE_ENV: "development", PROD: !0, SSR: !1 }, { DOMAIN: h } = m, k = {
+  domain: h,
+  defaultModel: {
+    useraction: !1,
+    value: { necessary: !0, functional: !1, analytics: !1, marketing: !1 }
+  },
+  persistentKey: "nortic_cookie_consent",
+  persistentExpirationDays: 365,
+  categories: ["necessary", "functional", "analytics", "marketing"],
+  services: [
+    { name: "Translations", category: "functional", scripts: [], cookies: [/^i18n_redirected/] },
+    { name: "Color mode", category: "functional", scripts: [], cookies: [/^color-mode/] }
+  ]
+};
+class d {
+  static createCookieString(e, t, o = {}) {
+    const { expires: s, path: i = "/", sameSite: n = "Strict", domain: c } = o, a = encodeURIComponent(t), u = s ? `; expires=${s.toUTCString()}` : "", p = c ? `; domain=${c}` : "";
+    return `${e}=${a}${u}; path=${i}; SameSite=${n}${p}`;
+  }
+  /**
+   * Sets a cookie with the specified options.
+   * @param name The name of the cookie.
+   * @param value The value of the cookie (string or object).
+   * @param days Number of days until the cookie expires.
+   * @param domain Optional domain for the cookie.
+   */
+  static set(e, t, o, s) {
+    const i = typeof t == "string" ? t : JSON.stringify(t), n = new Date(Date.now() + o * 24 * 60 * 60 * 1e3);
+    document.cookie = this.createCookieString(e, i, { expires: n, domain: s });
+  }
+  /**
+   * Retrieves the value of a cookie by name.
+   * @param name The name of the cookie.
+   * @returns The value of the cookie or null if not found.
+   */
+  static get(e) {
+    const t = document.cookie.match(new RegExp(`(^| )${e}=([^;]+)`));
+    if (!t)
+      return null;
+    const o = decodeURIComponent(t[2]);
+    try {
+      return JSON.parse(o);
+    } catch {
+      return o;
+    }
+  }
+  /**
+   * Deletes a cookie by name.
+   * @param name The name of the cookie.
+   * @param domain Optional domain for the cookie.
+   */
+  static delete(e, t) {
+    document.cookie = this.createCookieString(e, "", {
+      expires: /* @__PURE__ */ new Date(0),
+      domain: t
+    });
+  }
+}
+class f {
+  /**
+   * Cleans up cookies based on a list of blacklist patterns.
+   * @param blacklist An array of RegExp patterns for cookies to delete.
+   */
+  static run(e, t = d) {
+    function o(s) {
+      document.cookie.split(";").forEach((i) => {
+        const n = i.split("=")[0].trim();
+        s.test(n) && (t.delete(n), console.warn(`Removed cookie: ${n}`));
+      });
+    }
+    e.forEach((s) => {
+      o(s);
+    });
+  }
+}
+class y {
+  /**
+   * Starts the cookie interception process to block cookies based on a blacklist.
+   * @param blacklist An array of RegExp patterns for cookie names to block.
+   */
+  static run(e) {
+    const t = Object.getOwnPropertyDescriptor(Document.prototype, "cookie");
+    if (!t) {
+      console.error("Failed to retrieve the cookie property descriptor.");
+      return;
+    }
+    Object.defineProperty(document, "cookie", {
+      configurable: !0,
+      enumerable: !0,
+      /**
+       * Getter for `document.cookie`.
+       * @returns The current cookies as a string.
+       */
+      get() {
+        var o;
+        return ((o = t.get) == null ? void 0 : o.call(document)) || "";
+      },
+      /**
+       * Setter for `document.cookie`. Intercepts and blocks cookies based on the blacklist.
+       * @param cookieString The cookie string to be set.
+       */
+      set(o) {
+        var s;
+        const i = o.split("=")[0].trim(), n = o.match(/expires=([^;]+)/i);
+        n && new Date(n[1]).getTime() < Date.now() || !e.some((c) => c.test(i)) ? (s = t.set) == null || s.call(document, o) : console.warn(`Blocked cookie: ${i}`);
+      }
+    });
+  }
+}
+class l {
+  /**
+   * Starts the script interception process with a list of blacklist patterns for script `src` attributes.
+   * @param blacklist An array of RegExp patterns for script `src` attributes to block.
+   */
+  static run(e) {
+    this.interceptScriptCreation(e), this.observeDynamicScripts(e);
+  }
+  /**
+   * Determines whether a script should be blocked based on its `src` attribute.
+   * @param blacklist An array of RegExp patterns to match against the script `src`.
+   * @param src The `src` attribute of the script to check.
+   * @returns True if the script should be blocked, false otherwise.
+   */
+  static shouldBlockScript(e, t) {
+    return e.some((o) => o.test(t));
+  }
+  /**
+   * Intercepts the creation of `<script>` elements via `document.createElement`.
+   * Blocks scripts with `src` matching a blacklist pattern.
+   * @param blacklist An array of RegExp patterns for script `src` attributes to block.
+   */
+  static interceptScriptCreation(e) {
+    const t = document.createElement.bind(document);
+    document.createElement = function(o) {
+      const s = t(o);
+      if (o.toLowerCase() === "script") {
+        const i = s, n = Object.getOwnPropertyDescriptor(
+          HTMLScriptElement.prototype,
+          "src"
+        );
+        n && Object.defineProperty(i, "src", {
+          configurable: !0,
+          enumerable: !0,
+          get() {
+            var c;
+            return (c = n.get) == null ? void 0 : c.call(i);
+          },
+          set(c) {
+            var a;
+            if (l.shouldBlockScript(e, c)) {
+              console.warn(`Blocked script: ${c}`), i.type = "javascript/blocked";
+              return;
+            }
+            (a = n.set) == null || a.call(i, c);
+          }
+        });
+      }
+      return s;
+    };
+  }
+  /**
+   * Observes dynamically added `<script>` elements in the DOM and blocks them if necessary.
+   * Prevents execution of blocked scripts by attaching a `beforescriptexecute` listener (Firefox specific fix).
+   * @param blacklist An array of RegExp patterns for script `src` attributes to block.
+   */
+  static observeDynamicScripts(e) {
+    new MutationObserver((t) => {
+      t.forEach(({ addedNodes: o }) => {
+        o.forEach((s) => {
+          if (s.nodeType === Node.ELEMENT_NODE && s.tagName === "SCRIPT") {
+            const i = s;
+            if (i.src && this.shouldBlockScript(e, i.src)) {
+              console.warn(`Blocked dynamically added script: ${i.src}`), i.type = "javascript/blocked";
+              const n = (c) => {
+                i.getAttribute("type") === "javascript/blocked" && (c.preventDefault(), console.warn(`Prevented execution of blocked script: ${i.src}`)), i.removeEventListener("beforescriptexecute", n);
+              };
+              i.addEventListener("beforescriptexecute", n);
+            }
+          }
+        });
+      });
+    }).observe(document.documentElement, {
+      childList: !0,
+      subtree: !0
+    });
+  }
+}
+class g {
+  constructor(e = k, t = { update: [] }, o = d, s = f, i = y, n = l) {
+    this.config = e, this.listeners = t, this.persistentService = o, this.cookieCleaner = s, this.cookieInterceptor = i, this.scriptInterceptor = n, s.run(this.blacklist.cookies), i.run(this.blacklist.cookies), n.run(this.blacklist.scripts);
+  }
+  /**
+   * Retrieves the current cookie consent model from persistent storage.
+   * If the stored value is invalid, it falls back to the default model.
+   */
+  get model() {
+    const e = this.persistentService.get(this.config.persistentKey);
+    return this.isCookieConsentModel(e) ? e : this.config.defaultModel;
+  }
+  /**
+   * Updates the cookie consent model in persistent storage after validation.
+   * @param value The new model to save. Must pass validation as a CookieConsentModel.
+   * @throws Error if the provided model is invalid.
+   */
+  set model(e) {
+    if (!this.isCookieConsentModel(e))
+      throw new Error("Invalid model: The provided value is not a valid CookieConsentModel.");
+    this.persistentService.set(
+      this.config.persistentKey,
+      e,
+      this.config.persistentExpirationDays,
+      this.config.domain
+    );
+  }
+  /**
+   * Update the cookie consent model and notify listeners.
+   * @param consent The new cookie consent values.
+   */
+  update(e) {
+    this.model = { useraction: !0, value: e }, this.notifyListeners("update");
+  }
+  /**
+   * Register an event listener for a specific event.
+   * @param eventName The name of the event.
+   * @param listener The listener function to register.
+   */
+  on(e, t) {
+    this.listeners[e].push(t);
+  }
+  /**
+   * Notify all listeners for a specific event.
+   * @param eventName The name of the event to notify.
+   */
+  notifyListeners(e) {
+    this.listeners[e].forEach((t) => t(this.model));
+  }
+  /**
+   * Generates a blacklist of cookies and scripts to block based on user consent.
+   * @returns An object containing arrays of cookies and scripts to block.
+   */
+  get blacklist() {
+    return this.config.services.reduce((e, t) => {
+      if (this.model.value[t.category] === !1) {
+        const { cookies: o, scripts: s } = t;
+        e.cookies = e.cookies.concat(o), e.scripts = e.scripts.concat(s);
+      }
+      return e;
+    }, { cookies: [], scripts: [] });
+  }
+  /**
+   * Validates whether a value conforms to the CookieConsentModel interface.
+   * @param value The value to validate.
+   * @returns True if the value is a valid CookieConsentModel, otherwise false.
+   */
+  isCookieConsentModel(e) {
+    if (typeof e != "object" || e === null)
+      return !1;
+    const t = e;
+    if (typeof t.useraction != "boolean" || typeof t.value != "object" || t.value === null)
+      return !1;
+    const o = t.value;
+    return o.necessary === !0 && typeof o.functional == "boolean" && typeof o.analytics == "boolean" && typeof o.marketing == "boolean";
+  }
+}
+window.Citronkaka = window.Citronkaka || new g();
+const v = window.Citronkaka;
+class b {
+  constructor(e = null, t = v) {
+    this.ui = e, this.service = t, this.init();
+  }
+  /**
+   * Initializes the cookie consent dialog if user action has not been recorded.
+   */
+  init() {
+    this.service.model.useraction || (this.loadUI(), this.service.on("update", (e) => {
+      e.useraction && this.unloadUI();
+    }));
+  }
+  /**
+   * Dynamically loads and displays the cookie consent dialog.
+   */
+  async loadUI() {
+    try {
+      const { NorticCookieConsentDialog: e } = await import("./index-DE_M_lA4.js");
+      window.customElements.get("nortic-cookie-consent-dialog") || window.customElements.define("nortic-cookie-consent-dialog", e), this.ui = document.createElement("nortic-cookie-consent-dialog"), this.ui.setAttribute("data-testid", "cookie-consent"), document.body.appendChild(this.ui);
+    } catch (e) {
+      console.error("Failed to load the cookie consent dialog:", e);
+    }
+  }
+  /**
+   * Removes the cookie consent dialog from the DOM.
+   */
+  unloadUI() {
+    this.ui && (document.body.removeChild(this.ui), this.ui = null);
+  }
+}
+const w = new b();
+export {
+  v as b,
+  w as i
+};