@posthog/core 1.1.0 → 1.2.0

package/src/error-tracking/utils.ts

@@ -0,0 +1,39 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+/** A simple Least Recently Used map */
+export class ReduceableCache<K, V> {
+  private readonly _cache: Map<K, V>
+
+  public constructor(private readonly _maxSize: number) {
+    this._cache = new Map<K, V>()
+  }
+
+  /** Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order */
+  public get(key: K): V | undefined {
+    const value = this._cache.get(key)
+    if (value === undefined) {
+      return undefined
+    }
+    // Remove and re-insert to update the order
+    this._cache.delete(key)
+    this._cache.set(key, value)
+    return value
+  }
+
+  /** Insert an entry and evict an older entry if we've reached maxSize */
+  public set(key: K, value: V): void {
+    this._cache.set(key, value)
+  }
+
+  /** Remove an entry and return the entry if it was in the cache */
+  public reduce(): void {
+    while (this._cache.size >= this._maxSize) {
+      const value = this._cache.keys().next().value
+      if (value) {
+        // keys() returns an iterator in insertion order so keys().next() gives us the oldest key
+        this._cache.delete(value)
+      }
+    }
+  }
+}

package/src/eventemitter.ts

@@ -0,0 +1,27 @@
+export class SimpleEventEmitter {
+  events: { [key: string]: ((...args: any[]) => void)[] } = {}
+
+  constructor() {
+    this.events = {}
+  }
+
+  on(event: string, listener: (...args: any[]) => void): () => void {
+    if (!this.events[event]) {
+      this.events[event] = []
+    }
+    this.events[event].push(listener)
+
+    return () => {
+      this.events[event] = this.events[event].filter((x) => x !== listener)
+    }
+  }
+
+  emit(event: string, payload: any): void {
+    for (const listener of this.events[event] || []) {
+      listener(payload)
+    }
+    for (const listener of this.events['*'] || []) {
+      listener(event, payload)
+    }
+  }
+}

package/src/featureFlagUtils.ts

@@ -0,0 +1,192 @@
+import {
+  FeatureFlagDetail,
+  FeatureFlagValue,
+  JsonType,
+  PostHogFlagsResponse,
+  PostHogV1FlagsResponse,
+  PostHogV2FlagsResponse,
+  PostHogFlagsAndPayloadsResponse,
+  PartialWithRequired,
+  PostHogFeatureFlagsResponse,
+} from './types'
+
+export const normalizeFlagsResponse = (
+  flagsResponse:
+    | PartialWithRequired<PostHogV2FlagsResponse, 'flags'>
+    | PartialWithRequired<PostHogV1FlagsResponse, 'featureFlags' | 'featureFlagPayloads'>
+): PostHogFeatureFlagsResponse => {
+  if ('flags' in flagsResponse) {
+    // Convert v2 format to v1 format
+    const featureFlags = getFlagValuesFromFlags(flagsResponse.flags)
+    const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags)
+
+    return {
+      ...flagsResponse,
+      featureFlags,
+      featureFlagPayloads,
+    }
+  } else {
+    // Convert v1 format to v2 format
+    const featureFlags = flagsResponse.featureFlags ?? {}
+    const featureFlagPayloads = Object.fromEntries(
+      Object.entries(flagsResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)])
+    )
+
+    const flags = Object.fromEntries(
+      Object.entries(featureFlags).map(([key, value]) => [
+        key,
+        getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key]),
+      ])
+    )
+
+    return {
+      ...flagsResponse,
+      featureFlags,
+      featureFlagPayloads,
+      flags,
+    }
+  }
+}
+
+function getFlagDetailFromFlagAndPayload(
+  key: string,
+  value: FeatureFlagValue,
+  payload: JsonType | undefined
+): FeatureFlagDetail {
+  return {
+    key: key,
+    enabled: typeof value === 'string' ? true : value,
+    variant: typeof value === 'string' ? value : undefined,
+    reason: undefined,
+    metadata: {
+      id: undefined,
+      version: undefined,
+      payload: payload ? JSON.stringify(payload) : undefined,
+      description: undefined,
+    },
+  }
+}
+
+/**
+ * Get the flag values from the flags v4 response.
+ * @param flags - The flags
+ * @returns The flag values
+ */
+export const getFlagValuesFromFlags = (flags: PostHogFlagsResponse['flags']): PostHogFlagsResponse['featureFlags'] => {
+  return Object.fromEntries(
+    Object.entries(flags ?? {})
+      .map(([key, detail]) => [key, getFeatureFlagValue(detail)])
+      .filter(([, value]): boolean => value !== undefined)
+  )
+}
+
+/**
+ * Get the payloads from the flags v4 response.
+ * @param flags - The flags
+ * @returns The payloads
+ */
+export const getPayloadsFromFlags = (
+  flags: PostHogFlagsResponse['flags']
+): PostHogFlagsResponse['featureFlagPayloads'] => {
+  const safeFlags = flags ?? {}
+  return Object.fromEntries(
+    Object.keys(safeFlags)
+      .filter((flag) => {
+        const details = safeFlags[flag]
+        return details.enabled && details.metadata && details.metadata.payload !== undefined
+      })
+      .map((flag) => {
+        const payload = safeFlags[flag].metadata?.payload as string
+        return [flag, payload ? parsePayload(payload) : undefined]
+      })
+  )
+}
+
+/**
+ * Get the flag details from the legacy v1 flags and payloads. As such, it will lack the reason, id, version, and description.
+ * @param flagsResponse - The flags response
+ * @returns The flag details
+ */
+export const getFlagDetailsFromFlagsAndPayloads = (
+  flagsResponse: PostHogFeatureFlagsResponse
+): PostHogFlagsResponse['flags'] => {
+  const flags = flagsResponse.featureFlags ?? {}
+  const payloads = flagsResponse.featureFlagPayloads ?? {}
+  return Object.fromEntries(
+    Object.entries(flags).map(([key, value]) => [
+      key,
+      {
+        key: key,
+        enabled: typeof value === 'string' ? true : value,
+        variant: typeof value === 'string' ? value : undefined,
+        reason: undefined,
+        metadata: {
+          id: undefined,
+          version: undefined,
+          payload: payloads?.[key] ? JSON.stringify(payloads[key]) : undefined,
+          description: undefined,
+        },
+      },
+    ])
+  )
+}
+
+export const getFeatureFlagValue = (detail: FeatureFlagDetail | undefined): FeatureFlagValue | undefined => {
+  return detail === undefined ? undefined : (detail.variant ?? detail.enabled)
+}
+
+export const parsePayload = (response: any): any => {
+  if (typeof response !== 'string') {
+    return response
+  }
+
+  try {
+    return JSON.parse(response)
+  } catch {
+    return response
+  }
+}
+
+/**
+ * Get the normalized flag details from the flags and payloads.
+ * This is used to convert things like boostrap and stored feature flags and payloads to the v4 format.
+ * This helps us ensure backwards compatibility.
+ * If a key exists in the featureFlagPayloads that is not in the featureFlags, we treat it as a true feature flag.
+ *
+ * @param featureFlags - The feature flags
+ * @param featureFlagPayloads - The feature flag payloads
+ * @returns The normalized flag details
+ */
+export const createFlagsResponseFromFlagsAndPayloads = (
+  featureFlags: PostHogV1FlagsResponse['featureFlags'],
+  featureFlagPayloads: PostHogV1FlagsResponse['featureFlagPayloads']
+): PostHogFeatureFlagsResponse => {
+  // If a feature flag payload key is not in the feature flags, we treat it as true feature flag.
+  const allKeys = [...new Set([...Object.keys(featureFlags ?? {}), ...Object.keys(featureFlagPayloads ?? {})])]
+  const enabledFlags = allKeys
+    .filter((flag) => !!featureFlags[flag] || !!featureFlagPayloads[flag])
+    .reduce((res: Record<string, FeatureFlagValue>, key) => ((res[key] = featureFlags[key] ?? true), res), {})
+
+  const flagDetails: PostHogFlagsAndPayloadsResponse = {
+    featureFlags: enabledFlags,
+    featureFlagPayloads: featureFlagPayloads ?? {},
+  }
+
+  return normalizeFlagsResponse(flagDetails as PostHogV1FlagsResponse)
+}
+
+export const updateFlagValue = (flag: FeatureFlagDetail, value: FeatureFlagValue): FeatureFlagDetail => {
+  return {
+    ...flag,
+    enabled: getEnabledFromValue(value),
+    variant: getVariantFromValue(value),
+  }
+}
+
+function getEnabledFromValue(value: FeatureFlagValue): boolean {
+  return typeof value === 'string' ? true : value
+}
+
+function getVariantFromValue(value: FeatureFlagValue): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}

package/src/gzip.ts

@@ -0,0 +1,29 @@
+/**
+ * Older browsers and some runtimes don't support this yet
+ * This API (as of 2025-05-07) is not available on React Native.
+ */
+export function isGzipSupported(): boolean {
+  return 'CompressionStream' in globalThis
+}
+
+/**
+ * Gzip a string using Compression Streams API if it's available
+ */
+export async function gzipCompress(input: string, isDebug = true): Promise<Blob | null> {
+  try {
+    // Turn the string into a stream using a Blob, and then compress it
+    const dataStream = new Blob([input], {
+      type: 'text/plain',
+    }).stream()
+
+    const compressedStream = dataStream.pipeThrough(new CompressionStream('gzip'))
+
+    // Using a Response to easily extract the readablestream value. Decoding into a string for fetch
+    return await new Response(compressedStream).blob()
+  } catch (error) {
+    if (isDebug) {
+      console.error('Failed to gzip compress data', error)
+    }
+    return null
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { getFeatureFlagValue } from './featureFlagUtils'
+export * from './utils'
+export * as ErrorTracking from './error-tracking'
+export { uuidv7 } from './vendor/uuidv7'
+export * as testing from './testing'
+export * from './posthog-core'
+export * from './posthog-core-stateless'
+export * from './types'