@anker-in/analysis 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -0,0 +1,827 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GtagPixel: () => GtagPixel_default,
+  MetaPixel: () => MetaPixel_default,
+  PixelsManager: () => PixelsManager_default,
+  TrackTagsVersionMap: () => TrackTagsVersionMap,
+  clearTrackTags: () => clearTrackTags,
+  default: () => index_default,
+  gtagTrack: () => gtagTrack,
+  hasTrackPoint: () => hasTrackPoint,
+  isPlatformAvailable: () => isPlatformAvailable,
+  logger: () => logger,
+  metaTrack: () => metaTrack,
+  setTrackTags: () => setTrackTags,
+  track: () => track,
+  trackByTags: () => trackByTags,
+  triggerTrack: () => triggerTrack,
+  triggerTrackBatch: () => triggerTrackBatch,
+  updateScriptType: () => updateScriptType,
+  updateScriptsType: () => updateScriptsType,
+  useTracking: () => useTracking,
+  withTracking: () => withTracking
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/helpers/logger.ts
+function createLogger(initialEnabled = false) {
+  let enabled = initialEnabled;
+  return {
+    setEnabled(value) {
+      enabled = value;
+    },
+    log(...args) {
+      if (enabled) {
+        console.log("[Analysis SDK]", ...args);
+      }
+    },
+    warn(...args) {
+      if (enabled) {
+        console.warn("[Analysis SDK]", ...args);
+      }
+    },
+    error(...args) {
+      if (enabled) {
+        console.error("[Analysis SDK]", ...args);
+      }
+    }
+  };
+}
+__name(createLogger, "createLogger");
+var logger = createLogger();
+
+// src/core/helpers/script-loader.ts
+function updateScriptType(options) {
+  const { id, enabled, executeOnEnable = true, onError } = options;
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const scriptElement = document.getElementById(id);
+  if (!scriptElement) {
+    logger.warn(`Script element with id "${id}" not found`);
+    return false;
+  }
+  const newType = enabled ? "text/javascript" : "text/plain";
+  const currentType = scriptElement.getAttribute("type");
+  if (executeOnEnable && currentType === "text/plain" && newType === "text/javascript") {
+    scriptElement.setAttribute("type", newType);
+    const scriptContent = scriptElement.innerHTML;
+    if (scriptContent && typeof window.eval === "function") {
+      try {
+        window.eval(scriptContent);
+        logger.log(`Script "${id}" executed successfully`);
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e));
+        logger.error(`Script "${id}" execution error:`, error);
+        if (onError) {
+          onError(error);
+        }
+      }
+    }
+  } else {
+    scriptElement.setAttribute("type", newType);
+  }
+  return true;
+}
+__name(updateScriptType, "updateScriptType");
+function updateScriptsType(scriptIds, enabled, executeOnEnable = true) {
+  if (typeof window === "undefined") {
+    return 0;
+  }
+  let successCount = 0;
+  const ids = Array.isArray(scriptIds) ? scriptIds : Array.from({ length: 100 }, (_, i) => scriptIds(i)).filter(
+    (id) => document.getElementById(id)
+  );
+  ids.forEach((id) => {
+    const success = updateScriptType({
+      id,
+      enabled,
+      executeOnEnable
+    });
+    if (success) {
+      successCount++;
+    }
+  });
+  logger.log(`Updated ${successCount}/${ids.length} scripts`);
+  return successCount;
+}
+__name(updateScriptsType, "updateScriptsType");
+
+// src/core/helpers/function-utils.ts
+function debounce(fn, delay) {
+  let timer = null;
+  return function(...args) {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      fn.apply(this, args);
+    }, delay);
+  };
+}
+__name(debounce, "debounce");
+function throttle(fn, delay) {
+  let lastTime = 0;
+  return function(...args) {
+    const now = Date.now();
+    if (now - lastTime >= delay) {
+      lastTime = now;
+      fn.apply(this, args);
+    }
+  };
+}
+__name(throttle, "throttle");
+
+// src/core/helpers/platform-detector.ts
+var isPlatformAvailable = /* @__PURE__ */ __name((platform) => {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  switch (platform) {
+    case "gtag":
+      return typeof window.gtag !== "undefined" || typeof window.dataLayer !== "undefined";
+    case "meta":
+      return typeof window.fbq !== "undefined";
+    default:
+      return false;
+  }
+}, "isPlatformAvailable");
+
+// src/constants/tagsMap.ts
+var TrackTagsVersionMap = {
+  "fbq:act": "fbq:atc",
+  "gtag:conversion": "gtag:atc"
+};
+
+// src/autoTrack/trackByTags.ts
+function parseTag(tag) {
+  const parts = tag.split(":");
+  if (parts.length < 2) {
+    return null;
+  }
+  return {
+    media: parts[0]?.toLowerCase() || "",
+    event: parts[1]?.toLowerCase() || "",
+    target: parts[2] || null
+  };
+}
+__name(parseTag, "parseTag");
+function adaptEventName(tags) {
+  for (let i = 0; i < tags.length; i++) {
+    if (!tags[i]) {
+      continue;
+    }
+    for (const [oldEvent, newEvent] of Object.entries(TrackTagsVersionMap)) {
+      if (tags[i]?.includes(oldEvent)) {
+        tags[i] = tags[i]?.replace(oldEvent, newEvent) ?? "";
+        break;
+      }
+    }
+  }
+}
+__name(adaptEventName, "adaptEventName");
+function handleTagTracking(parsedTag, eventData) {
+  const { media, event, target } = parsedTag;
+  if (!target) {
+    logger.warn(`Tag missing target: ${media}:${event}`);
+    return;
+  }
+  try {
+    switch (media) {
+      case "fbq":
+      case "meta": {
+        const config = {
+          platform: "meta",
+          event: target,
+          // target 作为事件名
+          data: eventData
+        };
+        track(config);
+        break;
+      }
+      case "gtag": {
+        const config = {
+          platform: "gtag",
+          eventName: "conversion",
+          send_to: target,
+          // target 作为转化目标ID
+          value: eventData?.value ?? 1,
+          currency: eventData?.currency,
+          transactionId: eventData?.transactionId
+        };
+        track(config);
+        break;
+      }
+      default:
+        logger.warn(`Unsupported media platform: ${media}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to track tag ${media}:${event}:${target}:`, error);
+  }
+}
+__name(handleTagTracking, "handleTagTracking");
+function trackByTags({ tags, data }) {
+  if (!tags || tags.length === 0) {
+    logger.warn("trackByTags: tags array is empty");
+    return;
+  }
+  const adaptedTags = [...tags];
+  adaptEventName(adaptedTags);
+  const firstData = data && data.length > 0 ? data[0] : void 0;
+  const { event, ...trackingData } = firstData || {};
+  adaptedTags.forEach((tag) => {
+    const parsed = parseTag(tag);
+    if (!parsed) {
+      logger.warn(`trackByTags: Invalid tag format: ${tag}`);
+      return;
+    }
+    handleTagTracking(parsed, trackingData);
+  });
+}
+__name(trackByTags, "trackByTags");
+
+// src/core/helpers/triggerTrack.ts
+function getTrackTagsFromStorage(storageKey) {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    logger.warn("sessionStorage is not available");
+    return null;
+  }
+  try {
+    const trackTagsRaw = sessionStorage.getItem(storageKey);
+    if (!trackTagsRaw) {
+      return null;
+    }
+    const trackTags = JSON.parse(trackTagsRaw);
+    if (!trackTags || typeof trackTags !== "object") {
+      logger.warn(
+        `Invalid trackTags format in sessionStorage key: ${storageKey}`
+      );
+      return null;
+    }
+    return trackTags;
+  } catch (error) {
+    logger.error(`Failed to parse trackTags from sessionStorage:`, error);
+    return null;
+  }
+}
+__name(getTrackTagsFromStorage, "getTrackTagsFromStorage");
+function triggerTrack(trackPoint, options = {}) {
+  const {
+    tags,
+    eventData = {},
+    storageKey = "trackTags",
+    silent = false
+  } = options;
+  if (!trackPoint || typeof trackPoint !== "string") {
+    if (!silent) {
+      logger.warn("triggerTrack: trackPoint is required and must be a string");
+    }
+    return;
+  }
+  const trackTagsRow = getTrackTagsFromStorage(storageKey);
+  if (!trackTagsRow) {
+    if (!silent) {
+      logger.warn(
+        `triggerTrack: trackTags not found in sessionStorage (key: ${storageKey})`
+      );
+    }
+    return;
+  }
+  const trackTags = tags || trackTagsRow[trackPoint];
+  if (!trackTags) {
+    if (!silent) {
+      logger.warn(`triggerTrack: No tags found for trackPoint: ${trackPoint}`);
+    }
+    return;
+  }
+  if (!Array.isArray(trackTags)) {
+    if (!silent) {
+      logger.warn(
+        `triggerTrack: Tags for trackPoint "${trackPoint}" is not an array`
+      );
+    }
+    return;
+  }
+  if (trackTags.length === 0) {
+    if (!silent) {
+      logger.log(
+        `triggerTrack: Tags array is empty for trackPoint: ${trackPoint}`
+      );
+    }
+    return;
+  }
+  try {
+    trackByTags({
+      tags: trackTags,
+      data: [{ event: "custom", ...eventData }]
+    });
+    logger.log(
+      `triggerTrack: Successfully triggered for trackPoint: ${trackPoint}`,
+      {
+        tagsCount: trackTags.length,
+        trackTags
+      }
+    );
+  } catch (error) {
+    logger.error(
+      `triggerTrack: Failed to track for trackPoint: ${trackPoint}`,
+      error
+    );
+  }
+}
+__name(triggerTrack, "triggerTrack");
+function triggerTrackBatch(trackPoints, options = {}) {
+  if (!Array.isArray(trackPoints)) {
+    logger.warn("triggerTrackBatch: trackPoints must be an array");
+    return;
+  }
+  trackPoints.forEach((trackPoint) => {
+    triggerTrack(trackPoint, options);
+  });
+}
+__name(triggerTrackBatch, "triggerTrackBatch");
+function setTrackTags(trackTags, storageKey = "trackTags") {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    logger.warn("sessionStorage is not available");
+    return;
+  }
+  try {
+    const trackTagsJson = JSON.stringify(trackTags);
+    sessionStorage.setItem(storageKey, trackTagsJson);
+    logger.log(
+      `setTrackTags: Successfully saved to sessionStorage (key: ${storageKey})`
+    );
+  } catch (error) {
+    logger.error("setTrackTags: Failed to save to sessionStorage", error);
+  }
+}
+__name(setTrackTags, "setTrackTags");
+function clearTrackTags(storageKey = "trackTags") {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return;
+  }
+  try {
+    sessionStorage.removeItem(storageKey);
+    logger.log(
+      `clearTrackTags: Successfully removed from sessionStorage (key: ${storageKey})`
+    );
+  } catch (error) {
+    logger.error("clearTrackTags: Failed to remove from sessionStorage", error);
+  }
+}
+__name(clearTrackTags, "clearTrackTags");
+function hasTrackPoint(trackPoint, storageKey = "trackTags") {
+  const trackTags = getTrackTagsFromStorage(storageKey);
+  if (!trackTags) {
+    return false;
+  }
+  const tags = trackTags[trackPoint];
+  return Array.isArray(tags) && tags.length > 0;
+}
+__name(hasTrackPoint, "hasTrackPoint");
+
+// src/core/adapters/gtag.ts
+var gtagTrack = /* @__PURE__ */ __name((command, targetOrEventName, params) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof window.gtag !== "function") {
+    console.warn("gtag is not available. Please load gtag.js first.");
+    return;
+  }
+  try {
+    window.gtag(command, targetOrEventName, params);
+  } catch (error) {
+    console.error("gtagTrack error:", error);
+  }
+}, "gtagTrack");
+var gtagEvent = /* @__PURE__ */ __name((eventName, eventParams) => {
+  gtagTrack("event", eventName, eventParams);
+}, "gtagEvent");
+var gtagConfig = /* @__PURE__ */ __name((measurementId, configParams) => {
+  gtagTrack("config", measurementId, configParams);
+}, "gtagConfig");
+
+// src/core/adapters/meta.ts
+var metaTrack = /* @__PURE__ */ __name((event, data) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof window.fbq !== "undefined") {
+    try {
+      if (data) {
+        window.fbq("track", event, data);
+      } else {
+        window.fbq("track", event);
+      }
+    } catch (error) {
+      console.log("fbqTrack error", error);
+    }
+  }
+}, "metaTrack");
+
+// src/core/tracking/dispatcher.ts
+function track(config) {
+  const { platform, ...params } = config;
+  if (!isPlatformAvailable(platform)) {
+    logger.warn(`Platform ${platform} is not available`);
+    return;
+  }
+  try {
+    switch (platform) {
+      case "gtag": {
+        const gtagParams = params;
+        handleGtagTrack(gtagParams);
+        break;
+      }
+      case "meta": {
+        const metaParams = params;
+        handleMetaTrack(metaParams);
+        break;
+      }
+      default:
+        logger.warn(`Unsupported platform: ${platform}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to track on platform ${platform}:`, error);
+  }
+}
+__name(track, "track");
+function handleGtagTrack(params) {
+  const { eventName, measurementId, ...restParams } = params;
+  if (measurementId) {
+    gtagConfig(measurementId, {});
+  }
+  const eventParams = { ...restParams };
+  if (eventParams.transactionId && !eventParams.transaction_id) {
+    eventParams.transaction_id = eventParams.transactionId;
+    delete eventParams.transactionId;
+  }
+  gtagEvent(eventName, eventParams);
+  logger.log(`Gtag conversion tracked: ${eventName}`, eventParams);
+}
+__name(handleGtagTrack, "handleGtagTrack");
+function handleMetaTrack(params) {
+  const { event, data } = params;
+  if (!event) {
+    logger.warn("Meta Pixel event name is required");
+    return;
+  }
+  metaTrack(event, data);
+  logger.log(`Meta Pixel event tracked: ${event}`, data);
+}
+__name(handleMetaTrack, "handleMetaTrack");
+
+// src/core/tracking/with-tracking.ts
+function executeTracking(trackPoint, trackConfig) {
+  const configs = Array.isArray(trackConfig) ? trackConfig : [trackConfig ?? {}];
+  configs.forEach((config) => {
+    try {
+      track(config);
+    } catch (error) {
+      logger.error("withTracking: \u57CB\u70B9\u6267\u884C\u5931\u8D25", error);
+    }
+  });
+  if (typeof window !== "undefined" && !!trackPoint && window.__FUN_TRACK_TAGS__?.[trackPoint ?? ""]?.length > 0) {
+    trackByTags({
+      tags: window.__FUN_TRACK_TAGS__?.[trackPoint ?? ""] ?? [],
+      data: [{ event: "custom" }]
+    });
+  }
+}
+__name(executeTracking, "executeTracking");
+function withTracking(fn, config) {
+  const {
+    trackConfig,
+    timing = "after",
+    condition,
+    trackOnError = false,
+    errorTrackConfig,
+    debounce: debounceTime,
+    throttle: throttleTime,
+    trackPoint
+  } = config;
+  function wrappedFunction(...args) {
+    if (condition && !condition(args)) {
+      return fn(...args);
+    }
+    const getTrackConfig = /* @__PURE__ */ __name((result) => {
+      return typeof trackConfig === "function" ? trackConfig(args, result) : trackConfig;
+    }, "getTrackConfig");
+    if (timing === "before" || timing === "both") {
+      const config2 = getTrackConfig();
+      executeTracking(trackPoint, config2);
+    }
+    try {
+      const result = fn(...args);
+      if (result instanceof Promise) {
+        return result.then((resolvedResult) => {
+          if (timing === "after" || timing === "both") {
+            const config2 = getTrackConfig(resolvedResult);
+            executeTracking(trackPoint, config2);
+          }
+          return resolvedResult;
+        }).catch((error) => {
+          if (trackOnError && errorTrackConfig) {
+            executeTracking(trackPoint, errorTrackConfig(error, args));
+          }
+          throw error;
+        });
+      }
+      if (timing === "after" || timing === "both") {
+        const config2 = getTrackConfig(result);
+        executeTracking(trackPoint, config2);
+      }
+      return result;
+    } catch (error) {
+      if (trackOnError && errorTrackConfig) {
+        executeTracking(trackPoint, errorTrackConfig(error, args));
+      }
+      throw error;
+    }
+  }
+  __name(wrappedFunction, "wrappedFunction");
+  if (typeof window !== "undefined" && !!trackPoint) {
+    const urlParams = new URLSearchParams(window.location.search);
+    if (urlParams.has("TRACK_DEV")) {
+      return ((...args) => {
+        window.open(
+          `http://localhost:3002/tracking?trackPoint=${trackPoint}`,
+          "_blank"
+        );
+      });
+    }
+  }
+  if (debounceTime) {
+    return debounce(wrappedFunction, debounceTime);
+  }
+  if (throttleTime) {
+    return throttle(wrappedFunction, throttleTime);
+  }
+  return wrappedFunction;
+}
+__name(withTracking, "withTracking");
+function useTracking(config) {
+  return (fn) => {
+    return withTracking(fn, config);
+  };
+}
+__name(useTracking, "useTracking");
+
+// src/pixels/GtagPixel.tsx
+var import_react = require("react");
+var import_script = __toESM(require("next/script"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var GtagPixel = /* @__PURE__ */ __name((props) => {
+  const {
+    cookieConsentEnabled,
+    pixelIds,
+    strategy,
+    onPixelLoaded,
+    ...scriptProps
+  } = props;
+  const pixelIdsKey = (0, import_react.useMemo)(() => JSON.stringify(pixelIds), [pixelIds]);
+  const pixelIdsArray = (0, import_react.useMemo)(
+    () => Array.isArray(pixelIds) ? pixelIds : [pixelIds],
+    [pixelIdsKey]
+  );
+  const onLoadRef = (0, import_react.useRef)(onPixelLoaded);
+  (0, import_react.useEffect)(() => {
+    onLoadRef.current = onPixelLoaded;
+  }, [onPixelLoaded]);
+  const initializeGtag = /* @__PURE__ */ __name((pixelId) => {
+    try {
+      window.dataLayer = window.dataLayer || [];
+      if (typeof window.gtag !== "function") {
+        window.gtag = /* @__PURE__ */ __name(function gtag() {
+          window.dataLayer.push(arguments);
+        }, "gtag");
+      }
+      window.gtag("js", /* @__PURE__ */ new Date());
+      window.gtag("config", pixelId, {
+        allow_enhanced_conversions: true
+      });
+      console.log(`\u2705 GtagPixel ${pixelId} initialized`);
+    } catch (error) {
+      console.error(`Failed to initialize GtagPixel ${pixelId}:`, error);
+    }
+  }, "initializeGtag");
+  (0, import_react.useEffect)(() => {
+    if (!cookieConsentEnabled || typeof window === "undefined") return;
+    if (typeof window.gtag !== "undefined" || typeof window.dataLayer !== "undefined") {
+      console.log("\u2705 Gtag already available");
+      pixelIdsArray.forEach((pixelId) => initializeGtag(pixelId));
+      onLoadRef.current?.();
+      return;
+    }
+    const checkScriptLoaded = setInterval(() => {
+      if (typeof window.gtag !== "undefined" || typeof window.dataLayer !== "undefined") {
+        console.log("\u2705 Gtag became available!");
+        clearInterval(checkScriptLoaded);
+        pixelIdsArray.forEach((pixelId) => initializeGtag(pixelId));
+        onLoadRef.current?.();
+      }
+    }, 100);
+    const timeout = setTimeout(() => {
+      clearInterval(checkScriptLoaded);
+      console.warn("\u26A0\uFE0F Timeout waiting for gtag");
+    }, 5e3);
+    return () => {
+      clearInterval(checkScriptLoaded);
+      clearTimeout(timeout);
+    };
+  }, [cookieConsentEnabled, pixelIdsArray]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: pixelIdsArray.length > 0 && pixelIdsArray.map((pixelId, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_script.default,
+    {
+      id: `GtagPixel_${pixelId}_${index}`,
+      type: cookieConsentEnabled ? "text/plain" : "text/javascript",
+      "data-category": "targeting",
+      strategy,
+      src: `https://www.googletagmanager.com/gtag/js?id=${pixelId}`,
+      onLoad: () => {
+        console.log(`\u2705 GtagPixel ${pixelId} loaded from network`);
+        initializeGtag(pixelId);
+      },
+      onError: () => {
+        console.error(`\u274C GtagPixel ${pixelId} script load error`);
+      },
+      ...scriptProps
+    },
+    pixelId
+  )) });
+}, "GtagPixel");
+var GtagPixel_default = GtagPixel;
+
+// src/pixels/MetaPixel.tsx
+var import_react2 = require("react");
+var import_script2 = __toESM(require("next/script"));
+var import_jsx_runtime2 = (
+  // 添加 cookieConsentEnabled 条件
+  require("react/jsx-runtime")
+);
+var MetaPixel = /* @__PURE__ */ __name((props) => {
+  const {
+    cookieConsentEnabled,
+    pixelIds,
+    strategy,
+    onPixelLoaded,
+    ...scriptProps
+  } = props;
+  const pixelIdsKey = (0, import_react2.useMemo)(() => JSON.stringify(pixelIds), [pixelIds]);
+  const pixelIdsArray = (0, import_react2.useMemo)(
+    () => Array.isArray(pixelIds) ? pixelIds : [pixelIds],
+    [pixelIdsKey]
+  );
+  const onLoadRef = (0, import_react2.useRef)(onPixelLoaded);
+  (0, import_react2.useEffect)(() => {
+    onLoadRef.current = onPixelLoaded;
+  }, [onPixelLoaded]);
+  (0, import_react2.useEffect)(() => {
+    if (!cookieConsentEnabled || typeof window === "undefined") return;
+    if (typeof window.fbq !== "undefined") {
+      console.log("\u2705 window.fbq already available");
+      onLoadRef.current?.();
+      return;
+    }
+    const checkScriptLoaded = setInterval(() => {
+      if (typeof window.fbq !== "undefined") {
+        console.log("\u2705 window.fbq became available!");
+        clearInterval(checkScriptLoaded);
+        onLoadRef.current?.();
+      }
+    }, 100);
+    const timeout = setTimeout(() => {
+      clearInterval(checkScriptLoaded);
+      console.warn("\u26A0\uFE0F Timeout waiting for window.fbq");
+    }, 5e3);
+    return () => {
+      clearInterval(checkScriptLoaded);
+      clearTimeout(timeout);
+    };
+  }, [cookieConsentEnabled]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: pixelIdsArray?.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_script2.default,
+      {
+        id: "MetaPixel",
+        strategy,
+        type: cookieConsentEnabled ? "text/plain" : "text/javascript",
+        "data-category": "targeting",
+        src: `https://connect.facebook.net/en_US/fbevents.js`,
+        onLoad: () => {
+          console.log("\u2705 MetaPixel main script loaded from network");
+        },
+        onError: () => {
+          console.error("\u274C MetaPixel main script load error");
+        }
+      },
+      "MetaPixel"
+    ),
+    pixelIdsArray.map((pixelId, index) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_script2.default,
+      {
+        id: `MetaPixel_${pixelId}_${index}`,
+        strategy,
+        type: "text/javascript",
+        dangerouslySetInnerHTML: {
+          __html: `
+                !function(f,b,n)
+                {if(f.fbq)return;n=f.fbq=function(){n.callMethod?
+                n.callMethod.apply(n,arguments):n.queue.push(arguments)};
+                if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';
+                n.queue=[];}(window, document);
+                  fbq('init', '${pixelId}');
+                  fbq('track', 'PageView');
+              `
+        },
+        onError: () => {
+          console.error(`\u274C MetaPixel ${pixelId} script error`);
+        },
+        ...scriptProps
+      },
+      pixelId
+    ))
+  ] }) });
+}, "MetaPixel");
+var MetaPixel_default = MetaPixel;
+
+// src/pixels/PixelsManager.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var PIXEL_COMPONENTS = {
+  gtag: GtagPixel_default,
+  meta: MetaPixel_default
+};
+var PixelsManager = /* @__PURE__ */ __name((config) => {
+  const { type, ...pixelProps } = config;
+  const PixelComponent = PIXEL_COMPONENTS[type];
+  if (!PixelComponent) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(PixelComponent, { ...pixelProps });
+}, "PixelsManager");
+var PixelsManager_default = PixelsManager;
+
+// src/index.ts
+var index_default = {
+  track,
+  trackByTags,
+  withTracking,
+  useTracking,
+  logger,
+  isPlatformAvailable,
+  updateScriptType,
+  updateScriptsType
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GtagPixel,
+  MetaPixel,
+  PixelsManager,
+  TrackTagsVersionMap,
+  clearTrackTags,
+  gtagTrack,
+  hasTrackPoint,
+  isPlatformAvailable,
+  logger,
+  metaTrack,
+  setTrackTags,
+  track,
+  trackByTags,
+  triggerTrack,
+  triggerTrackBatch,
+  updateScriptType,
+  updateScriptsType,
+  useTracking,
+  withTracking
+});
+//# sourceMappingURL=index.cjs.map