Fullstory

import type {
  EvaluationSeriesContext,
  EvaluationSeriesData,
  Hook,
  LDContext,
  LDEvaluationDetail,
  LDPlugin,
  LDPluginEnvironmentMetadata,
  LDPluginMetadata,
} from 'launchdarkly-js-client-sdk';
declare global {
  interface Window {
    FS?: (operation: string, payload?: unknown) => unknown;
  }
}
// Builds the same fully-qualified context key that LaunchDarkly uses, by
// prefixing each key with its context kind and escaping '%' and ':'.
function canonicalKey(context: LDContext | undefined): string | undefined {
  if (!context || typeof context !== 'object') {
    return undefined;
  }
  const encode = (key: string) => key.replace(/%/g, '%25').replace(/:/g, '%3A');
  const multi = context as Record<string, { key?: string }> & { kind?: string };
  if (multi.kind === 'multi') {
    return Object.keys(multi)
      .filter((kind) => kind !== 'kind')
      .sort()
      .map((kind) => `${kind}:${encode(multi[kind]?.key ?? '')}`)
      .join(':');
  }
  const kind = multi.kind ?? 'user';
  const key = (context as { key?: string }).key;
  if (!key) {
    return undefined;
  }
  return kind === 'user' ? key : `${kind}:${encode(key)}`;
}
// Fullstory infers one type per property name, so serialize every variation
// value to a string.
function serializeValue(value: unknown): string {
  return typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
}
export function fullstoryPlugin(): LDPlugin {
  // Tracks the last value sent for each flag and context, so that repeated
  // evaluations of an unchanged flag do not send duplicate events.
  const lastSent = new Map<string, string>();
  const hook: Hook = {
    getMetadata() {
      return { name: 'fullstory-feature-flag-hook' };
    },
    afterEvaluation(
      hookContext: EvaluationSeriesContext,
      data: EvaluationSeriesData,
      detail: LDEvaluationDetail,
    ): EvaluationSeriesData {
      // The Fullstory snippet attaches a callable FS function to the window
      // object. If you configured a custom namespace, use that global instead.
      if (typeof window.FS !== 'function') {
        return data;
      }
      const contextId = canonicalKey(hookContext.context);
      const value = serializeValue(detail.value);
      const dedupeKey = `${hookContext.flagKey}:${contextId}`;
      if (lastSent.get(dedupeKey) === value) {
        return data;
      }
      lastSent.set(dedupeKey, value);
      window.FS('trackEvent', {
        name: 'feature_flag.evaluation',
        properties: {
          feature_flag: {
            key: hookContext.flagKey,
            provider_name: 'LaunchDarkly',
            context_id: contextId ?? null,
            variation_index: detail.variationIndex ?? null,
            value,
            evaluation_reason: detail.reason?.kind ?? null,
          },
        },
      });
      return data;
    },
  };
  return {
    getMetadata(): LDPluginMetadata {
      return { name: 'fullstory-feature-flag-plugin' };
    },
    getHooks(_environmentMetadata: LDPluginEnvironmentMetadata): Hook[] {
      return [hook];
    },
    register(): void {
      // No setup required. The SDK calls the hook on each evaluation.
    },
  };
}

import type {
  EvaluationSeriesContext,
  EvaluationSeriesData,
  Hook,
  LDEvaluationDetail,
  LDPlugin,
  LDPluginEnvironmentMetadata,
  LDPluginMetadata,
} from 'launchdarkly-js-client-sdk';
declare global {
  interface Window {
    FS?: (operation: string, payload?: unknown) => unknown;
  }
}
// Fullstory infers one type per property name, so serialize every variation
// value to a string.
function serializeValue(value: unknown): string {
  return typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);
}
export function fullstoryPagePropertiesPlugin(): LDPlugin {
  let currentSession: string | undefined;
  let evaluatedFlags: Record<string, string> = {};
  const hook: Hook = {
    getMetadata() {
      return { name: 'fullstory-page-properties-hook' };
    },
    afterEvaluation(
      hookContext: EvaluationSeriesContext,
      data: EvaluationSeriesData,
      detail: LDEvaluationDetail,
    ): EvaluationSeriesData {
      // The Fullstory snippet attaches a callable FS function to the window
      // object. If you configured a custom namespace, use that global instead.
      if (typeof window.FS !== 'function') {
        return data;
      }
      const sessionUrl = window.FS('getSession', { format: 'url' }) as string | undefined;
      if (!sessionUrl) {
        return data;
      }
      // Start a fresh set of flags whenever Fullstory begins a new session.
      if (sessionUrl !== currentSession) {
        currentSession = sessionUrl;
        evaluatedFlags = {};
      }
      // Skip the Fullstory call when this flag already has this value, so that
      // repeated evaluations do not resend an unchanged property.
      const value = serializeValue(detail.value);
      if (evaluatedFlags[hookContext.flagKey] === value) {
        return data;
      }
      evaluatedFlags[hookContext.flagKey] = value;
      const ldflags = Object.keys(evaluatedFlags)
        .sort()
        .map((flagKey) => `${flagKey}=${evaluatedFlags[flagKey]}`);
      window.FS('setProperties', {
        type: 'page',
        properties: { ldflags },
      });
      return data;
    },
  };
  return {
    getMetadata(): LDPluginMetadata {
      return { name: 'fullstory-page-properties-plugin' };
    },
    getHooks(_environmentMetadata: LDPluginEnvironmentMetadata): Hook[] {
      return [hook];
    },
    register(): void {
      // No setup required. The SDK calls the hook on each evaluation.
    },
  };
}