universal-ad-loader 0.0.0-stage → 0.1.0

package/dist/next.cjs

@@ -0,0 +1,35 @@
+'use client';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next.js
+var next_exports = {};
+__export(next_exports, {
+  AdSlot: () => import_react3.AdSlot,
+  UalProvider: () => UalProvider,
+  useUal: () => import_react3.useUal
+});
+module.exports = __toCommonJS(next_exports);
+var import_react = require("react");
+var import_navigation = require("next/navigation");
+var import_react2 = require("./react.cjs");
+var import_react3 = require("./react.cjs");
+function UalProvider(props) {
+  const pathname = (0, import_navigation.usePathname)();
+  return (0, import_react.createElement)(import_react2.UalProvider, { ...props, pageKey: props.pageKey !== void 0 ? props.pageKey : pathname });
+}

package/dist/next.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionComponent } from 'react';
+import type { UalProviderProps } from './react';
+
+export type { AdSlotProps } from './react';
+export { AdSlot, useUal } from './react';
+
+/** Come il UalProvider React, ma `pageKey` è il percorso (usePathname) e il cambio pagina è automatico. */
+export const UalProvider: FunctionComponent<UalProviderProps>;

package/dist/next.mjs

@@ -0,0 +1,16 @@
+'use client';
+
+// src/next.js
+import { createElement } from "react";
+import { usePathname } from "next/navigation";
+import { UalProvider as ReactProvider } from "./react.mjs";
+import { AdSlot, useUal } from "./react.mjs";
+function UalProvider(props) {
+  const pathname = usePathname();
+  return createElement(ReactProvider, { ...props, pageKey: props.pageKey !== void 0 ? props.pageKey : pathname });
+}
+export {
+  AdSlot,
+  UalProvider,
+  useUal
+};

package/dist/react.cjs

@@ -0,0 +1,122 @@
+'use client';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.js
+var react_exports = {};
+__export(react_exports, {
+  AdSlot: () => AdSlot,
+  UalProvider: () => UalProvider,
+  useUal: () => useUal
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+
+// src/wrappers/start.js
+var import_lib = require("./index.cjs");
+var loading = /* @__PURE__ */ new Map();
+function loadFromCdn(src) {
+  if (window.ual && window.ual.version) return Promise.resolve(window.ual);
+  if (!loading.has(src)) {
+    loading.set(src, new Promise((resolve, reject) => {
+      const s = document.createElement("script");
+      s.async = true;
+      s.src = src;
+      s.onload = () => {
+        if (window.ual && window.ual.version) resolve(window.ual);
+        else reject(new Error("il loader caricato da " + src + " non ha esposto window.ual"));
+      };
+      s.onerror = () => {
+        loading.delete(src);
+        reject(new Error("impossibile caricare il loader da " + src));
+      };
+      document.head.appendChild(s);
+    }));
+  }
+  return loading.get(src);
+}
+async function startUal({ config, src, beforeInit }) {
+  const ual = src ? await loadFromCdn(src) : (0, import_lib.getUal)();
+  if (beforeInit) beforeInit(ual);
+  const started = typeof ual.isInitialized === "function" && ual.isInitialized();
+  if (started) {
+    const p = typeof ual.whenReady === "function" ? ual.whenReady() : null;
+    if (p) await p;
+  } else {
+    await ual.init(config);
+  }
+  return ual;
+}
+
+// src/react.js
+var Ctx = (0, import_react.createContext)({ ual: null, ready: false });
+function useUal() {
+  return (0, import_react.useContext)(Ctx);
+}
+function UalProvider({ config, src, pageKey, targeting, onEvent, children }) {
+  const [state, setState] = (0, import_react.useState)({ ual: null, ready: false });
+  const configRef = (0, import_react.useRef)(config);
+  const onEventRef = (0, import_react.useRef)(onEvent);
+  onEventRef.current = onEvent;
+  const targetingRef = (0, import_react.useRef)(targeting);
+  targetingRef.current = targeting;
+  (0, import_react.useEffect)(() => {
+    let alive = true;
+    let off = null;
+    startUal({
+      config: configRef.current,
+      src,
+      beforeInit: (ual) => {
+        if (!alive) return;
+        if (targetingRef.current) ual.setTargeting(targetingRef.current);
+        off = ual.on("*", (data, evt) => {
+          if (onEventRef.current) onEventRef.current(evt, data);
+        });
+      }
+    }).then((ual) => {
+      if (alive) setState({ ual, ready: true });
+    }).catch((e) => console.warn("[UAL]", e && e.message ? e.message : e));
+    return () => {
+      alive = false;
+      if (off) off();
+    };
+  }, []);
+  const first = (0, import_react.useRef)(true);
+  (0, import_react.useEffect)(() => {
+    if (first.current) {
+      first.current = false;
+      return;
+    }
+    if (state.ual) state.ual.pageView();
+  }, [pageKey]);
+  const targetingKey = JSON.stringify(targeting || {});
+  (0, import_react.useEffect)(() => {
+    if (state.ual && targetingRef.current) state.ual.setTargeting(targetingRef.current);
+  }, [state.ual, targetingKey]);
+  return (0, import_react.createElement)(Ctx.Provider, { value: state }, children);
+}
+function AdSlot({ name, params, minHeight, className, style, id }) {
+  return (0, import_react.createElement)("div", {
+    id,
+    className,
+    "data-ad-slot": name,
+    "data-ad-params": params ? JSON.stringify(params) : void 0,
+    // riserva lo spazio già nell'HTML del server: nessun salto di layout quando arriva il banner
+    style: minHeight ? { minHeight, ...style } : style
+  });
+}

package/dist/react.d.ts

@@ -0,0 +1,36 @@
+import type { CSSProperties, FunctionComponent, ReactNode } from 'react';
+import type { Ual, UalConfig, Targeting, UalEventMap } from './index';
+
+export interface UalProviderProps {
+  /** Configurazione (oggetto, meglio con `defineConfig`) o URL del JSON. Letta solo all'avvio. */
+  config: UalConfig | string;
+  /** URL del loader su CDN (`ual.min.js`). Senza, UAL è incluso nel bundle del sito. */
+  src?: string;
+  /** Quando cambia, UAL ricalcola regole per pagina e slot (es. il percorso). */
+  pageKey?: string | number;
+  targeting?: Targeting;
+  /** Eventi di UAL (slotRendered, slotEmpty, consent, error…). */
+  onEvent?: <K extends keyof UalEventMap>(event: K, data: UalEventMap[K]) => void;
+  children?: ReactNode;
+}
+
+/** Avvia UAL dopo l'idratazione, una volta per pagina. Nessun DOM proprio. */
+export const UalProvider: FunctionComponent<UalProviderProps>;
+
+export interface AdSlotProps {
+  /** Nome dello slot in configurazione (data-ad-slot). */
+  name: string;
+  /** Sovrascrive i `params` del provider per questa istanza. */
+  params?: Record<string, unknown>;
+  /** Riserva lo spazio già nell'HTML del server (evita salti di layout). */
+  minHeight?: number;
+  className?: string;
+  style?: CSSProperties;
+  id?: string;
+}
+
+/** Una posizione pubblicitaria: un div vuoto che UAL riempie. */
+export const AdSlot: FunctionComponent<AdSlotProps>;
+
+/** `ual` è null finché UAL non è avviato (sempre null sul server). */
+export function useUal(): { ual: Ual | null; ready: boolean };

package/dist/react.mjs

@@ -0,0 +1,103 @@
+'use client';
+
+// src/react.js
+import { createContext, createElement, useContext, useEffect, useRef, useState } from "react";
+
+// src/wrappers/start.js
+import { getUal } from "./index.mjs";
+var loading = /* @__PURE__ */ new Map();
+function loadFromCdn(src) {
+  if (window.ual && window.ual.version) return Promise.resolve(window.ual);
+  if (!loading.has(src)) {
+    loading.set(src, new Promise((resolve, reject) => {
+      const s = document.createElement("script");
+      s.async = true;
+      s.src = src;
+      s.onload = () => {
+        if (window.ual && window.ual.version) resolve(window.ual);
+        else reject(new Error("il loader caricato da " + src + " non ha esposto window.ual"));
+      };
+      s.onerror = () => {
+        loading.delete(src);
+        reject(new Error("impossibile caricare il loader da " + src));
+      };
+      document.head.appendChild(s);
+    }));
+  }
+  return loading.get(src);
+}
+async function startUal({ config, src, beforeInit }) {
+  const ual = src ? await loadFromCdn(src) : getUal();
+  if (beforeInit) beforeInit(ual);
+  const started = typeof ual.isInitialized === "function" && ual.isInitialized();
+  if (started) {
+    const p = typeof ual.whenReady === "function" ? ual.whenReady() : null;
+    if (p) await p;
+  } else {
+    await ual.init(config);
+  }
+  return ual;
+}
+
+// src/react.js
+var Ctx = createContext({ ual: null, ready: false });
+function useUal() {
+  return useContext(Ctx);
+}
+function UalProvider({ config, src, pageKey, targeting, onEvent, children }) {
+  const [state, setState] = useState({ ual: null, ready: false });
+  const configRef = useRef(config);
+  const onEventRef = useRef(onEvent);
+  onEventRef.current = onEvent;
+  const targetingRef = useRef(targeting);
+  targetingRef.current = targeting;
+  useEffect(() => {
+    let alive = true;
+    let off = null;
+    startUal({
+      config: configRef.current,
+      src,
+      beforeInit: (ual) => {
+        if (!alive) return;
+        if (targetingRef.current) ual.setTargeting(targetingRef.current);
+        off = ual.on("*", (data, evt) => {
+          if (onEventRef.current) onEventRef.current(evt, data);
+        });
+      }
+    }).then((ual) => {
+      if (alive) setState({ ual, ready: true });
+    }).catch((e) => console.warn("[UAL]", e && e.message ? e.message : e));
+    return () => {
+      alive = false;
+      if (off) off();
+    };
+  }, []);
+  const first = useRef(true);
+  useEffect(() => {
+    if (first.current) {
+      first.current = false;
+      return;
+    }
+    if (state.ual) state.ual.pageView();
+  }, [pageKey]);
+  const targetingKey = JSON.stringify(targeting || {});
+  useEffect(() => {
+    if (state.ual && targetingRef.current) state.ual.setTargeting(targetingRef.current);
+  }, [state.ual, targetingKey]);
+  return createElement(Ctx.Provider, { value: state }, children);
+}
+function AdSlot({ name, params, minHeight, className, style, id }) {
+  return createElement("div", {
+    id,
+    className,
+    "data-ad-slot": name,
+    "data-ad-params": params ? JSON.stringify(params) : void 0,
+    // riserva lo spazio già nell'HTML del server: nessun salto di layout quando arriva il banner
+    style: minHeight ? { minHeight, ...style } : style
+  });
+}
+export {
+  AdSlot,
+  UalProvider,
+  useUal
+};