@pendo/openfeature-web-provider 0.1.0

package/README.md

@@ -0,0 +1,175 @@
+# @pendo/openfeature-web-provider
+
+OpenFeature provider for [Pendo](https://www.pendo.io/) feature flags in web browsers.
+
+## Installation
+
+```bash
+npm install @pendo/openfeature-web-provider @openfeature/web-sdk
+```
+
+## Prerequisites
+
+The Pendo agent must be installed on your page. The provider reads flags from `window.pendo.segmentFlags` which is populated by the agent.
+
+```html
+<script>
+  (function(apiKey){
+    // Pendo agent snippet
+    // ...
+  })('YOUR_PENDO_API_KEY');
+</script>
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { OpenFeature } from '@openfeature/web-sdk';
+import { PendoProvider } from '@pendo/openfeature-web-provider';
+
+// Initialize the provider (waits for Pendo agent to be ready)
+await OpenFeature.setProviderAndWait(new PendoProvider());
+
+// Get a client
+const client = OpenFeature.getClient();
+```
+
+### Evaluating Flags
+
+```typescript
+// Boolean flag
+const showNewFeature = await client.getBooleanValue('new-checkout-flow', false);
+
+// String flag (returns "on" or "off")
+const variant = await client.getStringValue('checkout-variant', 'control');
+
+// Number flag (returns 1 or 0)
+const flagValue = await client.getNumberValue('feature-score', 0);
+
+// Object flag (returns { enabled: true/false })
+const config = await client.getObjectValue('feature-config', { enabled: false });
+```
+
+### Event Tracking
+
+Track custom events to Pendo:
+
+```typescript
+const provider = new PendoProvider();
+await OpenFeature.setProviderAndWait(provider);
+
+// Track an event
+provider.track('checkout_started', undefined, { cartValue: '99.99' });
+
+// The context parameter is ignored in the web provider
+// since the Pendo agent already knows the current visitor
+provider.track('feature_used');
+```
+
+### Telemetry Hook
+
+Automatically track all flag evaluations to Pendo using the telemetry hook:
+
+```typescript
+import { OpenFeature } from '@openfeature/web-sdk';
+import { PendoProvider, PendoTelemetryHook } from '@pendo/openfeature-web-provider';
+
+const provider = new PendoProvider();
+const telemetryHook = new PendoTelemetryHook();
+
+await OpenFeature.setProviderAndWait(provider);
+OpenFeature.addHooks(telemetryHook);
+```
+
+#### Telemetry Hook Options
+
+```typescript
+const telemetryHook = new PendoTelemetryHook({
+  // Optional: Custom event name (default: "flag_evaluated")
+  eventName: 'feature_flag_evaluated',
+
+  // Optional: Filter which flags to track
+  flagFilter: (flagKey) => flagKey.startsWith('feature_'),
+});
+```
+
+#### Event Payload
+
+Each flag evaluation sends a track event with these properties:
+
+| Property | Description |
+|----------|-------------|
+| `flag_key` | The flag that was evaluated |
+| `flag_variant` | "on", "off", or variant name |
+| `flag_reason` | "TARGETING_MATCH", "DEFAULT", or "ERROR" |
+| `flag_value` | Stringified value |
+| `provider_name` | "pendo-provider" |
+
+### Configuration Options
+
+```typescript
+const provider = new PendoProvider({
+  // API key for Pendo initialization (optional if already initialized)
+  apiKey: 'YOUR_API_KEY',
+
+  // Timeout waiting for Pendo agent to be ready (default: 5000ms)
+  readyTimeout: 10000,
+});
+```
+
+## How It Works
+
+1. The provider waits for the Pendo agent to initialize
+2. Flag evaluation checks if the flag key exists in `window.pendo.segmentFlags`
+3. If the flag key is present, the flag is enabled; otherwise, it returns the default value
+
+## Context
+
+The web provider does not require explicit context for flag evaluation since the Pendo agent maintains visitor/account identity automatically. However, you can pass context for consistency with the OpenFeature API:
+
+```typescript
+const enabled = await client.getBooleanValue('my-flag', false, {
+  targetingKey: 'user-123',  // Ignored by web provider
+  accountId: 'account-456',  // Ignored by web provider
+});
+```
+
+## Resolution Details
+
+| Scenario | Reason | Variant |
+|----------|--------|---------|
+| Flag key in segmentFlags | `TARGETING_MATCH` | `on` |
+| Flag key not in segmentFlags | `DEFAULT` | `off` |
+| Pendo not ready | `DEFAULT` | `default` |
+
+## Troubleshooting
+
+### Flags always return default values
+
+1. Check that the Pendo agent is properly installed and initialized
+2. Verify the visitor is in a segment that has the flag enabled
+3. Check browser console for `[PendoProvider]` warnings
+
+### Provider times out
+
+Increase the `readyTimeout` option:
+
+```typescript
+new PendoProvider({ readyTimeout: 15000 });
+```
+
+### Track events not appearing
+
+Ensure the Pendo agent's `track` function is available:
+
+```typescript
+if (window.pendo?.track) {
+  provider.track('my-event');
+}
+```
+
+## License
+
+MIT

package/dist/PendoProvider.d.ts

@@ -0,0 +1,102 @@
+import type { Provider, ProviderMetadata, ResolutionDetails, EvaluationContext, JsonValue, Hook, TrackingEventDetails } from "@openfeature/web-sdk";
+import { ClientProviderStatus } from "@openfeature/web-sdk";
+declare global {
+    interface Window {
+        pendo?: {
+            segmentFlags?: string[];
+            isReady?: () => boolean;
+            initialize?: (options: unknown) => void;
+            track?: (event: string, properties?: Record<string, string>) => void;
+        };
+    }
+}
+export interface PendoProviderOptions {
+    /**
+     * Optional: Pendo API key for initialization.
+     * If not provided, assumes Pendo is already initialized on the page.
+     */
+    apiKey?: string;
+    /**
+     * Optional: Timeout in milliseconds to wait for Pendo to be ready.
+     * Default: 5000ms
+     */
+    readyTimeout?: number;
+}
+/**
+ * OpenFeature provider for Pendo feature flags.
+ *
+ * This provider evaluates feature flags by checking the `pendo.segmentFlags` array
+ * which is populated by the Pendo agent based on segment membership.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/web-sdk';
+ * import { PendoProvider } from '@pendo/openfeature-web-provider';
+ *
+ * await OpenFeature.setProviderAndWait(new PendoProvider());
+ *
+ * const client = OpenFeature.getClient();
+ * const enabled = await client.getBooleanValue('myFeature', false);
+ * ```
+ */
+export declare class PendoProvider implements Provider {
+    readonly metadata: ProviderMetadata;
+    readonly rulesChanged?: () => void;
+    status: ClientProviderStatus;
+    hooks?: Hook[];
+    private options;
+    private readyPromise;
+    constructor(options?: PendoProviderOptions);
+    /**
+     * Initialize the provider.
+     * Waits for Pendo to be ready before resolving.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Wait for Pendo to be ready with timeout.
+     */
+    private waitForPendo;
+    /**
+     * Shutdown the provider.
+     */
+    onClose(): Promise<void>;
+    /**
+     * Resolve a boolean flag value.
+     *
+     * Checks if the flagKey exists in pendo.segmentFlags array.
+     */
+    resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, _context: EvaluationContext): ResolutionDetails<boolean>;
+    /**
+     * Resolve a string flag value.
+     *
+     * For Pendo flags, this returns "on" if the flag is enabled, "off" otherwise.
+     */
+    resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext): ResolutionDetails<string>;
+    /**
+     * Resolve a number flag value.
+     *
+     * For Pendo flags, this returns 1 if enabled, 0 if disabled.
+     */
+    resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext): ResolutionDetails<number>;
+    /**
+     * Resolve an object flag value.
+     *
+     * For Pendo flags, this returns { enabled: true/false }.
+     */
+    resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): ResolutionDetails<T>;
+    /**
+     * Get the segment flags array from Pendo.
+     */
+    private getSegmentFlags;
+    /**
+     * Track a custom event in Pendo.
+     *
+     * This method delegates to the Pendo agent's track function.
+     * The Pendo agent must be initialized on the page for this to work.
+     *
+     * @param trackingEventName - The name of the event to track
+     * @param _context - Evaluation context (unused in web provider, Pendo agent handles visitor context)
+     * @param trackingEventDetails - Optional additional event properties
+     */
+    track(trackingEventName: string, _context: EvaluationContext, trackingEventDetails: TrackingEventDetails): void;
+}

package/dist/PendoProvider.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PendoProvider = void 0;
+const web_sdk_1 = require("@openfeature/web-sdk");
+/**
+ * OpenFeature provider for Pendo feature flags.
+ *
+ * This provider evaluates feature flags by checking the `pendo.segmentFlags` array
+ * which is populated by the Pendo agent based on segment membership.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/web-sdk';
+ * import { PendoProvider } from '@pendo/openfeature-web-provider';
+ *
+ * await OpenFeature.setProviderAndWait(new PendoProvider());
+ *
+ * const client = OpenFeature.getClient();
+ * const enabled = await client.getBooleanValue('myFeature', false);
+ * ```
+ */
+class PendoProvider {
+    constructor(options = {}) {
+        this.metadata = {
+            name: "pendo-provider",
+        };
+        this.status = web_sdk_1.ClientProviderStatus.NOT_READY;
+        this.readyPromise = null;
+        this.options = {
+            readyTimeout: 5000,
+            ...options,
+        };
+    }
+    /**
+     * Initialize the provider.
+     * Waits for Pendo to be ready before resolving.
+     */
+    async initialize() {
+        if (this.readyPromise) {
+            return this.readyPromise;
+        }
+        this.readyPromise = this.waitForPendo();
+        await this.readyPromise;
+        this.status = web_sdk_1.ClientProviderStatus.READY;
+    }
+    /**
+     * Wait for Pendo to be ready with timeout.
+     */
+    async waitForPendo() {
+        const timeout = this.options.readyTimeout ?? 5000;
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const check = () => {
+                // Check if pendo is available and ready
+                if (typeof window !== "undefined" && window.pendo) {
+                    if (window.pendo.isReady?.() || window.pendo.segmentFlags !== undefined) {
+                        resolve();
+                        return;
+                    }
+                }
+                // Check timeout
+                if (Date.now() - startTime > timeout) {
+                    // Don't reject - just resolve and work without Pendo
+                    // Flags will default to false
+                    console.warn("[PendoProvider] Pendo not ready within timeout. Flags will use default values.");
+                    resolve();
+                    return;
+                }
+                // Try again
+                setTimeout(check, 100);
+            };
+            // Also listen for pendo:ready event
+            if (typeof document !== "undefined") {
+                document.addEventListener("pendo:ready", () => {
+                    resolve();
+                }, { once: true });
+            }
+            check();
+        });
+    }
+    /**
+     * Shutdown the provider.
+     */
+    async onClose() {
+        this.status = web_sdk_1.ClientProviderStatus.NOT_READY;
+        this.readyPromise = null;
+    }
+    /**
+     * Resolve a boolean flag value.
+     *
+     * Checks if the flagKey exists in pendo.segmentFlags array.
+     */
+    resolveBooleanEvaluation(flagKey, defaultValue, _context) {
+        const flags = this.getSegmentFlags();
+        if (!flags) {
+            return {
+                value: defaultValue,
+                reason: "DEFAULT",
+                variant: "default",
+            };
+        }
+        const enabled = flags.includes(flagKey);
+        return {
+            value: enabled,
+            reason: enabled ? "TARGETING_MATCH" : "DEFAULT",
+            variant: enabled ? "on" : "off",
+        };
+    }
+    /**
+     * Resolve a string flag value.
+     *
+     * For Pendo flags, this returns "on" if the flag is enabled, "off" otherwise.
+     */
+    resolveStringEvaluation(flagKey, defaultValue, context) {
+        const boolResult = this.resolveBooleanEvaluation(flagKey, false, context);
+        if (boolResult.reason === "DEFAULT" && !boolResult.value) {
+            return {
+                value: defaultValue,
+                reason: "DEFAULT",
+                variant: "default",
+            };
+        }
+        return {
+            value: boolResult.value ? "on" : "off",
+            reason: boolResult.reason,
+            variant: boolResult.variant,
+        };
+    }
+    /**
+     * Resolve a number flag value.
+     *
+     * For Pendo flags, this returns 1 if enabled, 0 if disabled.
+     */
+    resolveNumberEvaluation(flagKey, defaultValue, context) {
+        const boolResult = this.resolveBooleanEvaluation(flagKey, false, context);
+        if (boolResult.reason === "DEFAULT" && !boolResult.value) {
+            return {
+                value: defaultValue,
+                reason: "DEFAULT",
+                variant: "default",
+            };
+        }
+        return {
+            value: boolResult.value ? 1 : 0,
+            reason: boolResult.reason,
+            variant: boolResult.variant,
+        };
+    }
+    /**
+     * Resolve an object flag value.
+     *
+     * For Pendo flags, this returns { enabled: true/false }.
+     */
+    resolveObjectEvaluation(flagKey, defaultValue, context) {
+        const boolResult = this.resolveBooleanEvaluation(flagKey, false, context);
+        if (boolResult.reason === "DEFAULT" && !boolResult.value) {
+            return {
+                value: defaultValue,
+                reason: "DEFAULT",
+                variant: "default",
+            };
+        }
+        return {
+            value: { enabled: boolResult.value },
+            reason: boolResult.reason,
+            variant: boolResult.variant,
+        };
+    }
+    /**
+     * Get the segment flags array from Pendo.
+     */
+    getSegmentFlags() {
+        if (typeof window === "undefined") {
+            return undefined;
+        }
+        return window.pendo?.segmentFlags;
+    }
+    /**
+     * Track a custom event in Pendo.
+     *
+     * This method delegates to the Pendo agent's track function.
+     * The Pendo agent must be initialized on the page for this to work.
+     *
+     * @param trackingEventName - The name of the event to track
+     * @param _context - Evaluation context (unused in web provider, Pendo agent handles visitor context)
+     * @param trackingEventDetails - Optional additional event properties
+     */
+    track(trackingEventName, _context, trackingEventDetails) {
+        if (typeof window === "undefined" || !window.pendo?.track) {
+            console.warn("[PendoProvider] Pendo agent not available for tracking");
+            return;
+        }
+        // Convert TrackingEventDetails to Record<string, string> for Pendo agent
+        const properties = {};
+        for (const [key, value] of Object.entries(trackingEventDetails)) {
+            if (value !== undefined && value !== null) {
+                properties[key] = String(value);
+            }
+        }
+        // Fire-and-forget: delegate to Pendo agent
+        window.pendo.track(trackingEventName, properties);
+    }
+}
+exports.PendoProvider = PendoProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PendoProvider.js","sourceRoot":"","sources":["../src/PendoProvider.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  Provider,\n  ProviderMetadata,\n  ResolutionDetails,\n  EvaluationContext,\n  JsonValue,\n  Hook,\n  TrackingEventDetails,\n} from \"@openfeature/web-sdk\";\nimport { ClientProviderStatus } from \"@openfeature/web-sdk\";\n\ndeclare global {\n  interface Window {\n    pendo?: {\n      segmentFlags?: string[];\n      isReady?: () => boolean;\n      initialize?: (options: unknown) => void;\n      track?: (event: string, properties?: Record<string, string>) => void;\n    };\n  }\n}\n\nexport interface PendoProviderOptions {\n  /**\n   * Optional: Pendo API key for initialization.\n   * If not provided, assumes Pendo is already initialized on the page.\n   */\n  apiKey?: string;\n\n  /**\n   * Optional: Timeout in milliseconds to wait for Pendo to be ready.\n   * Default: 5000ms\n   */\n  readyTimeout?: number;\n}\n\n/**\n * OpenFeature provider for Pendo feature flags.\n *\n * This provider evaluates feature flags by checking the `pendo.segmentFlags` array\n * which is populated by the Pendo agent based on segment membership.\n *\n * @example\n * ```typescript\n * import { OpenFeature } from '@openfeature/web-sdk';\n * import { PendoProvider } from '@pendo/openfeature-web-provider';\n *\n * await OpenFeature.setProviderAndWait(new PendoProvider());\n *\n * const client = OpenFeature.getClient();\n * const enabled = await client.getBooleanValue('myFeature', false);\n * ```\n */\nexport class PendoProvider implements Provider {\n  readonly metadata: ProviderMetadata = {\n    name: \"pendo-provider\",\n  };\n\n  readonly rulesChanged?: () => void;\n  status: ClientProviderStatus = ClientProviderStatus.NOT_READY;\n  hooks?: Hook[];\n\n  private options: PendoProviderOptions;\n  private readyPromise: Promise<void> | null = null;\n\n  constructor(options: PendoProviderOptions = {}) {\n    this.options = {\n      readyTimeout: 5000,\n      ...options,\n    };\n  }\n\n  /**\n   * Initialize the provider.\n   * Waits for Pendo to be ready before resolving.\n   */\n  async initialize(): Promise<void> {\n    if (this.readyPromise) {\n      return this.readyPromise;\n    }\n\n    this.readyPromise = this.waitForPendo();\n    await this.readyPromise;\n    this.status = ClientProviderStatus.READY;\n  }\n\n  /**\n   * Wait for Pendo to be ready with timeout.\n   */\n  private async waitForPendo(): Promise<void> {\n    const timeout = this.options.readyTimeout ?? 5000;\n    const startTime = Date.now();\n\n    return new Promise((resolve, reject) => {\n      const check = () => {\n        // Check if pendo is available and ready\n        if (typeof window !== \"undefined\" && window.pendo) {\n          if (window.pendo.isReady?.() || window.pendo.segmentFlags !== undefined) {\n            resolve();\n            return;\n          }\n        }\n\n        // Check timeout\n        if (Date.now() - startTime > timeout) {\n          // Don't reject - just resolve and work without Pendo\n          // Flags will default to false\n          console.warn(\n            \"[PendoProvider] Pendo not ready within timeout. Flags will use default values.\"\n          );\n          resolve();\n          return;\n        }\n\n        // Try again\n        setTimeout(check, 100);\n      };\n\n      // Also listen for pendo:ready event\n      if (typeof document !== \"undefined\") {\n        document.addEventListener(\n          \"pendo:ready\",\n          () => {\n            resolve();\n          },\n          { once: true }\n        );\n      }\n\n      check();\n    });\n  }\n\n  /**\n   * Shutdown the provider.\n   */\n  async onClose(): Promise<void> {\n    this.status = ClientProviderStatus.NOT_READY;\n    this.readyPromise = null;\n  }\n\n  /**\n   * Resolve a boolean flag value.\n   *\n   * Checks if the flagKey exists in pendo.segmentFlags array.\n   */\n  resolveBooleanEvaluation(\n    flagKey: string,\n    defaultValue: boolean,\n    _context: EvaluationContext\n  ): ResolutionDetails<boolean> {\n    const flags = this.getSegmentFlags();\n\n    if (!flags) {\n      return {\n        value: defaultValue,\n        reason: \"DEFAULT\",\n        variant: \"default\",\n      };\n    }\n\n    const enabled = flags.includes(flagKey);\n\n    return {\n      value: enabled,\n      reason: enabled ? \"TARGETING_MATCH\" : \"DEFAULT\",\n      variant: enabled ? \"on\" : \"off\",\n    };\n  }\n\n  /**\n   * Resolve a string flag value.\n   *\n   * For Pendo flags, this returns \"on\" if the flag is enabled, \"off\" otherwise.\n   */\n  resolveStringEvaluation(\n    flagKey: string,\n    defaultValue: string,\n    context: EvaluationContext\n  ): ResolutionDetails<string> {\n    const boolResult = this.resolveBooleanEvaluation(flagKey, false, context);\n\n    if (boolResult.reason === \"DEFAULT\" && !boolResult.value) {\n      return {\n        value: defaultValue,\n        reason: \"DEFAULT\",\n        variant: \"default\",\n      };\n    }\n\n    return {\n      value: boolResult.value ? \"on\" : \"off\",\n      reason: boolResult.reason,\n      variant: boolResult.variant,\n    };\n  }\n\n  /**\n   * Resolve a number flag value.\n   *\n   * For Pendo flags, this returns 1 if enabled, 0 if disabled.\n   */\n  resolveNumberEvaluation(\n    flagKey: string,\n    defaultValue: number,\n    context: EvaluationContext\n  ): ResolutionDetails<number> {\n    const boolResult = this.resolveBooleanEvaluation(flagKey, false, context);\n\n    if (boolResult.reason === \"DEFAULT\" && !boolResult.value) {\n      return {\n        value: defaultValue,\n        reason: \"DEFAULT\",\n        variant: \"default\",\n      };\n    }\n\n    return {\n      value: boolResult.value ? 1 : 0,\n      reason: boolResult.reason,\n      variant: boolResult.variant,\n    };\n  }\n\n  /**\n   * Resolve an object flag value.\n   *\n   * For Pendo flags, this returns { enabled: true/false }.\n   */\n  resolveObjectEvaluation<T extends JsonValue>(\n    flagKey: string,\n    defaultValue: T,\n    context: EvaluationContext\n  ): ResolutionDetails<T> {\n    const boolResult = this.resolveBooleanEvaluation(flagKey, false, context);\n\n    if (boolResult.reason === \"DEFAULT\" && !boolResult.value) {\n      return {\n        value: defaultValue,\n        reason: \"DEFAULT\",\n        variant: \"default\",\n      };\n    }\n\n    return {\n      value: { enabled: boolResult.value } as unknown as T,\n      reason: boolResult.reason,\n      variant: boolResult.variant,\n    };\n  }\n\n  /**\n   * Get the segment flags array from Pendo.\n   */\n  private getSegmentFlags(): string[] | undefined {\n    if (typeof window === \"undefined\") {\n      return undefined;\n    }\n\n    return window.pendo?.segmentFlags;\n  }\n\n  /**\n   * Track a custom event in Pendo.\n   *\n   * This method delegates to the Pendo agent's track function.\n   * The Pendo agent must be initialized on the page for this to work.\n   *\n   * @param trackingEventName - The name of the event to track\n   * @param _context - Evaluation context (unused in web provider, Pendo agent handles visitor context)\n   * @param trackingEventDetails - Optional additional event properties\n   */\n  track(\n    trackingEventName: string,\n    _context: EvaluationContext,\n    trackingEventDetails: TrackingEventDetails\n  ): void {\n    if (typeof window === \"undefined\" || !window.pendo?.track) {\n      console.warn(\"[PendoProvider] Pendo agent not available for tracking\");\n      return;\n    }\n\n    // Convert TrackingEventDetails to Record<string, string> for Pendo agent\n    const properties: Record<string, string> = {};\n    for (const [key, value] of Object.entries(trackingEventDetails)) {\n      if (value !== undefined && value !== null) {\n        properties[key] = String(value);\n      }\n    }\n\n    // Fire-and-forget: delegate to Pendo agent\n    window.pendo.track(trackingEventName, properties);\n  }\n}\n"]}

package/dist/PendoTelemetryHook.d.ts

@@ -0,0 +1,47 @@
+import type { Hook, HookContext, EvaluationDetails, FlagValue } from "@openfeature/web-sdk";
+export interface PendoTelemetryHookOptions {
+    /**
+     * Event name for flag evaluation tracking.
+     * Default: "flag_evaluated"
+     */
+    eventName?: string;
+    /**
+     * Optional filter function to selectively track flags.
+     * Return true to track the flag, false to skip.
+     */
+    flagFilter?: (flagKey: string) => boolean;
+}
+/**
+ * OpenFeature hook that automatically tracks flag evaluations to Pendo.
+ *
+ * This hook sends an event to Pendo after each flag evaluation, allowing you
+ * to analyze feature flag usage alongside your other Pendo analytics.
+ *
+ * The hook uses the Pendo agent's track function, so the Pendo agent must be
+ * initialized on the page for tracking to work.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/web-sdk';
+ * import { PendoProvider, PendoTelemetryHook } from '@pendo/openfeature-web-provider';
+ *
+ * const provider = new PendoProvider();
+ * const telemetryHook = new PendoTelemetryHook();
+ *
+ * await OpenFeature.setProviderAndWait(provider);
+ * OpenFeature.addHooks(telemetryHook);
+ * ```
+ */
+export declare class PendoTelemetryHook implements Hook {
+    private options;
+    constructor(options?: PendoTelemetryHookOptions);
+    /**
+     * Called after a flag is successfully evaluated.
+     * Sends the evaluation result to Pendo as a track event.
+     */
+    after(hookContext: Readonly<HookContext<FlagValue>>, evaluationDetails: EvaluationDetails<FlagValue>): void;
+    /**
+     * Convert a flag value to a string for tracking.
+     */
+    private stringifyValue;
+}

package/dist/PendoTelemetryHook.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PendoTelemetryHook = void 0;
+/**
+ * OpenFeature hook that automatically tracks flag evaluations to Pendo.
+ *
+ * This hook sends an event to Pendo after each flag evaluation, allowing you
+ * to analyze feature flag usage alongside your other Pendo analytics.
+ *
+ * The hook uses the Pendo agent's track function, so the Pendo agent must be
+ * initialized on the page for tracking to work.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/web-sdk';
+ * import { PendoProvider, PendoTelemetryHook } from '@pendo/openfeature-web-provider';
+ *
+ * const provider = new PendoProvider();
+ * const telemetryHook = new PendoTelemetryHook();
+ *
+ * await OpenFeature.setProviderAndWait(provider);
+ * OpenFeature.addHooks(telemetryHook);
+ * ```
+ */
+class PendoTelemetryHook {
+    constructor(options = {}) {
+        this.options = {
+            eventName: "flag_evaluated",
+            ...options,
+        };
+    }
+    /**
+     * Called after a flag is successfully evaluated.
+     * Sends the evaluation result to Pendo as a track event.
+     */
+    after(hookContext, evaluationDetails) {
+        const { flagKey } = hookContext;
+        // Check if this flag should be tracked
+        if (this.options.flagFilter && !this.options.flagFilter(flagKey)) {
+            return;
+        }
+        // Check if Pendo agent is available
+        if (typeof window === "undefined" || !window.pendo?.track) {
+            return;
+        }
+        const properties = {
+            flag_key: flagKey,
+            flag_variant: evaluationDetails.variant || "unknown",
+            flag_reason: evaluationDetails.reason || "UNKNOWN",
+            flag_value: this.stringifyValue(evaluationDetails.value),
+            provider_name: hookContext.providerMetadata.name,
+        };
+        // Fire-and-forget: delegate to Pendo agent
+        window.pendo.track(this.options.eventName, properties);
+    }
+    /**
+     * Convert a flag value to a string for tracking.
+     */
+    stringifyValue(value) {
+        if (value === null) {
+            return "null";
+        }
+        if (typeof value === "object") {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+}
+exports.PendoTelemetryHook = PendoTelemetryHook;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { PendoProvider } from "./PendoProvider";
+export type { PendoProviderOptions } from "./PendoProvider";
+export { PendoTelemetryHook } from "./PendoTelemetryHook";
+export type { PendoTelemetryHookOptions } from "./PendoTelemetryHook";

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PendoTelemetryHook = exports.PendoProvider = void 0;
+var PendoProvider_1 = require("./PendoProvider");
+Object.defineProperty(exports, "PendoProvider", { enumerable: true, get: function () { return PendoProvider_1.PendoProvider; } });
+var PendoTelemetryHook_1 = require("./PendoTelemetryHook");
+Object.defineProperty(exports, "PendoTelemetryHook", { enumerable: true, get: function () { return PendoTelemetryHook_1.PendoTelemetryHook; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsaURBQWdEO0FBQXZDLDhHQUFBLGFBQWEsT0FBQTtBQUV0QiwyREFBMEQ7QUFBakQsd0hBQUEsa0JBQWtCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBQZW5kb1Byb3ZpZGVyIH0gZnJvbSBcIi4vUGVuZG9Qcm92aWRlclwiO1xuZXhwb3J0IHR5cGUgeyBQZW5kb1Byb3ZpZGVyT3B0aW9ucyB9IGZyb20gXCIuL1BlbmRvUHJvdmlkZXJcIjtcbmV4cG9ydCB7IFBlbmRvVGVsZW1ldHJ5SG9vayB9IGZyb20gXCIuL1BlbmRvVGVsZW1ldHJ5SG9va1wiO1xuZXhwb3J0IHR5cGUgeyBQZW5kb1RlbGVtZXRyeUhvb2tPcHRpb25zIH0gZnJvbSBcIi4vUGVuZG9UZWxlbWV0cnlIb29rXCI7XG4iXX0=

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@pendo/openfeature-web-provider",
+  "version": "0.1.0",
+  "description": "OpenFeature provider for Pendo feature flags (web/browser)",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src"
+  },
+  "peerDependencies": {
+    "@openfeature/web-sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@openfeature/web-sdk": "^1.0.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "keywords": [
+    "openfeature",
+    "feature-flags",
+    "pendo",
+    "provider"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pendo-io/pendo-flags.git",
+    "directory": "packages/web-provider"
+  }
+}