@splitsoftware/openfeature-js-split-provider 1.1.0 → 1.3.0

package/CHANGES.txt

@@ -1,3 +1,11 @@
+1.3.0 (March 2, 2026)
+  - Updated ConfigurationChanged event to forward SDK_UPDATE metadata from Split (flagsChanged, metadata with type and names)
+  - Requires @splitsoftware/splitio ^11.10.0 for SDK_UPDATE metadata support
+
+1.2.0 (November 7, 2025)
+  - Updated @openfeature/server-sdk to 1.20.0
+  - Updated @splitsoftware/splitio to 11.8.0
+
 1.1.0 (September 12, 2025)
   - Updated @openfeature/server-sdk to 1.19.0
   - Updated @splitsoftware/splitio to 11.4.1

package/README.md

@@ -30,7 +30,9 @@ const OpenFeatureSplitProvider = require('@splitsoftware/openfeature-js-split-pr
 
 const authorizationKey = 'your auth key'
 const provider = new OpenFeatureSplitProvider(authorizationKey);
-OpenFeature.setProvider(provider);
+await OpenFeature.setProviderAndWait(provider);
+const client = OpenFeature.getClient('my-app');
+// safe to evaluate
 ```
 
 ### Register the Split provider with OpenFeature using splitFactory
@@ -42,7 +44,9 @@ const OpenFeatureSplitProvider = require('@splitsoftware/openfeature-js-split-pr
 const authorizationKey = 'your auth key'
 const splitFactory = SplitFactory({core: {authorizationKey}});
 const provider = new OpenFeatureSplitProvider(splitFactory);
-OpenFeature.setProvider(provider);
+await OpenFeature.setProviderAndWait(provider);
+const client = OpenFeature.getClient('my-app');
+// safe to evaluate
 ```
 
 ### Register the Split provider with OpenFeature using splitClient
@@ -54,7 +58,9 @@ const OpenFeatureSplitProvider = require('@splitsoftware/openfeature-js-split-pr
 const authorizationKey = 'your auth key'
 const splitClient = SplitFactory({core: {authorizationKey}}).client();
 const provider = new OpenFeatureSplitProvider({splitClient});
-OpenFeature.setProvider(provider);
+await OpenFeature.setProviderAndWait(provider);
+const client = OpenFeature.getClient('my-app');
+// safe to evaluate
 ```
 
 ## Use of OpenFeature with Split
@@ -94,6 +100,22 @@ const booleanTreatment = await client.getBooleanDetails('boolFlag', false, conte
 const config = booleanTreatment.flagMetadata.config
 ```
 
+## Configuration changed event (SDK_UPDATE)
+
+When the Split SDK emits the `SDK_UPDATE` **event** (flags or segments changed), the provider emits OpenFeature’s `ConfigurationChanged` and forwards the event metadata. The metadata shape matches [javascript-commons SdkUpdateMetadata](https://github.com/splitio/javascript-commons): `type` is `'FLAGS_UPDATE' | 'SEGMENTS_UPDATE'` and `names` is the list of flag or segment names that were updated. Handlers receive [Provider Event Details](https://openfeature.dev/specification/types#provider-event-details): `flagsChanged` (when `type === 'FLAGS_UPDATE'`, the `names` array) and `metadata` (`type` as string).
+
+Requires `@splitsoftware/splitio` **11.10.0 or later** (metadata was added in 11.10.0).
+
+```js
+const { OpenFeature, ProviderEvents } = require('@openfeature/server-sdk');
+
+const client = OpenFeature.getClient();
+client.addHandler(ProviderEvents.ConfigurationChanged, (eventDetails) => {
+  console.log('Flags changed:', eventDetails.flagsChanged);
+  console.log('Event metadata:', eventDetails.metadata);
+});
+```
+
 ## Tracking
 
 To use track(eventName, context, details) you must provide:

package/es/lib/client-resolver.js

@@ -0,0 +1,17 @@
+import { SplitFactory } from '@splitsoftware/splitio';
+/**
+ * Resolves the Split client from the various supported constructor option shapes.
+ * Supports: API key (string), Split SDK/AsyncSDK (factory), or pre-built splitClient.
+ */
+export function getSplitClient(options) {
+    if (typeof options === 'string') {
+        const splitFactory = SplitFactory({ core: { authorizationKey: options } });
+        return splitFactory.client();
+    }
+    try {
+        return options.client();
+    }
+    catch {
+        return options.splitClient;
+    }
+}

package/es/lib/context.js

@@ -0,0 +1,16 @@
+import { DEFAULT_TRAFFIC_TYPE } from './types';
+/**
+ * Transforms OpenFeature evaluation context into the consumer shape used by the Split API:
+ * targeting key, traffic type (with default), and remaining attributes.
+ */
+export function transformContext(context, defaultTrafficType = DEFAULT_TRAFFIC_TYPE) {
+    const { targetingKey, trafficType: ttVal, ...attributes } = context;
+    const trafficType = ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
+        ? ttVal
+        : defaultTrafficType;
+    return {
+        targetingKey,
+        trafficType,
+        attributes: JSON.parse(JSON.stringify(attributes)),
+    };
+}

package/es/lib/js-split-provider.js

@@ -1,47 +1,43 @@
-import { FlagNotFoundError, InvalidContextError, OpenFeatureEventEmitter, ParseError, ProviderEvents, StandardResolutionReasons, TargetingKeyMissingError } from '@openfeature/server-sdk';
-import { SplitFactory } from '@splitsoftware/splitio';
-const CONTROL_VALUE_ERROR_MESSAGE = 'Received the "control" value from Split.';
-const CONTROL_TREATMENT = 'control';
+import { FlagNotFoundError, OpenFeatureEventEmitter, ParseError, ProviderEvents, StandardResolutionReasons, TargetingKeyMissingError } from '@openfeature/server-sdk';
+import { getSplitClient } from './client-resolver';
+import { transformContext } from './context';
+import { parseValidJsonObject, parseValidNumber } from './parsers';
+import { attachReadyEventHandlers, waitUntilReady } from './readiness';
+import { CONTROL_TREATMENT, CONTROL_VALUE_ERROR_MESSAGE, DEFAULT_TRAFFIC_TYPE, PROVIDER_NAME } from './types';
 export class OpenFeatureSplitProvider {
-    getSplitClient(options) {
-        if (typeof (options) === 'string') {
-            const splitFactory = SplitFactory({ core: { authorizationKey: options } });
-            return splitFactory.client();
-        }
-        let splitClient;
-        try {
-            splitClient = options.client();
-        }
-        catch {
-            splitClient = options.splitClient;
-        }
-        return splitClient;
-    }
     constructor(options) {
         this.metadata = {
-            name: 'split',
+            name: PROVIDER_NAME,
         };
+        this.runsOn = 'server';
         this.events = new OpenFeatureEventEmitter();
-        this.client = this.getSplitClient(options);
-        this.client.on(this.client.Event.SDK_UPDATE, () => {
-            this.events.emit(ProviderEvents.ConfigurationChanged);
-        });
-        this.initialized = new Promise((resolve) => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (this.client.__getStatus().isReady) {
-                console.log(`${this.metadata.name} provider initialized`);
-                resolve();
-            }
-            else {
-                this.client.on(this.client.Event.SDK_READY, () => {
-                    console.log(`${this.metadata.name} provider initialized`);
-                    resolve();
-                });
-            }
+        this.trafficType = DEFAULT_TRAFFIC_TYPE;
+        this.client = getSplitClient(options);
+        attachReadyEventHandlers(this.client, this.events, this.metadata.name);
+        this.client.on(this.client.Event.SDK_UPDATE, (updateMetadata) => {
+            const eventDetails = {
+                providerName: this.metadata.name,
+                ...(updateMetadata
+                    ? {
+                        metadata: { type: updateMetadata.type },
+                        flagsChanged: updateMetadata.names || [],
+                    }
+                    : {}),
+            };
+            this.events.emit(ProviderEvents.ConfigurationChanged, eventDetails);
         });
     }
-    async resolveBooleanEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
+    /**
+     * Called by the SDK after the provider is set. Waits for the Split client to be ready.
+     * When this promise resolves, the SDK emits ProviderEvents.Ready.
+     */
+    async initialize(_context) {
+        void _context;
+        await waitUntilReady(this.client, this.events, this.metadata.name);
+    }
+    async resolveBooleanEvaluation(flagKey, _, context, logger) {
+        void logger;
+        const details = await this.evaluateTreatment(flagKey, transformContext(context, this.trafficType));
         const treatment = details.value.toLowerCase();
         if (treatment === 'on' || treatment === 'true') {
             return { ...details, value: true };
@@ -51,54 +47,48 @@ export class OpenFeatureSplitProvider {
         }
         throw new ParseError(`Invalid boolean value for ${treatment}`);
     }
-    async resolveStringEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
-        return details;
+    async resolveStringEvaluation(flagKey, _, context, logger) {
+        void logger;
+        return this.evaluateTreatment(flagKey, transformContext(context, this.trafficType));
     }
-    async resolveNumberEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
-        return { ...details, value: this.parseValidNumber(details.value) };
+    async resolveNumberEvaluation(flagKey, _, context, logger) {
+        void logger;
+        const details = await this.evaluateTreatment(flagKey, transformContext(context, this.trafficType));
+        return { ...details, value: parseValidNumber(details.value) };
     }
-    async resolveObjectEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
-        return { ...details, value: this.parseValidJsonObject(details.value) };
+    async resolveObjectEvaluation(flagKey, _, context, logger) {
+        void logger;
+        const details = await this.evaluateTreatment(flagKey, transformContext(context, this.trafficType));
+        return { ...details, value: parseValidJsonObject(details.value) };
     }
     async evaluateTreatment(flagKey, consumer) {
-        if (!consumer.key) {
+        if (!consumer.targetingKey) {
             throw new TargetingKeyMissingError('The Split provider requires a targeting key.');
         }
         if (flagKey == null || flagKey === '') {
             throw new FlagNotFoundError('flagKey must be a non-empty string');
         }
-        await this.initialized;
-        const { treatment: value, config } = await this.client.getTreatmentWithConfig(consumer.key, flagKey, consumer.attributes);
+        await waitUntilReady(this.client, this.events, this.metadata.name);
+        const { treatment: value, config } = await this.client.getTreatmentWithConfig(consumer.targetingKey, flagKey, consumer.attributes);
         if (value === CONTROL_TREATMENT) {
             throw new FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
         }
-        const flagMetadata = { config: config ? config : '' };
-        const details = {
-            value: value,
+        const flagMetadata = Object.freeze({ config: config ?? '' });
+        return {
+            value,
             variant: value,
-            flagMetadata: flagMetadata,
+            flagMetadata,
             reason: StandardResolutionReasons.TARGETING_MATCH,
         };
-        return details;
     }
     async track(trackingEventName, context, details) {
-        // targetingKey is always required
-        const { targetingKey } = context;
-        if (targetingKey == null || targetingKey === '')
-            throw new TargetingKeyMissingError('Missing targetingKey, required to track');
-        // eventName is always required
-        if (trackingEventName == null || trackingEventName === '')
+        if (trackingEventName == null || trackingEventName === '') {
             throw new ParseError('Missing eventName, required to track');
-        // trafficType is always required
-        const ttVal = context['trafficType'];
-        const trafficType = ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
-            ? ttVal
-            : null;
-        if (trafficType == null || trafficType === '')
-            throw new InvalidContextError('Missing trafficType variable, required to track');
+        }
+        const { targetingKey, trafficType } = transformContext(context, this.trafficType);
+        if (targetingKey == null || targetingKey === '') {
+            throw new TargetingKeyMissingError('Missing targetingKey, required to track');
+        }
         let value;
         let properties = {};
         if (details != null) {
@@ -114,39 +104,4 @@ export class OpenFeatureSplitProvider {
     async onClose() {
         return this.client.destroy();
     }
-    //Transform the context into an object useful for the Split API, an key string with arbitrary Split 'Attributes'.
-    transformContext(context) {
-        const { targetingKey, ...attributes } = context;
-        return {
-            key: targetingKey,
-            // Stringify context objects include date.
-            attributes: JSON.parse(JSON.stringify(attributes)),
-        };
-    }
-    parseValidNumber(stringValue) {
-        if (stringValue === undefined) {
-            throw new ParseError(`Invalid 'undefined' value.`);
-        }
-        const result = Number.parseFloat(stringValue);
-        if (Number.isNaN(result)) {
-            throw new ParseError(`Invalid numeric value ${stringValue}`);
-        }
-        return result;
-    }
-    parseValidJsonObject(stringValue) {
-        if (stringValue === undefined) {
-            throw new ParseError(`Invalid 'undefined' JSON value.`);
-        }
-        // we may want to allow the parsing to be customized.
-        try {
-            const value = JSON.parse(stringValue);
-            if (typeof value !== 'object') {
-                throw new ParseError(`Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`);
-            }
-            return value;
-        }
-        catch (err) {
-            throw new ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
-        }
-    }
 }

package/es/lib/parsers.js

@@ -0,0 +1,26 @@
+import { ParseError } from '@openfeature/server-sdk';
+export function parseValidNumber(stringValue) {
+    if (stringValue === undefined) {
+        throw new ParseError(`Invalid 'undefined' value.`);
+    }
+    const result = Number.parseFloat(stringValue);
+    if (Number.isNaN(result)) {
+        throw new ParseError(`Invalid numeric value ${stringValue}`);
+    }
+    return result;
+}
+export function parseValidJsonObject(stringValue) {
+    if (stringValue === undefined) {
+        throw new ParseError(`Invalid 'undefined' JSON value.`);
+    }
+    try {
+        const value = JSON.parse(stringValue);
+        if (typeof value !== 'object') {
+            throw new ParseError(`Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`);
+        }
+        return value;
+    }
+    catch (err) {
+        throw new ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
+    }
+}

package/es/lib/readiness.js

@@ -0,0 +1,64 @@
+import { ProviderEvents } from '@openfeature/server-sdk';
+import { PROVIDER_NAME } from './types';
+/**
+ * Builds OpenFeature Ready event details including Split SDK ready metadata.
+ * Handles Split SDK not passing metadata (e.g. in consumer/Redis mode).
+ */
+function buildReadyEventDetails(providerName, splitMetadata, readyFromCache) {
+    const metadata = {
+        readyFromCache,
+        initialCacheLoad: splitMetadata?.initialCacheLoad ?? false,
+    };
+    if (splitMetadata?.lastUpdateTimestamp != null) {
+        metadata.lastUpdateTimestamp = splitMetadata.lastUpdateTimestamp;
+    }
+    return {
+        providerName: providerName || PROVIDER_NAME,
+        metadata,
+    };
+}
+/**
+ * Registers Split SDK_READY and SDK_READY_FROM_CACHE listeners and forwards them
+ * as OpenFeature ProviderEvents.Ready with event metadata (initialCacheLoad, lastUpdateTimestamp, readyFromCache).
+ * If the client is already ready when attaching (e.g. localhost or reused client), emits Ready once
+ * with best-effort metadata so handlers always receive at least one Ready when the client is ready.
+ */
+export function attachReadyEventHandlers(client, events, providerName = PROVIDER_NAME) {
+    client.on(client.Event.SDK_READY_FROM_CACHE, (splitMetadata) => {
+        events.emit(ProviderEvents.Ready, buildReadyEventDetails(providerName, splitMetadata, true));
+    });
+    client.on(client.Event.SDK_READY, (splitMetadata) => {
+        events.emit(ProviderEvents.Ready, buildReadyEventDetails(providerName, splitMetadata, false));
+    });
+    const status = client.getStatus();
+    if (status.isReady) {
+        events.emit(ProviderEvents.Ready, buildReadyEventDetails(providerName, undefined, false));
+    }
+}
+/**
+ * Returns a promise that resolves when the Split client is ready (SDK_READY),
+ * or rejects if the client has timed out (SDK_READY_TIMED_OUT).
+ * Used to gate evaluations until the SDK has synchronized with the backend.
+ */
+export function waitUntilReady(client, events, providerName = PROVIDER_NAME) {
+    return new Promise((resolve, reject) => {
+        const status = client.getStatus();
+        if (status.isReady) {
+            emitReadyEvent(client, events, providerName);
+            resolve();
+            return;
+        }
+        if (status.hasTimedout) {
+            reject();
+            return;
+        }
+        client.on(client.Event.SDK_READY_TIMED_OUT, reject);
+        client.on(client.Event.SDK_READY, () => {
+            emitReadyEvent(client, events, providerName);
+            resolve();
+        });
+    });
+}
+export function emitReadyEvent(client, events, providerName = PROVIDER_NAME) {
+    events.emit(ProviderEvents.Ready, buildReadyEventDetails(providerName, undefined, false));
+}

package/es/lib/types.js

@@ -0,0 +1,4 @@
+export const CONTROL_TREATMENT = 'control';
+export const CONTROL_VALUE_ERROR_MESSAGE = 'Received the "control" value from Split.';
+export const DEFAULT_TRAFFIC_TYPE = 'user';
+export const PROVIDER_NAME = 'split';

package/lib/lib/client-resolver.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSplitClient = void 0;
+const splitio_1 = require("@splitsoftware/splitio");
+/**
+ * Resolves the Split client from the various supported constructor option shapes.
+ * Supports: API key (string), Split SDK/AsyncSDK (factory), or pre-built splitClient.
+ */
+function getSplitClient(options) {
+    if (typeof options === 'string') {
+        const splitFactory = (0, splitio_1.SplitFactory)({ core: { authorizationKey: options } });
+        return splitFactory.client();
+    }
+    try {
+        return options.client();
+    }
+    catch {
+        return options.splitClient;
+    }
+}
+exports.getSplitClient = getSplitClient;

package/lib/lib/context.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformContext = void 0;
+const types_1 = require("./types");
+/**
+ * Transforms OpenFeature evaluation context into the consumer shape used by the Split API:
+ * targeting key, traffic type (with default), and remaining attributes.
+ */
+function transformContext(context, defaultTrafficType = types_1.DEFAULT_TRAFFIC_TYPE) {
+    const { targetingKey, trafficType: ttVal, ...attributes } = context;
+    const trafficType = ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
+        ? ttVal
+        : defaultTrafficType;
+    return {
+        targetingKey,
+        trafficType,
+        attributes: JSON.parse(JSON.stringify(attributes)),
+    };
+}
+exports.transformContext = transformContext;

package/lib/lib/js-split-provider.js

@@ -2,49 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenFeatureSplitProvider = void 0;
 const server_sdk_1 = require("@openfeature/server-sdk");
-const splitio_1 = require("@splitsoftware/splitio");
-const CONTROL_VALUE_ERROR_MESSAGE = 'Received the "control" value from Split.';
-const CONTROL_TREATMENT = 'control';
+const client_resolver_1 = require("./client-resolver");
+const context_1 = require("./context");
+const parsers_1 = require("./parsers");
+const readiness_1 = require("./readiness");
+const types_1 = require("./types");
 class OpenFeatureSplitProvider {
-    getSplitClient(options) {
-        if (typeof (options) === 'string') {
-            const splitFactory = (0, splitio_1.SplitFactory)({ core: { authorizationKey: options } });
-            return splitFactory.client();
-        }
-        let splitClient;
-        try {
-            splitClient = options.client();
-        }
-        catch {
-            splitClient = options.splitClient;
-        }
-        return splitClient;
-    }
     constructor(options) {
         this.metadata = {
-            name: 'split',
+            name: types_1.PROVIDER_NAME,
         };
+        this.runsOn = 'server';
         this.events = new server_sdk_1.OpenFeatureEventEmitter();
-        this.client = this.getSplitClient(options);
-        this.client.on(this.client.Event.SDK_UPDATE, () => {
-            this.events.emit(server_sdk_1.ProviderEvents.ConfigurationChanged);
-        });
-        this.initialized = new Promise((resolve) => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (this.client.__getStatus().isReady) {
-                console.log(`${this.metadata.name} provider initialized`);
-                resolve();
-            }
-            else {
-                this.client.on(this.client.Event.SDK_READY, () => {
-                    console.log(`${this.metadata.name} provider initialized`);
-                    resolve();
-                });
-            }
+        this.trafficType = types_1.DEFAULT_TRAFFIC_TYPE;
+        this.client = (0, client_resolver_1.getSplitClient)(options);
+        (0, readiness_1.attachReadyEventHandlers)(this.client, this.events, this.metadata.name);
+        this.client.on(this.client.Event.SDK_UPDATE, (updateMetadata) => {
+            const eventDetails = {
+                providerName: this.metadata.name,
+                ...(updateMetadata
+                    ? {
+                        metadata: { type: updateMetadata.type },
+                        flagsChanged: updateMetadata.names || [],
+                    }
+                    : {}),
+            };
+            this.events.emit(server_sdk_1.ProviderEvents.ConfigurationChanged, eventDetails);
         });
     }
-    async resolveBooleanEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
+    /**
+     * Called by the SDK after the provider is set. Waits for the Split client to be ready.
+     * When this promise resolves, the SDK emits ProviderEvents.Ready.
+     */
+    async initialize(_context) {
+        void _context;
+        await (0, readiness_1.waitUntilReady)(this.client, this.events, this.metadata.name);
+    }
+    async resolveBooleanEvaluation(flagKey, _, context, logger) {
+        void logger;
+        const details = await this.evaluateTreatment(flagKey, (0, context_1.transformContext)(context, this.trafficType));
         const treatment = details.value.toLowerCase();
         if (treatment === 'on' || treatment === 'true') {
             return { ...details, value: true };
@@ -54,54 +50,48 @@ class OpenFeatureSplitProvider {
         }
         throw new server_sdk_1.ParseError(`Invalid boolean value for ${treatment}`);
     }
-    async resolveStringEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
-        return details;
+    async resolveStringEvaluation(flagKey, _, context, logger) {
+        void logger;
+        return this.evaluateTreatment(flagKey, (0, context_1.transformContext)(context, this.trafficType));
     }
-    async resolveNumberEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
-        return { ...details, value: this.parseValidNumber(details.value) };
+    async resolveNumberEvaluation(flagKey, _, context, logger) {
+        void logger;
+        const details = await this.evaluateTreatment(flagKey, (0, context_1.transformContext)(context, this.trafficType));
+        return { ...details, value: (0, parsers_1.parseValidNumber)(details.value) };
     }
-    async resolveObjectEvaluation(flagKey, _, context) {
-        const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
-        return { ...details, value: this.parseValidJsonObject(details.value) };
+    async resolveObjectEvaluation(flagKey, _, context, logger) {
+        void logger;
+        const details = await this.evaluateTreatment(flagKey, (0, context_1.transformContext)(context, this.trafficType));
+        return { ...details, value: (0, parsers_1.parseValidJsonObject)(details.value) };
     }
     async evaluateTreatment(flagKey, consumer) {
-        if (!consumer.key) {
+        if (!consumer.targetingKey) {
             throw new server_sdk_1.TargetingKeyMissingError('The Split provider requires a targeting key.');
         }
         if (flagKey == null || flagKey === '') {
             throw new server_sdk_1.FlagNotFoundError('flagKey must be a non-empty string');
         }
-        await this.initialized;
-        const { treatment: value, config } = await this.client.getTreatmentWithConfig(consumer.key, flagKey, consumer.attributes);
-        if (value === CONTROL_TREATMENT) {
-            throw new server_sdk_1.FlagNotFoundError(CONTROL_VALUE_ERROR_MESSAGE);
+        await (0, readiness_1.waitUntilReady)(this.client, this.events, this.metadata.name);
+        const { treatment: value, config } = await this.client.getTreatmentWithConfig(consumer.targetingKey, flagKey, consumer.attributes);
+        if (value === types_1.CONTROL_TREATMENT) {
+            throw new server_sdk_1.FlagNotFoundError(types_1.CONTROL_VALUE_ERROR_MESSAGE);
         }
-        const flagMetadata = { config: config ? config : '' };
-        const details = {
-            value: value,
+        const flagMetadata = Object.freeze({ config: config ?? '' });
+        return {
+            value,
             variant: value,
-            flagMetadata: flagMetadata,
+            flagMetadata,
             reason: server_sdk_1.StandardResolutionReasons.TARGETING_MATCH,
         };
-        return details;
     }
     async track(trackingEventName, context, details) {
-        // targetingKey is always required
-        const { targetingKey } = context;
-        if (targetingKey == null || targetingKey === '')
-            throw new server_sdk_1.TargetingKeyMissingError('Missing targetingKey, required to track');
-        // eventName is always required
-        if (trackingEventName == null || trackingEventName === '')
+        if (trackingEventName == null || trackingEventName === '') {
             throw new server_sdk_1.ParseError('Missing eventName, required to track');
-        // trafficType is always required
-        const ttVal = context['trafficType'];
-        const trafficType = ttVal != null && typeof ttVal === 'string' && ttVal.trim() !== ''
-            ? ttVal
-            : null;
-        if (trafficType == null || trafficType === '')
-            throw new server_sdk_1.InvalidContextError('Missing trafficType variable, required to track');
+        }
+        const { targetingKey, trafficType } = (0, context_1.transformContext)(context, this.trafficType);
+        if (targetingKey == null || targetingKey === '') {
+            throw new server_sdk_1.TargetingKeyMissingError('Missing targetingKey, required to track');
+        }
         let value;
         let properties = {};
         if (details != null) {
@@ -117,40 +107,5 @@ class OpenFeatureSplitProvider {
     async onClose() {
         return this.client.destroy();
     }
-    //Transform the context into an object useful for the Split API, an key string with arbitrary Split 'Attributes'.
-    transformContext(context) {
-        const { targetingKey, ...attributes } = context;
-        return {
-            key: targetingKey,
-            // Stringify context objects include date.
-            attributes: JSON.parse(JSON.stringify(attributes)),
-        };
-    }
-    parseValidNumber(stringValue) {
-        if (stringValue === undefined) {
-            throw new server_sdk_1.ParseError(`Invalid 'undefined' value.`);
-        }
-        const result = Number.parseFloat(stringValue);
-        if (Number.isNaN(result)) {
-            throw new server_sdk_1.ParseError(`Invalid numeric value ${stringValue}`);
-        }
-        return result;
-    }
-    parseValidJsonObject(stringValue) {
-        if (stringValue === undefined) {
-            throw new server_sdk_1.ParseError(`Invalid 'undefined' JSON value.`);
-        }
-        // we may want to allow the parsing to be customized.
-        try {
-            const value = JSON.parse(stringValue);
-            if (typeof value !== 'object') {
-                throw new server_sdk_1.ParseError(`Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`);
-            }
-            return value;
-        }
-        catch (err) {
-            throw new server_sdk_1.ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
-        }
-    }
 }
 exports.OpenFeatureSplitProvider = OpenFeatureSplitProvider;