@pendo/openfeature-web-provider 0.1.0 → 0.2.0

package/README.md

@@ -10,15 +10,15 @@ 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>
+The Pendo Web SDK must be installed and initialized on your page with `requestSegmentFlags: true` enabled.
+
+```javascript
+// Initialize Pendo with segment flags enabled
+pendo.initialize({
+  visitor: { id: 'user-123' },
+  account: { id: 'account-456' },
+  requestSegmentFlags: true  // Required for feature flags
+});
 ```
 
 ## Usage
@@ -29,7 +29,7 @@ The Pendo agent must be installed on your page. The provider reads flags from `w
 import { OpenFeature } from '@openfeature/web-sdk';
 import { PendoProvider } from '@pendo/openfeature-web-provider';
 
-// Initialize the provider (waits for Pendo agent to be ready)
+// Initialize the provider (waits for Pendo to be ready)
 await OpenFeature.setProviderAndWait(new PendoProvider());
 
 // Get a client
@@ -40,16 +40,16 @@ const client = OpenFeature.getClient();
 
 ```typescript
 // Boolean flag
-const showNewFeature = await client.getBooleanValue('new-checkout-flow', false);
+const showNewFeature = client.getBooleanValue('new-checkout-flow', false);
 
 // String flag (returns "on" or "off")
-const variant = await client.getStringValue('checkout-variant', 'control');
+const variant = client.getStringValue('checkout-variant', 'control');
 
 // Number flag (returns 1 or 0)
-const flagValue = await client.getNumberValue('feature-score', 0);
+const flagValue = client.getNumberValue('feature-score', 0);
 
 // Object flag (returns { enabled: true/false })
-const config = await client.getObjectValue('feature-config', { enabled: false });
+const config = client.getObjectValue('feature-config', { enabled: false });
 ```
 
 ### Event Tracking
@@ -57,18 +57,47 @@ const config = await client.getObjectValue('feature-config', { enabled: false })
 Track custom events to Pendo:
 
 ```typescript
-const provider = new PendoProvider();
-await OpenFeature.setProviderAndWait(provider);
+const client = OpenFeature.getClient();
 
-// Track an event
-provider.track('checkout_started', undefined, { cartValue: '99.99' });
+// Track an event (delegates to pendo.track)
+client.track('checkout_started', { cartValue: '99.99' });
+```
+
+### Configuration Options
 
-// The context parameter is ignored in the web provider
-// since the Pendo agent already knows the current visitor
-provider.track('feature_used');
+```typescript
+const provider = new PendoProvider({
+  // Timeout waiting for the Pendo Web SDK to be ready (default: 5000ms)
+  readyTimeout: 10000,
+});
 ```
 
-### Telemetry Hook
+## How It Works
+
+1. The provider waits for the Pendo Web SDK to be ready
+2. Flag evaluation checks if the flag key exists in `pendo.segmentFlags`
+3. When Pendo updates flags (on metadata/identity changes), the provider emits `ConfigurationChanged`
+4. React/Angular OpenFeature SDKs automatically re-render when flags change
+
+## Automatic Flag Updates
+
+The provider subscribes to Pendo's `Events.segmentFlagsUpdated` event to detect when flags are updated. This happens automatically when:
+
+- Pendo initializes and loads initial flags
+- Visitor metadata changes
+- Visitor identity changes (via `pendo.identify()`)
+
+When flags update, the provider emits a `ConfigurationChanged` event, which triggers re-renders in React/Angular SDKs.
+
+## Resolution Details
+
+| Scenario | Reason | Variant |
+|----------|--------|---------|
+| Flag key in segmentFlags | `TARGETING_MATCH` | `on` |
+| Flag key not in segmentFlags | `DEFAULT` | `off` |
+| Pendo not ready / no flags | `DEFAULT` | `default` |
+
+## Telemetry Hook
 
 Automatically track all flag evaluations to Pendo using the telemetry hook:
 
@@ -83,7 +112,7 @@ await OpenFeature.setProviderAndWait(provider);
 OpenFeature.addHooks(telemetryHook);
 ```
 
-#### Telemetry Hook Options
+### Telemetry Hook Options
 
 ```typescript
 const telemetryHook = new PendoTelemetryHook({
@@ -95,62 +124,14 @@ const telemetryHook = new PendoTelemetryHook({
 });
 ```
 
-#### 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
+1. Ensure `requestSegmentFlags: true` is set in your Pendo initialization
+2. Check that Pendo is properly initialized before the provider
+3. Verify the visitor is in a segment with the flag enabled
+4. Check browser console for `[PendoProvider]` warnings
 
 ### Provider times out
 
@@ -160,15 +141,13 @@ Increase the `readyTimeout` option:
 new PendoProvider({ readyTimeout: 15000 });
 ```
 
-### Track events not appearing
+### Flags not updating
 
-Ensure the Pendo agent's `track` function is available:
+The provider automatically detects flag changes. If flags aren't updating:
 
-```typescript
-if (window.pendo?.track) {
-  provider.track('my-event');
-}
-```
+1. Verify Pendo is receiving metadata/identity updates
+2. Check that `requestSegmentFlags: true` is enabled
+3. Ensure your segments are configured correctly in Pendo
 
 ## License
 

package/dist/PendoProvider.d.ts

@@ -1,23 +1,9 @@
 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;
-        };
-    }
-}
+import { ClientProviderStatus, OpenFeatureEventEmitter } from "@openfeature/web-sdk";
+import "./types";
 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.
+     * Timeout in milliseconds to wait for Pendo to be ready.
      * Default: 5000ms
      */
     readyTimeout?: number;
@@ -25,37 +11,55 @@ export interface PendoProviderOptions {
 /**
  * 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.
+ * This provider integrates with the Pendo Web SDK's segment-flags plugin
+ * to evaluate feature flags based on segment membership.
+ *
+ * Prerequisites:
+ * - Pendo Web SDK must be installed and initialized on the page
+ * - `requestSegmentFlags: true` must be set in the Pendo configuration
  *
  * @example
  * ```typescript
  * import { OpenFeature } from '@openfeature/web-sdk';
  * import { PendoProvider } from '@pendo/openfeature-web-provider';
  *
+ * // Pendo must be initialized with requestSegmentFlags enabled:
+ * // pendo.initialize({
+ * //   visitor: { id: 'user-123' },
+ * //   account: { id: 'account-456' },
+ * //   requestSegmentFlags: true
+ * // });
+ *
  * await OpenFeature.setProviderAndWait(new PendoProvider());
  *
  * const client = OpenFeature.getClient();
- * const enabled = await client.getBooleanValue('myFeature', false);
+ * const enabled = client.getBooleanValue('myFeature', false);
  * ```
  */
 export declare class PendoProvider implements Provider {
     readonly metadata: ProviderMetadata;
-    readonly rulesChanged?: () => void;
+    readonly events: OpenFeatureEventEmitter;
     status: ClientProviderStatus;
     hooks?: Hook[];
     private options;
-    private readyPromise;
+    private flagChangeDetectionSetup;
+    private flagChangeHandler;
     constructor(options?: PendoProviderOptions);
     /**
      * Initialize the provider.
-     * Waits for Pendo to be ready before resolving.
+     * Waits for Pendo to be ready and sets up flag change detection.
      */
     initialize(): Promise<void>;
     /**
      * Wait for Pendo to be ready with timeout.
      */
     private waitForPendo;
+    /**
+     * Set up detection for when segment flags change.
+     * Listens for the segmentFlagsUpdated event from Pendo.
+     * Idempotent - only runs once.
+     */
+    private setupFlagChangeDetection;
     /**
      * Shutdown the provider.
      */
@@ -84,19 +88,15 @@ export declare class PendoProvider implements Provider {
      * 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
+     * Delegates to the Pendo Web SDK's track function.
      */
     track(trackingEventName: string, _context: EvaluationContext, trackingEventDetails: TrackingEventDetails): void;
+    /**
+     * Get the segment flags array from Pendo.
+     * Returns null if Pendo is not available or flags haven't been loaded.
+     */
+    private getSegmentFlags;
 }

package/dist/PendoProvider.js

@@ -2,21 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PendoProvider = void 0;
 const web_sdk_1 = require("@openfeature/web-sdk");
+require("./types");
 /**
  * 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.
+ * This provider integrates with the Pendo Web SDK's segment-flags plugin
+ * to evaluate feature flags based on segment membership.
+ *
+ * Prerequisites:
+ * - Pendo Web SDK must be installed and initialized on the page
+ * - `requestSegmentFlags: true` must be set in the Pendo configuration
  *
  * @example
  * ```typescript
  * import { OpenFeature } from '@openfeature/web-sdk';
  * import { PendoProvider } from '@pendo/openfeature-web-provider';
  *
+ * // Pendo must be initialized with requestSegmentFlags enabled:
+ * // pendo.initialize({
+ * //   visitor: { id: 'user-123' },
+ * //   account: { id: 'account-456' },
+ * //   requestSegmentFlags: true
+ * // });
+ *
  * await OpenFeature.setProviderAndWait(new PendoProvider());
  *
  * const client = OpenFeature.getClient();
- * const enabled = await client.getBooleanValue('myFeature', false);
+ * const enabled = client.getBooleanValue('myFeature', false);
  * ```
  */
 class PendoProvider {
@@ -24,8 +36,10 @@ class PendoProvider {
         this.metadata = {
             name: "pendo-provider",
         };
+        this.events = new web_sdk_1.OpenFeatureEventEmitter();
         this.status = web_sdk_1.ClientProviderStatus.NOT_READY;
-        this.readyPromise = null;
+        this.flagChangeDetectionSetup = false;
+        this.flagChangeHandler = null;
         this.options = {
             readyTimeout: 5000,
             ...options,
@@ -33,23 +47,24 @@ class PendoProvider {
     }
     /**
      * Initialize the provider.
-     * Waits for Pendo to be ready before resolving.
+     * Waits for Pendo to be ready and sets up flag change detection.
      */
     async initialize() {
-        if (this.readyPromise) {
-            return this.readyPromise;
+        // Listen for pendo_ready to set up detection even if we timeout initially
+        if (typeof document !== "undefined") {
+            document.addEventListener("pendo_ready", () => this.setupFlagChangeDetection(), { once: true });
         }
-        this.readyPromise = this.waitForPendo();
-        await this.readyPromise;
+        await this.waitForPendo();
+        this.setupFlagChangeDetection();
         this.status = web_sdk_1.ClientProviderStatus.READY;
     }
     /**
      * Wait for Pendo to be ready with timeout.
      */
     async waitForPendo() {
-        const timeout = this.options.readyTimeout ?? 5000;
+        const timeout = this.options.readyTimeout;
         const startTime = Date.now();
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             const check = () => {
                 // Check if pendo is available and ready
                 if (typeof window !== "undefined" && window.pendo) {
@@ -60,8 +75,6 @@ class PendoProvider {
                 }
                 // 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;
@@ -69,21 +82,46 @@ class PendoProvider {
                 // Try again
                 setTimeout(check, 100);
             };
-            // Also listen for pendo:ready event
+            // Also listen for pendo_ready event
             if (typeof document !== "undefined") {
-                document.addEventListener("pendo:ready", () => {
-                    resolve();
-                }, { once: true });
+                document.addEventListener("pendo_ready", () => resolve(), { once: true });
             }
             check();
         });
     }
+    /**
+     * Set up detection for when segment flags change.
+     * Listens for the segmentFlagsUpdated event from Pendo.
+     * Idempotent - only runs once.
+     */
+    setupFlagChangeDetection() {
+        if (this.flagChangeDetectionSetup) {
+            return;
+        }
+        if (typeof window === "undefined" || !window.pendo?.Events?.segmentFlagsUpdated) {
+            return;
+        }
+        this.flagChangeDetectionSetup = true;
+        // Create handler and store reference for cleanup
+        this.flagChangeHandler = () => {
+            this.events.emit(web_sdk_1.ProviderEvents.ConfigurationChanged);
+        };
+        // Subscribe to Pendo's segmentFlagsUpdated event
+        window.pendo.Events.segmentFlagsUpdated.on(this.flagChangeHandler);
+    }
     /**
      * Shutdown the provider.
      */
     async onClose() {
+        // Unsubscribe from Pendo events
+        if (typeof window !== "undefined" &&
+            window.pendo?.Events?.segmentFlagsUpdated &&
+            this.flagChangeHandler) {
+            window.pendo.Events.segmentFlagsUpdated.off(this.flagChangeHandler);
+        }
         this.status = web_sdk_1.ClientProviderStatus.NOT_READY;
-        this.readyPromise = null;
+        this.flagChangeHandler = null;
+        this.flagChangeDetectionSetup = false;
     }
     /**
      * Resolve a boolean flag value.
@@ -92,7 +130,7 @@ class PendoProvider {
      */
     resolveBooleanEvaluation(flagKey, defaultValue, _context) {
         const flags = this.getSegmentFlags();
-        if (!flags) {
+        if (flags === null) {
             return {
                 value: defaultValue,
                 reason: "DEFAULT",
@@ -166,40 +204,38 @@ class PendoProvider {
             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
+     * Delegates to the Pendo Web SDK's track function.
      */
     track(trackingEventName, _context, trackingEventDetails) {
         if (typeof window === "undefined" || !window.pendo?.track) {
-            console.warn("[PendoProvider] Pendo agent not available for tracking");
+            console.warn("[PendoProvider] Pendo Web SDK not available for tracking");
             return;
         }
-        // Convert TrackingEventDetails to Record<string, string> for Pendo agent
+        // Convert TrackingEventDetails to Record<string, string> for Pendo Web SDK
         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);
     }
+    /**
+     * Get the segment flags array from Pendo.
+     * Returns null if Pendo is not available or flags haven't been loaded.
+     */
+    getSegmentFlags() {
+        if (typeof window === "undefined" || !window.pendo) {
+            return null;
+        }
+        const flags = window.pendo.segmentFlags;
+        // Return null if flags haven't been loaded yet (undefined)
+        // Return the array (even if empty) if flags have been loaded
+        return flags === undefined ? null : flags;
+    }
 }
 exports.PendoProvider = PendoProvider;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PendoProvider.js","sourceRoot":"","sources":["../src/PendoProvider.ts"],"names":[],"mappings":";;;AASA,kDAA4D;AA2B5D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,aAAa;IAYxB,YAAY,UAAgC,EAAE;QAXrC,aAAQ,GAAqB;YACpC,IAAI,EAAE,gBAAgB;SACvB,CAAC;QAGF,WAAM,GAAyB,8BAAoB,CAAC,SAAS,CAAC;QAItD,iBAAY,GAAyB,IAAI,CAAC;QAGhD,IAAI,CAAC,OAAO,GAAG;YACb,YAAY,EAAE,IAAI;YAClB,GAAG,OAAO;SACX,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACxC,MAAM,IAAI,CAAC,YAAY,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,8BAAoB,CAAC,KAAK,CAAC;IAC3C,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,IAAI,CAAC;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,KAAK,GAAG,GAAG,EAAE;gBACjB,wCAAwC;gBACxC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;oBAClD,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,MAAM,CAAC,KAAK,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;wBACxE,OAAO,EAAE,CAAC;wBACV,OAAO;oBACT,CAAC;gBACH,CAAC;gBAED,gBAAgB;gBAChB,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,CAAC;oBACrC,qDAAqD;oBACrD,8BAA8B;oBAC9B,OAAO,CAAC,IAAI,CACV,gFAAgF,CACjF,CAAC;oBACF,OAAO,EAAE,CAAC;oBACV,OAAO;gBACT,CAAC;gBAED,YAAY;gBACZ,UAAU,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACzB,CAAC,CAAC;YAEF,oCAAoC;YACpC,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;gBACpC,QAAQ,CAAC,gBAAgB,CACvB,aAAa,EACb,GAAG,EAAE;oBACH,OAAO,EAAE,CAAC;gBACZ,CAAC,EACD,EAAE,IAAI,EAAE,IAAI,EAAE,CACf,CAAC;YACJ,CAAC;YAED,KAAK,EAAE,CAAC;QACV,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,MAAM,GAAG,8BAAoB,CAAC,SAAS,CAAC;QAC7C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,wBAAwB,CACtB,OAAe,EACf,YAAqB,EACrB,QAA2B;QAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAErC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,KAAK,EAAE,YAAY;gBACnB,MAAM,EAAE,SAAS;gBACjB,OAAO,EAAE,SAAS;aACnB,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAExC,OAAO;YACL,KAAK,EAAE,OAAO;YACd,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS;YAC/C,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;SAChC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,uBAAuB,CACrB,OAAe,EACf,YAAoB,EACpB,OAA0B;QAE1B,MAAM,UAAU,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAE1E,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACzD,OAAO;gBACL,KAAK,EAAE,YAAY;gBACnB,MAAM,EAAE,SAAS;gBACjB,OAAO,EAAE,SAAS;aACnB,CAAC;QACJ,CAAC;QAED,OAAO;YACL,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK;YACtC,MAAM,EAAE,UAAU,CAAC,MAAM;YACzB,OAAO,EAAE,UAAU,CAAC,OAAO;SAC5B,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,uBAAuB,CACrB,OAAe,EACf,YAAoB,EACpB,OAA0B;QAE1B,MAAM,UAAU,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAE1E,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACzD,OAAO;gBACL,KAAK,EAAE,YAAY;gBACnB,MAAM,EAAE,SAAS;gBACjB,OAAO,EAAE,SAAS;aACnB,CAAC;QACJ,CAAC;QAED,OAAO;YACL,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,EAAE,UAAU,CAAC,MAAM;YACzB,OAAO,EAAE,UAAU,CAAC,OAAO;SAC5B,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,uBAAuB,CACrB,OAAe,EACf,YAAe,EACf,OAA0B;QAE1B,MAAM,UAAU,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAE1E,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACzD,OAAO;gBACL,KAAK,EAAE,YAAY;gBACnB,MAAM,EAAE,SAAS;gBACjB,OAAO,EAAE,SAAS;aACnB,CAAC;QACJ,CAAC;QAED,OAAO;YACL,KAAK,EAAE,EAAE,OAAO,EAAE,UAAU,CAAC,KAAK,EAAkB;YACpD,MAAM,EAAE,UAAU,CAAC,MAAM;YACzB,OAAO,EAAE,UAAU,CAAC,OAAO;SAC5B,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,eAAe;QACrB,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;YAClC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,MAAM,CAAC,KAAK,EAAE,YAAY,CAAC;IACpC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CACH,iBAAyB,EACzB,QAA2B,EAC3B,oBAA0C;QAE1C,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC;YAC1D,OAAO,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;YACvE,OAAO;QACT,CAAC;QAED,yEAAyE;QACzE,MAAM,UAAU,GAA2B,EAAE,CAAC;QAC9C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC;YAChE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBAC1C,UAAU,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAED,2CAA2C;QAC3C,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC;CACF;AAhPD,sCAgPC","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"]}
+//# 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 {\n  ClientProviderStatus,\n  OpenFeatureEventEmitter,\n  ProviderEvents,\n} from \"@openfeature/web-sdk\";\nimport \"./types\";\n\nexport interface PendoProviderOptions {\n  /**\n   * 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 integrates with the Pendo Web SDK's segment-flags plugin\n * to evaluate feature flags based on segment membership.\n *\n * Prerequisites:\n * - Pendo Web SDK must be installed and initialized on the page\n * - `requestSegmentFlags: true` must be set in the Pendo configuration\n *\n * @example\n * ```typescript\n * import { OpenFeature } from '@openfeature/web-sdk';\n * import { PendoProvider } from '@pendo/openfeature-web-provider';\n *\n * // Pendo must be initialized with requestSegmentFlags enabled:\n * // pendo.initialize({\n * //   visitor: { id: 'user-123' },\n * //   account: { id: 'account-456' },\n * //   requestSegmentFlags: true\n * // });\n *\n * await OpenFeature.setProviderAndWait(new PendoProvider());\n *\n * const client = OpenFeature.getClient();\n * const enabled = client.getBooleanValue('myFeature', false);\n * ```\n */\nexport class PendoProvider implements Provider {\n  readonly metadata: ProviderMetadata = {\n    name: \"pendo-provider\",\n  };\n\n  readonly events = new OpenFeatureEventEmitter();\n  status: ClientProviderStatus = ClientProviderStatus.NOT_READY;\n  hooks?: Hook[];\n\n  private options: Required<PendoProviderOptions>;\n  private flagChangeDetectionSetup = false;\n  private flagChangeHandler: (() => 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 and sets up flag change detection.\n   */\n  async initialize(): Promise<void> {\n    // Listen for pendo_ready to set up detection even if we timeout initially\n    if (typeof document !== \"undefined\") {\n      document.addEventListener(\n        \"pendo_ready\",\n        () => this.setupFlagChangeDetection(),\n        { once: true }\n      );\n    }\n\n    await this.waitForPendo();\n    this.setupFlagChangeDetection();\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;\n    const startTime = Date.now();\n\n    return new Promise((resolve) => {\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          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          () => resolve(),\n          { once: true }\n        );\n      }\n\n      check();\n    });\n  }\n\n  /**\n   * Set up detection for when segment flags change.\n   * Listens for the segmentFlagsUpdated event from Pendo.\n   * Idempotent - only runs once.\n   */\n  private setupFlagChangeDetection(): void {\n    if (this.flagChangeDetectionSetup) {\n      return;\n    }\n\n    if (typeof window === \"undefined\" || !window.pendo?.Events?.segmentFlagsUpdated) {\n      return;\n    }\n\n    this.flagChangeDetectionSetup = true;\n\n    // Create handler and store reference for cleanup\n    this.flagChangeHandler = () => {\n      this.events.emit(ProviderEvents.ConfigurationChanged);\n    };\n\n    // Subscribe to Pendo's segmentFlagsUpdated event\n    window.pendo.Events.segmentFlagsUpdated.on(this.flagChangeHandler);\n  }\n\n  /**\n   * Shutdown the provider.\n   */\n  async onClose(): Promise<void> {\n    // Unsubscribe from Pendo events\n    if (\n      typeof window !== \"undefined\" &&\n      window.pendo?.Events?.segmentFlagsUpdated &&\n      this.flagChangeHandler\n    ) {\n      window.pendo.Events.segmentFlagsUpdated.off(this.flagChangeHandler);\n    }\n\n    this.status = ClientProviderStatus.NOT_READY;\n    this.flagChangeHandler = null;\n    this.flagChangeDetectionSetup = false;\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 === null) {\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   * Track a custom event in Pendo.\n   *\n   * Delegates to the Pendo Web SDK's track function.\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 Web SDK not available for tracking\");\n      return;\n    }\n\n    // Convert TrackingEventDetails to Record<string, string> for Pendo Web SDK\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    window.pendo.track(trackingEventName, properties);\n  }\n\n  /**\n   * Get the segment flags array from Pendo.\n   * Returns null if Pendo is not available or flags haven't been loaded.\n   */\n  private getSegmentFlags(): string[] | null {\n    if (typeof window === \"undefined\" || !window.pendo) {\n      return null;\n    }\n\n    const flags = window.pendo.segmentFlags;\n\n    // Return null if flags haven't been loaded yet (undefined)\n    // Return the array (even if empty) if flags have been loaded\n    return flags === undefined ? null : flags;\n  }\n}\n"]}

package/dist/PendoTelemetryHook.d.ts

@@ -1,4 +1,5 @@
 import type { Hook, HookContext, EvaluationDetails, FlagValue } from "@openfeature/web-sdk";
+import "./types";
 export interface PendoTelemetryHookOptions {
     /**
      * Event name for flag evaluation tracking.
@@ -17,7 +18,7 @@ export interface PendoTelemetryHookOptions {
  * 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
+ * The hook uses the Pendo Web SDK's track function, so the Pendo Web SDK must be
  * initialized on the page for tracking to work.
  *
  * @example

package/dist/PendoTelemetryHook.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PendoTelemetryHook = void 0;
+require("./types");
 /**
  * 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
+ * The hook uses the Pendo Web SDK's track function, so the Pendo Web SDK must be
  * initialized on the page for tracking to work.
  *
  * @example
@@ -39,7 +40,7 @@ class PendoTelemetryHook {
         if (this.options.flagFilter && !this.options.flagFilter(flagKey)) {
             return;
         }
-        // Check if Pendo agent is available
+        // Check if Pendo Web SDK is available
         if (typeof window === "undefined" || !window.pendo?.track) {
             return;
         }
@@ -50,7 +51,7 @@ class PendoTelemetryHook {
             flag_value: this.stringifyValue(evaluationDetails.value),
             provider_name: hookContext.providerMetadata.name,
         };
-        // Fire-and-forget: delegate to Pendo agent
+        // Fire-and-forget: delegate to Pendo Web SDK
         window.pendo.track(this.options.eventName, properties);
     }
     /**
@@ -67,4 +68,4 @@ class PendoTelemetryHook {
     }
 }
 exports.PendoTelemetryHook = PendoTelemetryHook;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Type declarations for Pendo Web SDK integration.
+ */
+interface PendoEventEmitter {
+    on: (handler: (data?: unknown) => void) => void;
+    off: (handler: (data?: unknown) => void) => void;
+    trigger: (data?: unknown) => void;
+}
+declare global {
+    interface Window {
+        pendo?: {
+            segmentFlags?: string[] | null;
+            isReady?: () => boolean;
+            initialize?: (options: unknown) => void;
+            track?: (event: string, properties?: Record<string, string>) => void;
+            Events?: {
+                segmentFlagsUpdated?: PendoEventEmitter;
+            };
+        };
+    }
+}
+export {};

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type declarations for Pendo Web SDK integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUeXBlIGRlY2xhcmF0aW9ucyBmb3IgUGVuZG8gV2ViIFNESyBpbnRlZ3JhdGlvbi5cbiAqL1xuXG5pbnRlcmZhY2UgUGVuZG9FdmVudEVtaXR0ZXIge1xuICBvbjogKGhhbmRsZXI6IChkYXRhPzogdW5rbm93bikgPT4gdm9pZCkgPT4gdm9pZDtcbiAgb2ZmOiAoaGFuZGxlcjogKGRhdGE/OiB1bmtub3duKSA9PiB2b2lkKSA9PiB2b2lkO1xuICB0cmlnZ2VyOiAoZGF0YT86IHVua25vd24pID0+IHZvaWQ7XG59XG5cbmRlY2xhcmUgZ2xvYmFsIHtcbiAgaW50ZXJmYWNlIFdpbmRvdyB7XG4gICAgcGVuZG8/OiB7XG4gICAgICBzZWdtZW50RmxhZ3M/OiBzdHJpbmdbXSB8IG51bGw7XG4gICAgICBpc1JlYWR5PzogKCkgPT4gYm9vbGVhbjtcbiAgICAgIGluaXRpYWxpemU/OiAob3B0aW9uczogdW5rbm93bikgPT4gdm9pZDtcbiAgICAgIHRyYWNrPzogKGV2ZW50OiBzdHJpbmcsIHByb3BlcnRpZXM/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+KSA9PiB2b2lkO1xuICAgICAgRXZlbnRzPzoge1xuICAgICAgICBzZWdtZW50RmxhZ3NVcGRhdGVkPzogUGVuZG9FdmVudEVtaXR0ZXI7XG4gICAgICB9O1xuICAgIH07XG4gIH1cbn1cblxuLy8gVGhpcyBleHBvcnQgbWFrZXMgdGhpcyBmaWxlIGEgbW9kdWxlXG5leHBvcnQge307XG4iXX0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pendo/openfeature-web-provider",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenFeature provider for Pendo feature flags (web/browser)",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -11,7 +11,11 @@
   "scripts": {
     "build": "tsc",
     "test": "jest",
-    "lint": "eslint src"
+    "lint": "eslint src",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "peerDependencies": {
     "@openfeature/web-sdk": "^1.0.0"