@open-condo/miniapp-utils/dist/index.js

A set of helper functions / components / hooks used to build new condo apps fast

"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 __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, {
  Analytics: () => Analytics,
  FINGERPRINT_ID_COOKIE_NAME: () => FINGERPRINT_ID_COOKIE_NAME,
  FINGERPRINT_ID_LENGTH: () => FINGERPRINT_ID_LENGTH,
  SSRCookiesHelper: () => SSRCookiesHelper,
  generateFingerprint: () => generateFingerprint,
  generateUUIDv4: () => generateUUIDv4,
  getClientSideFingerprint: () => getClientSideFingerprint,
  getClientSideSenderInfo: () => getClientSideSenderInfo,
  getPosthogEndpoint: () => getPosthogEndpoint,
  getTracingMiddleware: () => getTracingMiddleware,
  isDebug: () => isDebug,
  isSSR: () => isSSR,
  nonNull: () => nonNull,
  prepareSSRContext: () => prepareSSRContext,
  useEffectOnce: () => useEffectOnce,
  useIntersectionObserver: () => useIntersectionObserver,
  usePrevious: () => usePrevious,
  useSetPageActionsHandlers: () => useSetPageActionsHandlers
});
module.exports = __toCommonJS(index_exports);

// src/helpers/analytics/instance.ts
var import_analytics = require("analytics");

// src/helpers/analytics/middlewares/grouping.ts
function _addGroupingProperties(data) {
  const { instance } = data;
  for (const groupName of instance.groups) {
    const groupKey = Analytics.getGroupKey(groupName);
    const groupValue = instance.storage.getItem(groupKey);
    if (typeof groupValue === "string") {
      const groupAttrName = `groups.${groupName}`;
      data.payload.properties[groupAttrName] = groupValue;
    }
  }
  return data;
}
var GroupingMiddlewarePlugin = {
  name: "analytics-plugin-grouping",
  track: _addGroupingProperties,
  page: _addGroupingProperties
};

// src/helpers/analytics/middlewares/identity.ts
var IDENTITY_PROPERTIES = ["app", "version"];
function _addIdentityProperties(data) {
  const { instance } = data;
  for (const contextPropertyName of IDENTITY_PROPERTIES) {
    const propertyValue = instance.getState(`context.${contextPropertyName}`);
    if (typeof propertyValue === "string") {
      data.payload.properties[contextPropertyName] = propertyValue;
    }
  }
  return data;
}
var IdentityMiddlewarePlugin = {
  name: "analytics-plugin-identity",
  track: _addIdentityProperties,
  page: _addIdentityProperties
};

// src/helpers/analytics/instance.ts
var Analytics = class _Analytics {
  constructor(config) {
    this._groups = /* @__PURE__ */ new Set();
    this._analytics = (0, import_analytics.Analytics)({
      ...config,
      plugins: [
        IdentityMiddlewarePlugin,
        GroupingMiddlewarePlugin,
        ...config.plugins || []
      ]
    });
    this._analytics.groups = this._groups;
  }
  /**
   * Tracks type-safe business events. Recommended to use in most cases in app's codebase.
   * To add an event, modify "Events" generic.
   */
  async track(eventName, eventData) {
    await this._analytics.track(eventName, eventData);
  }
  /**
   * Tracks untyped analytics events, used mainly for external sources (bridge / ui-kit / messages, etc.)
   * @deprecated It's not recommended to use this in your business logic, consider using typed "track" instead
   */
  async trackUntyped(eventName, eventData) {
    await this._analytics.track(eventName, eventData);
  }
  /**
   * Tracks page changing in SPAs
   */
  async pageView(data) {
    await this._analytics.page(data);
  }
  /**
   * Identifies user in analytics provider.
   * To specify all possible shape of user's data, modify "UserData" generic
   *
   * NOTE: Analytics plugins don't have a fixed behavior on how to handle consecutive identify calls.
   * Some of them affect only subsequent events, others affect all user events.
   * Therefore, it is not recommended to put cohort-specific data (organization, address, language, etc.) here.
   * Instead, use something like "group" method if your plugins supports it.
   */
  async identify(userId, userData) {
    await this._analytics.identify(userId, userData);
  }
  /**
   * Resets analytics providers
   */
  async reset() {
    for (const groupName of this._groups) {
      const groupKey = _Analytics.getGroupKey(groupName);
      this._analytics.storage.removeItem(groupKey);
    }
    this._groups.clear();
    await this._analytics.reset();
  }
  static getGroupKey(groupName) {
    return ["analytics", "groups", groupName].join(":");
  }
  /**
   * Associates the user with a group, adding the attributes `groups.${groupName} = groupId`
   * to all subsequent analytic queries for the user
   * @example
   * analytics.setGroup('organization', organizationId)
   */
  setGroup(groupName, groupId) {
    const groupKey = _Analytics.getGroupKey(groupName);
    this._groups.add(groupName);
    this._analytics.storage.setItem(groupKey, groupId);
  }
  /**
   * Removes the current user from the group, stripping the “groups.${groupName}”
   * attribute from all subsequent eventualities
   * @example
   * deleteOrganization()
   *     .then(() => analytics.removeGroup('organization'))
   */
  removeGroup(groupName) {
    const groupKey = _Analytics.getGroupKey(groupName);
    this._analytics.storage.removeItem(groupKey);
    this._groups.delete(groupName);
  }
};

// src/helpers/apollo.ts
var import_cookie2 = require("cookie");
var import_cookies_next3 = require("cookies-next");

// src/helpers/proxying/utils.ts
var import_jsonwebtoken = __toESM(require("jsonwebtoken"));
var import_proxy_addr = __toESM(require("proxy-addr"));
var import_zod = require("zod");

// src/helpers/ip/utils.ts
var v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
var v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
var IPv4Reg = new RegExp(`^${v4Str}$`);
var v6Seg = "(?:[0-9a-fA-F]{1,4})";
var IPv6Reg = new RegExp(
  `^((?:${v6Seg}:){7}(?:${v6Seg}|:)|(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:)))(%[0-9a-zA-Z]{1,})?$`
);
function isIPv4(s) {
  return IPv4Reg.test(s);
}
function isIPv6(s) {
  return IPv6Reg.test(s);
}
function isIP(s) {
  if (isIPv4(s)) return 4;
  if (isIPv6(s)) return 6;
  return 0;
}

// src/helpers/ip/ipv4.ts
function ipv4ToLong(ip) {
  if (!isIPv4(ip)) {
    throw new Error(`not a valid IPv4 address: ${ip}`);
  }
  const octets = ip.split(".");
  return (parseInt(octets[0], 10) << 24) + (parseInt(octets[1], 10) << 16) + (parseInt(octets[2], 10) << 8) + parseInt(octets[3], 10) >>> 0;
}
function createLongChecker(subnet) {
  const [subnetAddress, prefixLengthString] = subnet.split("/");
  const prefixLength = parseInt(prefixLengthString, 10);
  if (!subnetAddress || !Number.isInteger(prefixLength)) {
    throw new Error(`not a valid IPv4 subnet: ${subnet}`);
  }
  if (prefixLength < 0 || prefixLength > 32) {
    throw new Error(`not a valid IPv4 prefix length: ${prefixLength} (from ${subnet})`);
  }
  const subnetLong = ipv4ToLong(subnetAddress);
  return (addressLong) => {
    if (prefixLength === 0) {
      return true;
    }
    const subnetPrefix = subnetLong >> 32 - prefixLength;
    const addressPrefix = addressLong >> 32 - prefixLength;
    return subnetPrefix === addressPrefix;
  };
}
function createChecker(subnetOrSubnets) {
  if (Array.isArray(subnetOrSubnets)) {
    const checks = subnetOrSubnets.map((subnet) => createLongChecker(subnet));
    return (address) => {
      const addressLong = ipv4ToLong(address);
      return checks.some((check2) => check2(addressLong));
    };
  }
  const check = createLongChecker(subnetOrSubnets);
  return (address) => {
    const addressLong = ipv4ToLong(address);
    return check(addressLong);
  };
}

// src/helpers/ip/ipv6.ts
var dot = /\./;
var mappedIpv4 = /^(.+:ffff:)(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(?:%.+)?$/;
var colon = /:/;
var doubleColon = /::/;
function mappedIpv4ToIpv6(ip) {
  const matches = ip.match(mappedIpv4);
  if (!matches || !isIPv4(matches[2])) {
    throw new Error(`not a mapped IPv4 address: ${ip}`);
  }
  const prefix = matches[1];
  const ipv4 = matches[2];
  const parts = ipv4.split(dot).map((x) => parseInt(x, 10));
  const segment7 = ((parts[0] << 8) + parts[1]).toString(16);
  const segment8 = ((parts[2] << 8) + parts[3]).toString(16);
  return `${prefix}${segment7}:${segment8}`;
}
function extractMappedIpv4(ip) {
  const matches = ip.match(mappedIpv4);
  if (!matches || !isIPv4(matches[2])) {
    throw new Error(`not a mapped IPv4 address: ${ip}`);
  }
  return matches[2];
}
function getIpv6Segments(ip) {
  if (!isIPv6(ip)) {
    throw new Error(`not a valid IPv6 address: ${ip}`);
  }
  if (dot.test(ip)) {
    return getIpv6Segments(mappedIpv4ToIpv6(ip));
  }
  const [beforeChunk, afterChunk] = ip.split(doubleColon);
  const beforeParts = beforeChunk && beforeChunk.split(colon) || [];
  const afterParts = afterChunk && afterChunk.split(colon) || [];
  const missingSegments = new Array(8 - (beforeParts.length + afterParts.length));
  return beforeParts.concat(missingSegments, afterParts);
}
function createChecker2(subnetOrSubnets) {
  if (Array.isArray(subnetOrSubnets)) {
    const checks = subnetOrSubnets.map((subnet) => createSegmentChecker(subnet));
    return (address) => {
      const segments = getIpv6Segments(address);
      return checks.some((check2) => check2(segments));
    };
  }
  const check = createSegmentChecker(subnetOrSubnets);
  return (address) => {
    const segments = getIpv6Segments(address);
    return check(segments);
  };
}
function createSegmentChecker(subnet) {
  const [subnetAddress, prefixLengthString] = subnet.split("/");
  const prefixLength = parseInt(prefixLengthString, 10);
  if (!subnetAddress || !Number.isInteger(prefixLength)) {
    throw new Error(`not a valid IPv6 CIDR subnet: ${subnet}`);
  }
  if (prefixLength < 0 || prefixLength > 128) {
    throw new Error(`not a valid IPv6 prefix length: ${prefixLength} (from ${subnet})`);
  }
  const subnetSegments = getIpv6Segments(subnetAddress);
  return (addressSegments) => {
    for (let i = 0; i < 8; ++i) {
      const bitCount = Math.min(prefixLength - i * 16, 16);
      if (bitCount <= 0) {
        break;
      }
      const subnetPrefix = (subnetSegments[i] && parseInt(subnetSegments[i], 16) || 0) >> 16 - bitCount;
      const addressPrefix = (addressSegments[i] && parseInt(addressSegments[i], 16) || 0) >> 16 - bitCount;
      if (subnetPrefix !== addressPrefix) {
        return false;
      }
    }
    return true;
  };
}
var specialNetsCache = {};
function isIPv4MappedAddress(address) {
  if (!("mapped" in specialNetsCache)) {
    specialNetsCache["mapped"] = createChecker2("::ffff:0:0/96");
  }
  if (specialNetsCache["mapped"](address)) {
    const matches = address.match(mappedIpv4);
    return Boolean(matches && isIPv4(matches[2]));
  }
  return false;
}

// src/helpers/ip/index.ts
function isInSubnet(address, subnetOrSubnets) {
  return createChecker3(subnetOrSubnets)(address);
}
function createChecker3(subnetOrSubnets) {
  if (!Array.isArray(subnetOrSubnets)) {
    return createChecker3([subnetOrSubnets]);
  }
  const subnetsByVersion = subnetOrSubnets.reduce(
    (acc, subnet) => {
      const ip = subnet.split("/")[0];
      acc[isIP(ip)].push(subnet);
      return acc;
    },
    { 0: [], 4: [], 6: [] }
  );
  if (subnetsByVersion[0].length !== 0) {
    throw new Error(`some subnets are not valid IP addresses: ${subnetsByVersion[0]}`);
  }
  const check4 = createChecker(subnetsByVersion[4]);
  const check6 = createChecker2(subnetsByVersion[6]);
  return (address) => {
    if (!isIP(address)) {
      throw new Error(`not a valid IPv4 or IPv6 address: ${address}`);
    }
    if (isIPv6(address) && isIPv4MappedAddress(address)) {
      return check6(address) || check4(extractMappedIpv4(address));
    }
    if (isIPv6(address)) {
      return check6(address);
    } else {
      return check4(address);
    }
  };
}

// src/helpers/proxying/utils.ts
var _ipSchema = import_zod.z.union([import_zod.z.ipv4(), import_zod.z.ipv6()]);
var _timeStampBasicRegexp = /^\d+$/;
var DEFAULT_PROXY_TIMEOUT_IN_MS = 5e3;
var X_PROXY_ID_HEADER = "x-proxy-id";
var X_PROXY_IP_HEADER = "x-proxy-ip";
var X_PROXY_TIMESTAMP_HEADER = "x-proxy-timestamp";
var X_PROXY_SIGNATURE_HEADER = "x-proxy-signature";
function _getTimestampFromHeader(timestamp) {
  if (!_timeStampBasicRegexp.test(timestamp)) return Number.NaN;
  return new Date(parseInt(timestamp)).getTime();
}
function _isProxyIP(ip, proxyConfig) {
  const addresses = Array.isArray(proxyConfig.address) ? proxyConfig.address : [proxyConfig.address];
  const config = addresses.reduce((acc, addr) => {
    const isSubnet = addr.split("/").length > 1;
    if (isSubnet) {
      acc.subnets.push(addr);
    } else {
      acc.ips.push(addr);
    }
    return acc;
  }, { ips: [], subnets: [] });
  if (config.ips.length && config.ips.includes(ip)) {
    return true;
  }
  return !!(config.subnets.length && isInSubnet(ip, config.subnets));
}
function getRequestIp(req, trustProxyFn, knownProxies) {
  const originalIP = (0, import_proxy_addr.default)(req, trustProxyFn);
  if (!knownProxies) return originalIP;
  const xProxyId = req.headers[X_PROXY_ID_HEADER];
  const xProxyIp = req.headers[X_PROXY_IP_HEADER];
  const xProxyTimestamp = req.headers[X_PROXY_TIMESTAMP_HEADER];
  const xProxySignature = req.headers[X_PROXY_SIGNATURE_HEADER];
  if (typeof xProxyId !== "string" || typeof xProxyIp !== "string" || typeof xProxyTimestamp !== "string" || typeof xProxySignature !== "string") {
    return originalIP;
  }
  const { success: isValidIp } = _ipSchema.safeParse(xProxyIp);
  if (!isValidIp) {
    return originalIP;
  }
  const timestamp = _getTimestampFromHeader(xProxyTimestamp);
  const now = Date.now();
  if (Number.isNaN(timestamp) || timestamp > now || now - timestamp > DEFAULT_PROXY_TIMEOUT_IN_MS) {
    return originalIP;
  }
  if (!Object.hasOwn(knownProxies, xProxyId)) {
    return originalIP;
  }
  const proxyConfig = knownProxies[xProxyId];
  if (!proxyConfig || !_isProxyIP(originalIP, proxyConfig)) {
    return originalIP;
  }
  try {
    const jwtPayload = import_jsonwebtoken.default.verify(xProxySignature, proxyConfig.secret, { algorithms: ["HS256"] });
    const expectedPayloadSchema = import_zod.z.object({
      [X_PROXY_TIMESTAMP_HEADER]: import_zod.z.literal(xProxyTimestamp),
      [X_PROXY_IP_HEADER]: import_zod.z.literal(xProxyIp),
      [X_PROXY_ID_HEADER]: import_zod.z.literal(xProxyId),
      method: import_zod.z.literal(req.method),
      url: import_zod.z.literal(req.url)
    });
    const { success: isMatchingSignature } = expectedPayloadSchema.safeParse(jwtPayload);
    return isMatchingSignature ? xProxyIp : originalIP;
  } catch {
    return originalIP;
  }
}

// src/helpers/proxying/proxy.ts
var import_http_proxy = __toESM(require("http-proxy"));

// src/helpers/sender.ts
var import_cookies_next2 = require("cookies-next");

// src/helpers/embeddingContext.tsx
var import_cookies_next = require("cookies-next");
var import_react = __toESM(require("react"));
var import_zod2 = require("zod");

// src/helpers/uuid.ts
var import_crypto = require("crypto");
function generateUUIDv4() {
  let randomValues;
  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
    return crypto.randomUUID();
  } else if (typeof window !== "undefined" && window.crypto && window.crypto.getRandomValues) {
    randomValues = new Uint8Array(16);
    window.crypto.getRandomValues(randomValues);
  } else {
    randomValues = (0, import_crypto.randomBytes)(16);
  }
  randomValues[6] = randomValues[6] & 15 | 64;
  randomValues[8] = randomValues[8] & 63 | 128;
  return [...randomValues].map((value, index) => {
    const hex = value.toString(16).padStart(2, "0");
    if (index === 4 || index === 6 || index === 8 || index === 10) {
      return `-${hex}`;
    }
    return hex;
  }).join("");
}

// src/helpers/embeddingContext.tsx
var EMBEDDING_CONTEXT_COOKIE_NAME = "embeddingContext";
var EMBEDDING_CONTEXT_QUERY_PARAM = "embeddingContext";
var EMBEDDING_CONTEXT_SCHEMA = import_zod2.z.strictObject({
  dv: import_zod2.z.literal(1),
  app: import_zod2.z.strictObject({
    id: import_zod2.z.string(),
    version: import_zod2.z.string().optional(),
    build: import_zod2.z.string().optional()
  }),
  platform: import_zod2.z.enum(["iOS", "Android", "web"]),
  os: import_zod2.z.strictObject({
    name: import_zod2.z.string(),
    version: import_zod2.z.string().optional()
  }).optional(),
  device: import_zod2.z.strictObject({
    id: import_zod2.z.string()
  })
});
var EMBEDDING_CONTEXT_WITH_SOURCE_SCHEMA = import_zod2.z.strictObject({
  ctx: EMBEDDING_CONTEXT_SCHEMA,
  source: import_zod2.z.enum(["query", "cookie"])
});
var IS_PRIMARY_ALIVE_MESSAGE_SCHEMA = import_zod2.z.object({
  type: import_zod2.z.literal("EmbeddingContextPrimaryPolling"),
  data: import_zod2.z.strictObject({
    requestId: import_zod2.z.string()
  })
});
var IS_PRIMARY_ALIVE_RESPONSE_SCHEMA = import_zod2.z.object({
  type: import_zod2.z.literal("EmbeddingContextPrimaryPollingResult"),
  data: import_zod2.z.strictObject({
    requestId: import_zod2.z.string(),
    isPrimary: import_zod2.z.boolean()
  })
});
var ReactEmbeddingContext = (0, import_react.createContext)(null);
function b64toContext(b64) {
  try {
    const bytes = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
    const decodedUTFString = new TextDecoder().decode(bytes);
    const parsedCtx = JSON.parse(decodedUTFString);
    return EMBEDDING_CONTEXT_SCHEMA.parse(parsedCtx);
  } catch {
    return null;
  }
}
function getEmbeddingContext(req, res) {
  try {
    const queryParamValue = req ? new URL(req.url ?? "/", "https://_").searchParams.get(EMBEDDING_CONTEXT_QUERY_PARAM) : new URLSearchParams(window.location.search).get(EMBEDDING_CONTEXT_QUERY_PARAM);
    if (queryParamValue) {
      const ctx = b64toContext(decodeURIComponent(queryParamValue));
      if (ctx) return { ctx, source: "query" };
    }
  } catch {
  }
  const cookieValue = (0, import_cookies_next.getCookie)(EMBEDDING_CONTEXT_COOKIE_NAME, { req, res });
  if (cookieValue) {
    const ctx = b64toContext(cookieValue);
    if (ctx) return { ctx, source: "cookie" };
  }
  return null;
}

// src/helpers/sender.ts
var FINGERPRINT_ID_COOKIE_NAME = "fingerprint";
var FINGERPRINT_ID_LENGTH = 32;
var VERY_LONG_MAX_AGE_IN_SECONDS = Math.pow(2, 31) - 1;
function makeId(length) {
  const croppedLength = Math.min(length, 32);
  return generateUUIDv4().replaceAll("-", "").substring(0, croppedLength);
}
function generateFingerprint() {
  return makeId(FINGERPRINT_ID_LENGTH);
}
function getClientSideFingerprint() {
  const embeddingContext = getEmbeddingContext();
  if (embeddingContext) {
    return embeddingContext.ctx.device.id;
  }
  let fingerprint = (0, import_cookies_next2.getCookie)(FINGERPRINT_ID_COOKIE_NAME);
  if (!fingerprint) {
    fingerprint = generateFingerprint();
  }
  (0, import_cookies_next2.setCookie)(FINGERPRINT_ID_COOKIE_NAME, fingerprint, {
    maxAge: VERY_LONG_MAX_AGE_IN_SECONDS
    // no "maxAge" or "expires" means that cookie clears when session ends (f.e. when browser closes)
  });
  return fingerprint;
}
function getClientSideSenderInfo() {
  return {
    dv: 1,
    fingerprint: getClientSideFingerprint()
  };
}

// src/helpers/tracing.ts
var import_cookie = require("cookie");
var SSR_DEFAULT_FINGERPRINT = "webAppSSR";
var COOKIE_HEADER_NAME = "cookie";
var REMOTE_APP_HEADER_NAME = "x-remote-app";
var REMOTE_VERSION_HEADER_NAME = "x-remote-version";
var REMOTE_CLIENT_HEADER_NAME = "x-remote-client";
var REMOTE_ENV_HEADER_NAME = "x-remote-env";
var TARGET_HEADER_NAME = "x-target";
var START_REQUEST_ID_HEADER_NAME = "x-start-request-id";
var PARENT_REQUEST_ID_HEADER_NAME = "x-parent-request-id";
function generateRequestId() {
  return `BR${generateUUIDv4().replaceAll("-", "")}`;
}
function getAppTracingHeaders(options) {
  const reqId = generateRequestId();
  const headers = {
    ...options.previousHeaders,
    [REMOTE_APP_HEADER_NAME]: options.serviceUrl,
    [REMOTE_VERSION_HEADER_NAME]: options.codeVersion,
    [PARENT_REQUEST_ID_HEADER_NAME]: reqId,
    [START_REQUEST_ID_HEADER_NAME]: reqId
  };
  if (options.target) {
    headers[TARGET_HEADER_NAME] = options.target;
  }
  headers[REMOTE_ENV_HEADER_NAME] = typeof document === "undefined" ? "SSR" : "CSR";
  if (typeof document !== "undefined" && document.cookie) {
    headers[REMOTE_CLIENT_HEADER_NAME] = getClientSideFingerprint();
  } else if (headers[COOKIE_HEADER_NAME]) {
    const ssrCookies = (0, import_cookie.parse)(headers[COOKIE_HEADER_NAME]);
    headers[REMOTE_CLIENT_HEADER_NAME] = ssrCookies[FINGERPRINT_ID_COOKIE_NAME] || SSR_DEFAULT_FINGERPRINT;
  }
  return headers;
}

// src/helpers/apollo.ts
function getTracingMiddleware(options) {
  return function(operation, forward) {
    operation.setContext((previousContext) => {
      const { headers: previousHeaders } = previousContext;
      return {
        ...previousContext,
        headers: getAppTracingHeaders({
          ...options,
          previousHeaders
        })
      };
    });
    return forward(operation);
  };
}
function prepareSSRContext(req, res) {
  if (!req) {
    return {
      headers: {},
      defaultContext: {}
    };
  }
  const requestCookies = (0, import_cookies_next3.getCookies)({ req, res });
  if (!requestCookies[FINGERPRINT_ID_COOKIE_NAME]) {
    const fingerprint = generateFingerprint();
    requestCookies[FINGERPRINT_ID_COOKIE_NAME] = fingerprint;
    (0, import_cookies_next3.setCookie)(FINGERPRINT_ID_COOKIE_NAME, fingerprint, { req, res });
  }
  const cookieHeader = Object.entries(requestCookies).map(([name, value]) => value ? (0, import_cookie2.serialize)(name, value) : null).filter(Boolean).join(";");
  const clientIp = getRequestIp(req, () => true);
  const headers = {
    "cookie": cookieHeader
  };
  if (req.headers["accept-language"]) {
    headers["accept-language"] = req.headers["accept-language"];
  }
  return {
    headers,
    defaultContext: {
      clientIp
    }
  };
}

// src/helpers/collections.ts
function nonNull(val) {
  return val !== null && val !== void 0;
}

// src/helpers/cookies.ts
var import_cookies_next4 = require("cookies-next");
var import_react2 = require("react");
var SSR_COOKIES_DEFAULT_PROP_NAME = "__SSR_COOKIES__";
var SSRCookiesHelper = class {
  constructor(allowedCookies, propName) {
    this.allowedCookies = allowedCookies;
    this.propName = propName || SSR_COOKIES_DEFAULT_PROP_NAME;
    this.defaultValues = Object.fromEntries(allowedCookies.map((key) => [key, null]));
    this.context = (0, import_react2.createContext)(this.defaultValues);
    this.extractSSRCookies = this.extractSSRCookies.bind(this);
  }
  getContext() {
    return this.context;
  }
  generateUseSSRCookiesExtractorHook() {
    const defaultValues = this.defaultValues;
    const propName = this.propName;
    return function useSSRCookiesExtractor(pageProps) {
      return pageProps[propName] || defaultValues;
    };
  }
  generateUseSSRCookiesHook() {
    const context = this.context;
    return function useSSRCookies() {
      return (0, import_react2.useContext)(context);
    };
  }
  extractSSRCookies(req, res, pageParams) {
    return {
      ...pageParams,
      props: {
        ...pageParams.props,
        [this.propName]: Object.fromEntries(
          Object.keys(this.defaultValues).map((key) => [
            key,
            (0, import_cookies_next4.getCookie)(key, { req, res }) || null
          ])
        )
      }
    };
  }
};

// src/helpers/environment.ts
function isSSR() {
  return typeof window === "undefined";
}
function isDebug() {
  return process.env.NODE_ENV === "development";
}

// src/helpers/posthog.ts
var POSTHOG_CLOUD_HOST_BASE = "i.posthog.com";
var POSTHOG_CLOUD_HOST_MATCHER = new RegExp(`^(\\w+)\\.${POSTHOG_CLOUD_HOST_BASE.replaceAll(".", "\\.")}$`);
function getPosthogEndpoint(posthogDomain, requestedPath) {
  const posthogURL = new URL(posthogDomain);
  const cloudMatch = posthogURL.host.match(POSTHOG_CLOUD_HOST_MATCHER);
  if (cloudMatch && cloudMatch.length > 1) {
    const region = cloudMatch[1];
    if (requestedPath.length && requestedPath[0] === "static") {
      posthogURL.host = `${region}-assets.${POSTHOG_CLOUD_HOST_BASE}`;
      posthogURL.pathname = requestedPath.slice(1).join("/");
      return posthogURL.toString();
    }
  }
  posthogURL.pathname = requestedPath.join("/");
  return posthogURL.toString();
}

// src/hooks/useSetPageActionsHandlers.ts
var import_react3 = require("react");
function useSetPageActionsHandlers(bridge, handlers) {
  const handlersRef = (0, import_react3.useRef)(handlers);
  (0, import_react3.useEffect)(() => {
    handlersRef.current = handlers;
  }, [handlers]);
  (0, import_react3.useEffect)(() => {
    const listener = (event) => {
      if (event.type !== "CondoWebAppActionClickEvent") return;
      if ("actionId" in event.data && typeof event.data.actionId === "string") {
        const { actionId } = event.data;
        const handler = handlersRef.current[actionId];
        handler == null ? void 0 : handler(actionId);
      }
    };
    bridge.subscribe(listener);
    return () => {
      bridge.unsubscribe(listener);
    };
  }, [bridge]);
}

// src/hooks/useEffectOnce.ts
var import_react4 = require("react");
function useEffectOnce(cb) {
  (0, import_react4.useEffect)(cb, []);
}

// src/hooks/useIntersectionObserver.ts
var import_react5 = require("react");
function useIntersectionObserver({
  threshold = 0,
  root = null,
  rootMargin = "0%",
  onChange
} = {}) {
  const [ref, setRef] = (0, import_react5.useState)(null);
  const [state, setState] = (0, import_react5.useState)(() => ({
    isIntersecting: false,
    entry: void 0
  }));
  const callbackRef = (0, import_react5.useRef)();
  callbackRef.current = onChange;
  (0, import_react5.useEffect)(() => {
    if (!ref) return;
    if (!("IntersectionObserver" in window)) return;
    const observer = new IntersectionObserver((entries) => {
      const thresholds = observer.thresholds;
      entries.forEach((entry) => {
        const isIntersecting = entry.isIntersecting && thresholds.some((threshold2) => entry.intersectionRatio >= threshold2);
        setState({ isIntersecting, entry });
        if (callbackRef.current) {
          callbackRef.current(isIntersecting, entry);
        }
      });
    }, { threshold, root, rootMargin });
    observer.observe(ref);
    return () => {
      observer.disconnect();
    };
  }, [ref, root, rootMargin, threshold]);
  const prevRef = (0, import_react5.useRef)(null);
  (0, import_react5.useEffect)(() => {
    var _a;
    if (!ref && ((_a = state.entry) == null ? void 0 : _a.target) && prevRef.current !== state.entry.target) {
      prevRef.current = state.entry.target;
      setState({ isIntersecting: false, entry: void 0 });
    }
  }, [ref, state.entry]);
  return {
    entry: state.entry,
    ref: setRef,
    isIntersecting: state.isIntersecting
  };
}

// src/hooks/usePrevious.ts
var import_react6 = require("react");
function usePrevious(state) {
  const ref = (0, import_react6.useRef)();
  (0, import_react6.useEffect)(() => {
    ref.current = state;
  });
  return ref.current;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Analytics,
  FINGERPRINT_ID_COOKIE_NAME,
  FINGERPRINT_ID_LENGTH,
  SSRCookiesHelper,
  generateFingerprint,
  generateUUIDv4,
  getClientSideFingerprint,
  getClientSideSenderInfo,
  getPosthogEndpoint,
  getTracingMiddleware,
  isDebug,
  isSSR,
  nonNull,
  prepareSSRContext,
  useEffectOnce,
  useIntersectionObserver,
  usePrevious,
  useSetPageActionsHandlers
});
//# sourceMappingURL=index.js.map