@open-condo/miniapp-utils
Version:
A set of helper functions / components / hooks used to build new condo apps fast
784 lines (758 loc) • 26.2 kB
JavaScript
// src/helpers/analytics/instance.ts
import { Analytics as DefaultAnalytics } from "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 = DefaultAnalytics({
...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
import { serialize as serializeCookie } from "cookie";
import { setCookie as setCookie3, getCookies } from "cookies-next";
// src/helpers/proxying/utils.ts
import jwt from "jsonwebtoken";
import proxyAddr from "proxy-addr";
import { z } from "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 = z.union([z.ipv4(), 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 = proxyAddr(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 = jwt.verify(xProxySignature, proxyConfig.secret, { algorithms: ["HS256"] });
const expectedPayloadSchema = z.object({
[X_PROXY_TIMESTAMP_HEADER]: z.literal(xProxyTimestamp),
[X_PROXY_IP_HEADER]: z.literal(xProxyIp),
[X_PROXY_ID_HEADER]: z.literal(xProxyId),
method: z.literal(req.method),
url: z.literal(req.url)
});
const { success: isMatchingSignature } = expectedPayloadSchema.safeParse(jwtPayload);
return isMatchingSignature ? xProxyIp : originalIP;
} catch {
return originalIP;
}
}
// src/helpers/proxying/proxy.ts
import httpProxy from "http-proxy";
// src/helpers/sender.ts
import { getCookie as getCookie2, setCookie as setCookie2 } from "cookies-next";
// src/helpers/embeddingContext.tsx
import { deleteCookie, getCookie, setCookie } from "cookies-next";
import React, { useEffect, useMemo, useState, createContext, useContext } from "react";
import { z as z2 } from "zod";
// src/helpers/uuid.ts
import { randomBytes } from "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 = 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 = z2.strictObject({
dv: z2.literal(1),
app: z2.strictObject({
id: z2.string(),
version: z2.string().optional(),
build: z2.string().optional()
}),
platform: z2.enum(["iOS", "Android", "web"]),
os: z2.strictObject({
name: z2.string(),
version: z2.string().optional()
}).optional(),
device: z2.strictObject({
id: z2.string()
})
});
var EMBEDDING_CONTEXT_WITH_SOURCE_SCHEMA = z2.strictObject({
ctx: EMBEDDING_CONTEXT_SCHEMA,
source: z2.enum(["query", "cookie"])
});
var IS_PRIMARY_ALIVE_MESSAGE_SCHEMA = z2.object({
type: z2.literal("EmbeddingContextPrimaryPolling"),
data: z2.strictObject({
requestId: z2.string()
})
});
var IS_PRIMARY_ALIVE_RESPONSE_SCHEMA = z2.object({
type: z2.literal("EmbeddingContextPrimaryPollingResult"),
data: z2.strictObject({
requestId: z2.string(),
isPrimary: z2.boolean()
})
});
var ReactEmbeddingContext = 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 = 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 = getCookie2(FINGERPRINT_ID_COOKIE_NAME);
if (!fingerprint) {
fingerprint = generateFingerprint();
}
setCookie2(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
import { parse as parseCookieString } from "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 = parseCookieString(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 = getCookies({ req, res });
if (!requestCookies[FINGERPRINT_ID_COOKIE_NAME]) {
const fingerprint = generateFingerprint();
requestCookies[FINGERPRINT_ID_COOKIE_NAME] = fingerprint;
setCookie3(FINGERPRINT_ID_COOKIE_NAME, fingerprint, { req, res });
}
const cookieHeader = Object.entries(requestCookies).map(([name, value]) => value ? serializeCookie(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
import { getCookie as getCookie3 } from "cookies-next";
import { createContext as createContext2, useContext as useContext2 } from "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 = createContext2(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 useContext2(context);
};
}
extractSSRCookies(req, res, pageParams) {
return {
...pageParams,
props: {
...pageParams.props,
[this.propName]: Object.fromEntries(
Object.keys(this.defaultValues).map((key) => [
key,
getCookie3(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
import { useEffect as useEffect2, useRef } from "react";
function useSetPageActionsHandlers(bridge, handlers) {
const handlersRef = useRef(handlers);
useEffect2(() => {
handlersRef.current = handlers;
}, [handlers]);
useEffect2(() => {
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
import { useEffect as useEffect3 } from "react";
function useEffectOnce(cb) {
useEffect3(cb, []);
}
// src/hooks/useIntersectionObserver.ts
import { useEffect as useEffect4, useRef as useRef2, useState as useState2 } from "react";
function useIntersectionObserver({
threshold = 0,
root = null,
rootMargin = "0%",
onChange
} = {}) {
const [ref, setRef] = useState2(null);
const [state, setState] = useState2(() => ({
isIntersecting: false,
entry: void 0
}));
const callbackRef = useRef2();
callbackRef.current = onChange;
useEffect4(() => {
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 = useRef2(null);
useEffect4(() => {
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
import { useEffect as useEffect5, useRef as useRef3 } from "react";
function usePrevious(state) {
const ref = useRef3();
useEffect5(() => {
ref.current = state;
});
return ref.current;
}
export {
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.mjs.map