@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/esm/readiness/sdkReadinessManager.js

@@ -1,100 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { promiseWrapper } from '../utils/promise/wrapper';
-import { readinessManagerFactory } from './readinessManager';
-import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
-var NEW_LISTENER_EVENT = 'newListener';
-var REMOVE_LISTENER_EVENT = 'removeListener';
-/**
- * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
- * It also updates logs related warnings and errors.
- *
- * @param readyTimeout - time in millis to emit SDK_READY_TIME_OUT event
- * @param readinessManager - optional readinessManager to use. only used internally for `shared` method
- */
-export function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
-    if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, settings); }
-    var log = settings.log;
-    /** Ready callback warning */
-    var internalReadyCbCount = 0;
-    var readyCbCount = 0;
-    readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {
-        if (event === SDK_READY)
-            readyCbCount--;
-    });
-    readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {
-        if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
-            if (readinessManager.isReady()) {
-                log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
-            }
-            else if (event === SDK_READY) {
-                readyCbCount++;
-            }
-        }
-    });
-    /** Ready promise */
-    var readyPromise = generateReadyPromise();
-    readinessManager.gate.once(SDK_READY_FROM_CACHE, function () {
-        log.info(CLIENT_READY_FROM_CACHE);
-    });
-    // default onRejected handler, that just logs the error, if ready promise doesn't have one.
-    function defaultOnRejected(err) {
-        log.error(err && err.message);
-    }
-    function generateReadyPromise() {
-        var promise = promiseWrapper(new Promise(function (resolve, reject) {
-            readinessManager.gate.once(SDK_READY, function () {
-                log.info(CLIENT_READY);
-                if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled())
-                    log.warn(CLIENT_NO_LISTENER);
-                resolve();
-            });
-            readinessManager.gate.once(SDK_READY_TIMED_OUT, function (message) {
-                reject(new Error(message));
-            });
-        }), defaultOnRejected);
-        return promise;
-    }
-    return {
-        readinessManager: readinessManager,
-        shared: function () {
-            return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
-        },
-        incInternalReadyCbCount: function () {
-            internalReadyCbCount++;
-        },
-        sdkStatus: objectAssign(
-        // Expose Event Emitter functionality
-        Object.create(readinessManager.gate), {
-            // Expose the event constants without changing the interface
-            Event: {
-                SDK_READY: SDK_READY,
-                SDK_READY_FROM_CACHE: SDK_READY_FROM_CACHE,
-                SDK_UPDATE: SDK_UPDATE,
-                SDK_READY_TIMED_OUT: SDK_READY_TIMED_OUT,
-            },
-            ready: function () {
-                if (readinessManager.hasTimedout()) {
-                    if (!readinessManager.isReady()) {
-                        return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
-                    }
-                    else {
-                        return Promise.resolve();
-                    }
-                }
-                return readyPromise;
-            },
-            __getStatus: function () {
-                return {
-                    isReady: readinessManager.isReady(),
-                    isReadyFromCache: readinessManager.isReadyFromCache(),
-                    isTimedout: readinessManager.isTimedout(),
-                    hasTimedout: readinessManager.hasTimedout(),
-                    isDestroyed: readinessManager.isDestroyed(),
-                    isOperational: readinessManager.isOperational(),
-                    lastUpdate: readinessManager.lastUpdate(),
-                };
-            },
-        })
-    };
-}

package/esm/readiness/types.js

@@ -1 +0,0 @@
-export {};

package/esm/sdkClient/client.js

@@ -1,179 +0,0 @@
-import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
-import { thenable } from '../utils/promise/thenable';
-import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
-import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
-import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
-import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-var treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
-function treatmentsNotReady(featureFlagNames) {
-    var evaluations = {};
-    featureFlagNames.forEach(function (featureFlagName) {
-        evaluations[featureFlagName] = treatmentNotReady;
-    });
-    return evaluations;
-}
-function stringify(options) {
-    if (options && options.properties) {
-        try {
-            return JSON.stringify(options.properties);
-        }
-        catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
-    }
-}
-/**
- * Creator of base client with getTreatments and track methods.
- */
-export function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;
-    var log = settings.log, mode = settings.mode;
-    var isAsync = isConsumerMode(mode);
-    function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
-        if (withConfig === void 0) { withConfig = false; }
-        if (methodName === void 0) { methodName = GET_TREATMENT; }
-        var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
-        var wrapUp = function (evaluationResult) {
-            var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
-            impressionsTracker.track(queue, attributes);
-            stopTelemetryTracker(queue[0] && queue[0].imp.label);
-            return treatment;
-        };
-        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-            evaluateFeature(log, key, featureFlagName, attributes, storage) :
-            isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-                Promise.resolve(treatmentNotReady) :
-                treatmentNotReady;
-        return thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
-    }
-    function getTreatmentWithConfig(key, featureFlagName, attributes, options) {
-        return getTreatment(key, featureFlagName, attributes, options, true, GET_TREATMENT_WITH_CONFIG);
-    }
-    function getTreatments(key, featureFlagNames, attributes, options, withConfig, methodName) {
-        if (withConfig === void 0) { withConfig = false; }
-        if (methodName === void 0) { methodName = GET_TREATMENTS; }
-        var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
-        var wrapUp = function (evaluationResults) {
-            var queue = [];
-            var treatments = {};
-            var properties = stringify(options);
-            Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
-            });
-            impressionsTracker.track(queue, attributes);
-            stopTelemetryTracker(queue[0] && queue[0].imp.label);
-            return treatments;
-        };
-        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-            evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
-            isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-                Promise.resolve(treatmentsNotReady(featureFlagNames)) :
-                treatmentsNotReady(featureFlagNames);
-        return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
-    }
-    function getTreatmentsWithConfig(key, featureFlagNames, attributes, options) {
-        return getTreatments(key, featureFlagNames, attributes, options, true, GET_TREATMENTS_WITH_CONFIG);
-    }
-    function getTreatmentsByFlagSets(key, flagSetNames, attributes, options, withConfig, method, methodName) {
-        if (withConfig === void 0) { withConfig = false; }
-        if (method === void 0) { method = TREATMENTS_BY_FLAGSETS; }
-        if (methodName === void 0) { methodName = GET_TREATMENTS_BY_FLAG_SETS; }
-        var stopTelemetryTracker = telemetryTracker.trackEval(method);
-        var wrapUp = function (evaluationResults) {
-            var queue = [];
-            var treatments = {};
-            var properties = stringify(options);
-            Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
-            });
-            impressionsTracker.track(queue, attributes);
-            stopTelemetryTracker(queue[0] && queue[0].imp.label);
-            return treatments;
-        };
-        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-            evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
-            isAsync ?
-                Promise.resolve({}) :
-                {};
-        return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
-    }
-    function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes, options) {
-        return getTreatmentsByFlagSets(key, flagSetNames, attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
-    }
-    function getTreatmentsByFlagSet(key, flagSetName, attributes, options) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
-    }
-    function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes, options) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
-    }
-    // Internal function
-    function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
-        var matchingKey = getMatching(key);
-        var bucketingKey = getBucketing(key);
-        var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a, impressionsDisabled = evaluation.impressionsDisabled;
-        log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-        if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-            log.info(IMPRESSION_QUEUEING);
-            queue.push({
-                imp: {
-                    feature: featureFlagName,
-                    keyName: matchingKey,
-                    treatment: treatment,
-                    time: Date.now(),
-                    bucketingKey: bucketingKey,
-                    label: label,
-                    changeNumber: changeNumber,
-                    properties: properties
-                },
-                disabled: impressionsDisabled
-            });
-        }
-        if (withConfig) {
-            return {
-                treatment: treatment,
-                config: config
-            };
-        }
-        return treatment;
-    }
-    function track(key, trafficTypeName, eventTypeId, value, properties, size) {
-        if (size === void 0) { size = 1024; }
-        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
-        var matchingKey = getMatching(key);
-        var timestamp = Date.now();
-        var eventData = {
-            eventTypeId: eventTypeId,
-            trafficTypeName: trafficTypeName,
-            value: value,
-            timestamp: timestamp,
-            key: matchingKey,
-            properties: properties
-        };
-        // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-        validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
-        var result = eventTracker.track(eventData, size);
-        if (thenable(result)) {
-            return result.then(function (result) {
-                stopTelemetryTracker();
-                return result;
-            });
-        }
-        else {
-            stopTelemetryTracker();
-            return result;
-        }
-    }
-    return {
-        getTreatment: getTreatment,
-        getTreatmentWithConfig: getTreatmentWithConfig,
-        getTreatments: getTreatments,
-        getTreatmentsWithConfig: getTreatmentsWithConfig,
-        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
-        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
-        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
-        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: track,
-    };
-}

package/esm/sdkClient/clientAttributesDecoration.js

@@ -1,118 +0,0 @@
-import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
-import { validateAttributesDeep } from '../utils/inputValidation/attributes';
-import { objectAssign } from '../utils/lang/objectAssign';
-/**
- * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
- */
-export function clientAttributesDecoration(log, client) {
-    var attributeStorage = new AttributesCacheInMemory();
-    // Keep a reference to the original methods
-    var clientGetTreatment = client.getTreatment;
-    var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-    var clientGetTreatments = client.getTreatments;
-    var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-    var clientGetTreatmentsByFlagSets = client.getTreatmentsByFlagSets;
-    var clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
-    var clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
-    var clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
-    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
-        return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
-        return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
-        return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
-        return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
-        return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
-        return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
-        return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
-        return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
-    }
-    function combineAttributes(maybeAttributes) {
-        var storedAttributes = attributeStorage.getAll();
-        return Object.keys(storedAttributes).length > 0 ?
-            objectAssign({}, storedAttributes, maybeAttributes) :
-            maybeAttributes;
-    }
-    return objectAssign(client, {
-        getTreatment: getTreatment,
-        getTreatmentWithConfig: getTreatmentWithConfig,
-        getTreatments: getTreatments,
-        getTreatmentsWithConfig: getTreatmentsWithConfig,
-        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
-        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
-        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
-        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        /**
-         * Add an attribute to client's in memory attributes storage
-         *
-         * @param attributeName - Attribute name
-         * @param attributeValue - Attribute value
-         * @returns true if the attribute was stored and false otherways
-         */
-        setAttribute: function (attributeName, attributeValue) {
-            var attribute = {};
-            attribute[attributeName] = attributeValue;
-            if (!validateAttributesDeep(log, attribute, 'setAttribute'))
-                return false;
-            log.debug("stored " + attributeValue + " for attribute " + attributeName);
-            return attributeStorage.setAttribute(attributeName, attributeValue);
-        },
-        /**
-         * Returns the attribute with the given name
-         *
-         * @param attributeName - Attribute name
-         * @returns Attribute with the given name
-         */
-        getAttribute: function (attributeName) {
-            log.debug("retrieved attribute " + attributeName);
-            return attributeStorage.getAttribute(attributeName + '');
-        },
-        /**
-         * Add to client's in memory attributes storage the attributes in 'attributes'
-         *
-         * @param attributes - Object with attributes to store
-         * @returns true if attributes were stored an false otherways
-         */
-        setAttributes: function (attributes) {
-            if (!validateAttributesDeep(log, attributes, 'setAttributes'))
-                return false;
-            return attributeStorage.setAttributes(attributes);
-        },
-        /**
-         * Return all the attributes stored in client's in memory attributes storage
-         *
-         * @returns returns all the stored attributes
-         */
-        getAttributes: function () {
-            return attributeStorage.getAll();
-        },
-        /**
-         * Removes from client's in memory attributes storage the attribute with the given name
-         *
-         * @param attributeName - Attribute name
-         * @returns true if attribute was removed and false otherways
-         */
-        removeAttribute: function (attributeName) {
-            log.debug("removed attribute " + attributeName);
-            return attributeStorage.removeAttribute(attributeName + '');
-        },
-        /**
-         * Remove all the stored attributes in the client's in memory attribute storage
-         */
-        clearAttributes: function () {
-            return attributeStorage.clear();
-        }
-    });
-}

package/esm/sdkClient/clientCS.js

@@ -1,26 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { clientAttributesDecoration } from './clientAttributesDecoration';
-/**
- * Decorator that binds a key to client methods
- *
- * @param client - sync client instance
- * @param key - validated split key
- */
-export function clientCSDecorator(log, client, key) {
-    var clientCS = clientAttributesDecoration(log, client);
-    return objectAssign(clientCS, {
-        // In the client-side API, we bind a key to the client `getTreatment*` and `track` methods
-        getTreatment: clientCS.getTreatment.bind(clientCS, key),
-        getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
-        getTreatments: clientCS.getTreatments.bind(clientCS, key),
-        getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
-        getTreatmentsByFlagSets: clientCS.getTreatmentsByFlagSets.bind(clientCS, key),
-        getTreatmentsWithConfigByFlagSets: clientCS.getTreatmentsWithConfigByFlagSets.bind(clientCS, key),
-        getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
-        getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
-        track: clientCS.track.bind(clientCS, key),
-        // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
-        isClientSide: true,
-        key: key
-    });
-}

package/esm/sdkClient/clientInputValidation.js

@@ -1,143 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational, validateEvaluationOptions } from '../utils/inputValidation';
-import { startsWith } from '../utils/lang';
-import { CONTROL, CONTROL_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
-import { isConsumerMode } from '../utils/settingsValidation/mode';
-import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
-/**
- * Decorator that validates the input before actually executing the client methods.
- * We should "guard" the client here, while not polluting the "real" implementation of those methods.
- */
-export function clientInputValidationDecorator(settings, client, readinessManager) {
-    var log = settings.log, mode = settings.mode;
-    var isAsync = isConsumerMode(mode);
-    /**
-     * Avoid repeating this validations code
-     */
-    function validateEvaluationParams(methodName, maybeKey, maybeNameOrNames, maybeAttributes, maybeOptions) {
-        var key = validateKey(log, maybeKey, methodName);
-        var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
-            validateFlagSets(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
-            startsWith(methodName, GET_TREATMENTS) ?
-                validateSplits(log, maybeNameOrNames, methodName) :
-                validateSplit(log, maybeNameOrNames, methodName);
-        var attributes = validateAttributes(log, maybeAttributes, methodName);
-        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
-        var options = validateEvaluationOptions(log, maybeOptions, methodName);
-        validateIfOperational(log, readinessManager, methodName, nameOrNames);
-        var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
-        return {
-            valid: valid,
-            key: key,
-            nameOrNames: nameOrNames,
-            attributes: attributes,
-            options: options
-        };
-    }
-    function wrapResult(value) {
-        return isAsync ? Promise.resolve(value) : value;
-    }
-    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult(CONTROL);
-        }
-    }
-    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
-        }
-    }
-    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var res_1 = {};
-            if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_1[split] = CONTROL; });
-            return wrapResult(res_1);
-        }
-    }
-    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var res_2 = {};
-            if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_2[split] = objectAssign({}, CONTROL_WITH_CONFIG); });
-            return wrapResult(res_2);
-        }
-    }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
-        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-        var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
-        var tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
-        var event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
-        var eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
-        var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
-        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
-        if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-            return client.track(key, tt, event, eventValue, properties, size);
-        }
-        else {
-            return isAsync ? Promise.resolve(false) : false;
-        }
-    }
-    return {
-        getTreatment: getTreatment,
-        getTreatmentWithConfig: getTreatmentWithConfig,
-        getTreatments: getTreatments,
-        getTreatmentsWithConfig: getTreatmentsWithConfig,
-        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
-        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
-        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
-        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: track
-    };
-}

package/esm/sdkClient/identity.js

@@ -1,3 +0,0 @@
-export function buildInstanceId(key, trafficType) {
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType ? trafficType : '');
-}

package/esm/sdkClient/sdkClient.js

@@ -1,60 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { releaseApiKey } from '../utils/inputValidation/apiKey';
-import { clientFactory } from './client';
-import { clientInputValidationDecorator } from './clientInputValidation';
-var COOLDOWN_TIME_IN_MILLIS = 1000;
-/**
- * Creates an Sdk client, i.e., a base client with status and destroy interface
- */
-export function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
-    var lastActionTime = 0;
-    function __cooldown(func, time) {
-        var now = Date.now();
-        //get the actual time elapsed in ms
-        var timeElapsed = now - lastActionTime;
-        //check if the time elapsed is less than desired cooldown
-        if (timeElapsed < time) {
-            //if yes, return message with remaining time in seconds
-            settings.log.warn("Flush cooldown, remaining time " + (time - timeElapsed) / 1000 + " seconds");
-            return Promise.resolve();
-        }
-        else {
-            //Do the requested action and re-assign the lastActionTime
-            lastActionTime = now;
-            return func();
-        }
-    }
-    function __flush() {
-        return syncManager ? syncManager.flush() : Promise.resolve();
-    }
-    return objectAssign(
-    // Proto-linkage of the readiness Event Emitter
-    Object.create(sdkReadinessManager.sdkStatus), 
-    // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), 
-    // Sdk destroy
-    {
-        flush: function () {
-            // @TODO define cooldown time
-            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
-        },
-        destroy: function () {
-            // Mark the SDK as destroyed immediately
-            sdkReadinessManager.readinessManager.destroy();
-            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
-            if (!isSharedClient) {
-                releaseApiKey(settings.core.authorizationKey);
-                telemetryTracker.sessionLength();
-                signalListener && signalListener.stop();
-                uniqueKeysTracker.stop();
-            }
-            // Stop background jobs
-            syncManager && syncManager.stop();
-            return __flush().then(function () {
-                // Cleanup storage
-                return storage.destroy();
-            });
-        }
-    });
-}

package/esm/sdkClient/sdkClientMethod.js

@@ -1,18 +0,0 @@
-import { sdkClientFactory } from './sdkClient';
-import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
-/**
- * Factory of client method for server-side SDKs
- */
-export function sdkClientMethodFactory(params) {
-    var log = params.settings.log;
-    var clientInstance = sdkClientFactory(params);
-    // Only one client in server-side without bound key
-    params.clients[''] = clientInstance;
-    return function client() {
-        if (arguments.length > 0) {
-            throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');
-        }
-        log.debug(RETRIEVE_CLIENT_DEFAULT);
-        return clientInstance;
-    };
-}