@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/src/utils/inputValidation/definitionExistence.ts

@@ -0,0 +1,19 @@
+import { FALLBACK_DEFINITION_NOT_FOUND, DEFINITION_NOT_FOUND } from '../labels';
+import { IReadinessManager } from '../../readiness/types';
+import { ILogger } from '../../logger/types';
+import { WARN_NOT_EXISTENT_DEFINITION } from '../../logger/constants';
+
+/**
+ * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a definition twice.
+ */
+export function validateDefinitionExistence(log: ILogger, readinessManager: IReadinessManager, definitionName: string, labelOrDefinitionObj: any, method: string): boolean {
+  if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
+    if (labelOrDefinitionObj === DEFINITION_NOT_FOUND || labelOrDefinitionObj === FALLBACK_DEFINITION_NOT_FOUND || labelOrDefinitionObj == null) {
+      log.warn(WARN_NOT_EXISTENT_DEFINITION, [method, definitionName]);
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/utils/inputValidation/definitions.ts

@@ -0,0 +1,21 @@
+import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
+import { uniq } from '../lang';
+import { validateDefinition } from './definition';
+
+export function validateDefinitions(log: ILogger, maybeDefinitions: any, method: string, listName = 'feature flag names', item = 'feature flag name'): string[] | false {
+  if (Array.isArray(maybeDefinitions) && maybeDefinitions.length > 0) {
+    let validatedArray: string[] = [];
+    // Remove invalid values
+    maybeDefinitions.forEach(maybeDefinition => {
+      const definitionName = validateDefinition(log, maybeDefinition, method, item);
+      if (definitionName) validatedArray.push(definitionName);
+    });
+
+    // Strip off duplicated values if we have valid definition names then return
+    if (validatedArray.length) return uniq(validatedArray);
+  }
+
+  log.error(ERROR_EMPTY_ARRAY, [method, listName]);
+  return false;
+}

package/src/utils/inputValidation/index.ts

@@ -4,10 +4,10 @@ export { validateEvent } from './event';
 export { validateEventValue } from './eventValue';
 export { validateEventProperties } from './eventProperties';
 export { validateKey } from './key';
-export { validateSplit } from './split';
-export { validateSplits } from './splits';
+export { validateDefinition } from './definition';
+export { validateDefinitions } from './definitions';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfReadyFromCache, validateIfOperational } from './isOperational';
-export { validateSplitExistence } from './splitExistence';
+export { validateDefinitionExistence } from './definitionExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validateEvaluationOptions } from './eventProperties';

package/src/utils/inputValidation/isOperational.ts

@@ -9,14 +9,14 @@ export function validateIfNotDestroyed(log: ILogger, readinessManager: IReadines
   return false;
 }
 
-export function validateIfReadyFromCache(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
+export function validateIfReadyFromCache(log: ILogger, readinessManager: IReadinessManager, method: string) {
   if (readinessManager.isReadyFromCache()) return true;
 
-  log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? ` for feature flag ${featureFlagNameOrNames.toString()}` : '']);
+  log.warn(CLIENT_NOT_READY_FROM_CACHE, [method]);
   return false;
 }
 
 // Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
-export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string, featureFlagNameOrNames?: string | string[] | false) {
-  return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+export function validateIfOperational(log: ILogger, readinessManager: IReadinessManager, method: string) {
+  return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method);
 }

package/src/utils/inputValidation/target.ts

@@ -0,0 +1,21 @@
+import { isObject } from '../lang';
+import SplitIO from '../../../types/splitio';
+import { ILogger } from '../../logger/types';
+import { validateKey } from './key';
+import { validateAttributes } from './attributes';
+import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
+
+export function validateTarget(log: ILogger, maybeTarget: any, method: string): SplitIO.Target | false {
+  if (!isObject(maybeTarget)) {
+    log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'target']);
+    return false;
+  }
+
+  const key = validateKey(log, maybeTarget.key, method);
+  if (key === false) return false;
+
+  const attributes = validateAttributes(log, maybeTarget.attributes, method);
+  if (attributes === false) return false;
+
+  return { ...maybeTarget, key, attributes };
+}

package/src/utils/inputValidation/trafficTypeExistence.ts

@@ -1,6 +1,6 @@
 import { thenable } from '../promise/thenable';
 import { LOCALHOST_MODE } from '../constants';
-import { ISplitsCacheBase } from '../../storages/types';
+import { IDefinitionsCacheBase } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import SplitIO from '../../../types/splitio';
 import { MaybeThenable } from '../../dtos/types';
@@ -14,7 +14,7 @@ function logTTExistenceWarning(log: ILogger, maybeTT: string, method: string) {
 /**
  * Separated from the previous method since on some cases it'll be async.
  */
-export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
+export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: IDefinitionsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
 
   // If not ready or in localhost mode, we won't run the validation
   if (!readinessManager.isReady() || mode === LOCALHOST_MODE) return true;

package/src/utils/jwt/types.ts

@@ -1,6 +1,6 @@
 export interface IDecodedJWTToken {
   ['x-ably-capability']: string
-  exp: number
+  exp: number // epoch seconds
   iat: number
 
   /** Unused fields: */

package/src/utils/labels/index.ts

@@ -2,11 +2,11 @@ import { FALLBACK_PREFIX } from '../../evaluator/fallbackTreatmentsCalculator';
 
 export const SPLIT_KILLED = 'killed';
 export const NO_CONDITION_MATCH = 'default rule';
-export const SPLIT_NOT_FOUND = 'definition not found';
+export const DEFINITION_NOT_FOUND = 'definition not found';
 export const SDK_NOT_READY = 'not ready';
 export const EXCEPTION = 'exception';
 export const SPLIT_ARCHIVED = 'archived';
 export const NOT_IN_SPLIT = 'not in split';
 export const UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 export const PREREQUISITES_NOT_MET = 'prerequisites not met';
-export const FALLBACK_SPLIT_NOT_FOUND = FALLBACK_PREFIX + SPLIT_NOT_FOUND;
+export const FALLBACK_DEFINITION_NOT_FOUND = FALLBACK_PREFIX + DEFINITION_NOT_FOUND;

package/src/utils/lang/sets.ts

@@ -12,6 +12,8 @@ export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
   return new Set(setToArray(set).concat(setToArray(set2)));
 }
 
-export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
-  return list.filter(item => list2.indexOf(item) === -1);
+export function returnDifference<T>(list1?: T[] | null, list2?: T[] | null): T[] {
+  list1 = list1 || [];
+  list2 = list2 || [];
+  return list1.filter(item => list2!.indexOf(item) === -1);
 }

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,4 +1,4 @@
-import { validateSplits } from '../inputValidation/splits';
+import { validateDefinitions } from '../inputValidation/definitions';
 import { ISplitFiltersValidation } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
@@ -49,7 +49,7 @@ function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.Sp
  */
 function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) {
   // validate and remove invalid and duplicated values
-  let result = validateSplits(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
+  let result = validateDefinitions(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
 
   if (result) {
 
@@ -181,7 +181,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
 }
 
 export function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] | false {
-  const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
+  const sets = validateDefinitions(log, flagSets, method, 'flag sets', 'flag set');
   let toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
   if (flagSetsInConfig.length > 0) {
     toReturn = toReturn.filter(flagSet => {

package/src/utils/settingsValidation/url.ts

@@ -2,7 +2,7 @@ import { ISettings } from '../../types';
 
 const telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-const authEndpointMatcher = /^\/v2\/auth/;
+const authEndpointMatcher = /^\/(v2|v3)\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;
 
 /**

package/types/splitio.d.ts

@@ -73,10 +73,12 @@ interface ISharedSettings {
        * const factory = SplitFactory({
        *   ...
        *   sync: {
-       *     getHeaderOverrides: (context) => {
-       *       return {
-       *         'Authorization': context.headers['Authorization'] + ', other-value',
-       *         'custom-header': 'custom-value'
+       *     requestOptions: {
+       *       getHeaderOverrides: (context) => {
+       *         return {
+       *           'Authorization': context.headers['Authorization'] + ', other-value',
+       *           'custom-header': 'custom-value'
+       *         };
        *       };
        *     }
        *   }
@@ -493,7 +495,7 @@ declare namespace SplitIO {
   }
 
   /**
-   * Metadata for the update event emitted when the SDK cache is updated with new data for flags or segments.
+   * Metadata for the update event emitted when the SDK cache is updated with new data for flags, configs, or segments.
    */
   type SdkUpdateMetadata = {
     /**
@@ -501,7 +503,7 @@ declare namespace SplitIO {
      */
     type: SdkUpdateMetadataType;
     /**
-     * The names of the flags or segments that were updated.
+     * The names of the flags or configs that were updated. Empty array if the update is of type 'SEGMENTS_UPDATE'.
      */
     names: string[];
   }
@@ -509,7 +511,7 @@ declare namespace SplitIO {
   /**
    * Metadata type for SDK update events.
    */
-  type SdkUpdateMetadataType = 'FLAGS_UPDATE' | 'SEGMENTS_UPDATE';
+  type SdkUpdateMetadataType = 'CONFIGS_UPDATE' | 'FLAGS_UPDATE' | 'SEGMENTS_UPDATE';
 
   /**
    * Metadata for the ready events emitted when the SDK is ready to evaluate feature flags.
@@ -1590,10 +1592,12 @@ declare namespace SplitIO {
          * const factory = SplitFactory({
          *   ...
          *   sync: {
-         *     getHeaderOverrides: (context) => {
-         *       return {
-         *         'Authorization': context.headers['Authorization'] + ', other-value',
-         *         'custom-header': 'custom-value'
+         *     requestOptions: {
+         *       getHeaderOverrides: (context) => {
+         *         return {
+         *           'Authorization': context.headers['Authorization'] + ', other-value',
+         *           'custom-header': 'custom-value'
+         *         };
          *       };
          *     }
          *   }
@@ -2284,4 +2288,211 @@ declare namespace SplitIO {
      */
     split(featureFlagName: string): SplitViewAsync;
   }
+
+  /**
+   * Fallback configuration objects returned by the `client.getConfig` method when the SDK is not ready or the provided config name is not found.
+   */
+  type FallbackConfigs = {
+    /**
+     * Fallback config for all config names.
+     */
+    global?: Config;
+    /**
+     * Fallback configs for specific config names. It takes precedence over the global fallback config.
+     */
+    byName?: {
+      [configName: string]: Config;
+    };
+  }
+
+  /**
+   * Configs SDK settings.
+   */
+  interface ConfigsClientSettings {
+    /**
+     * Your SDK key.
+     *
+     * @see {@link https://developer.harness.io/docs/feature-management-experimentation/management-and-administration/account-settings/api-keys/}
+     */
+    authorizationKey: string;
+    /**
+     * Polling rate for configs and segments refresh, in seconds. Minimum value: 5.
+     *
+     * @defaultValue `60`
+     */
+    pollingRate?: number;
+    /**
+     * Push rate for events and impressions, in seconds. Minimum value: 60.
+     *
+     * @defaultValue `60`
+     */
+    pushRate?: number;
+    /**
+     * Maximum queue size for events and impressions. When the queue reaches this size, a flush is triggered. Minimum value: 1000.
+     *
+     * @defaultValue `10000`
+     */
+    queueSize?: number;
+    /**
+     * Logging level.
+     *
+     * @defaultValue `'NONE'`
+     */
+    logLevel?: LogLevel;
+    /**
+     * Time in seconds until SDK ready timeout is emitted.
+     *
+     * @defaultValue `10`
+     */
+    timeout?: number;
+    /**
+     * Custom endpoints to replace the default ones used by the SDK.
+     */
+    urls?: {
+      /**
+       * String property to override the base URL where the SDK will get JWT authentication credentials.
+       *
+       * @defaultValue `'https://auth.split.io/api'`
+       */
+      auth?: string;
+      /**
+       * String property to override the base URL where the SDK will get rollout plan related data, like feature flags and segments definitions.
+       *
+       * @defaultValue `'https://appconfig.split.io/api'`
+       */
+      sdk?: string;
+      /**
+       * String property to override the base URL where the SDK will post event-related information like impressions.
+       *
+       * @defaultValue `'https://events.split.io/api'`
+       */
+      events?: string;
+    };
+    /**
+     * Fallback configuration objects returned by the `client.getConfig` method when the SDK is not ready or the provided config name is not found.
+     */
+    fallbackConfigs?: FallbackConfigs;
+    /**
+     * Custom options object for HTTP(S) requests.
+     * If provided, this object is merged with the options object passed by the SDK for EventSource and Fetch calls.
+     */
+    requestOptions?: {
+      /**
+       * Custom function called before each request, allowing you to add or update headers in SDK HTTP requests.
+       * Some headers, such as `SplitSDKVersion`, are required by the SDK and cannot be overridden.
+       * To pass multiple headers with the same name, combine their values into a single line, separated by commas. Example: `{ 'Authorization': 'value1, value2' }`
+       * Or provide keys with different cases since headers are case-insensitive. Example: `{ 'authorization': 'value1', 'Authorization': 'value2' }`
+       *
+       * @defaultValue `undefined`
+       *
+       * @param context - The context for the request, which contains the `headers` property object representing the current headers in the request.
+       * @returns An object representing a set of headers to be merged with the current headers.
+       *
+       * @example
+       * ```
+       * const client = ConfigsClient({
+       *   ...
+       *   requestOptions: {
+       *     getHeaderOverrides: (context) => {
+       *       return {
+       *         'Authorization': context.headers['Authorization'] + ', other-value',
+       *         'custom-header': 'custom-value'
+       *       };
+       *     }
+       *   }
+       * });
+       * ```
+       */
+      getHeaderOverrides?: (context: { headers: Record<string, string>; }) => Record<string, string>;
+      /**
+       * Custom Node.js HTTP(S) Agent used by the SDK for HTTP(S) requests.
+       *
+       * You can use it, for example, for certificate pinning or setting a network proxy:
+       *
+       * ```
+       * const { HttpsProxyAgent } = require('https-proxy-agent');
+       *
+       * const proxyAgent = new HttpsProxyAgent(process.env.HTTPS_PROXY || 'http://10.10.1.10:1080');
+       *
+       * const client = ConfigsClient({
+       *   ...
+       *   requestOptions: {
+       *     agent: proxyAgent
+       *   }
+       * })
+       * ```
+       *
+       * @see {@link https://nodejs.org/api/https.html#class-httpsagent}
+       *
+       * @defaultValue `undefined`
+       */
+      agent?: RequestOptions['agent'];
+    };
+  }
+
+  /**
+   * Target for a config evaluation.
+   */
+  interface Target {
+    /**
+     * The key of the target.
+     */
+    key: SplitKey;
+    /**
+     * The attributes of the target.
+     *
+     * @defaultValue `undefined`
+     */
+    attributes?: Attributes;
+  }
+
+  type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+  type JsonArray = JsonValue[];
+  type JsonObject = { [key: string]: JsonValue; };
+
+  /**
+   * Config object returned by getConfig.
+   */
+  type Config = {
+    /**
+     * The name of the variant.
+     */
+    variant: string;
+    /**
+     * The config value, a raw JSON object.
+     */
+    value: JsonObject;
+  }
+
+  /**
+   * Configs SDK client interface.
+   */
+  interface ConfigsClient extends Omit<IStatusInterface, 'ready'> {
+    /**
+     * Destroys the client.
+     *
+     * @returns A promise that resolves once all clients are destroyed.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Gets the config object for a given config name and optional target. If no target is provided, the default variant of the config is returned.
+     *
+     * @param configName - The name of the config we want to get.
+     * @param target - The target of the config evaluation.
+     * @param options - An object of type EvaluationOptions for advanced evaluation options.
+     * @returns The config object.
+     */
+    getConfig(configName: string, target?: Target, options?: EvaluationOptions): Config;
+    /**
+     * Tracks an event to be fed to the results product on Harness FME user interface.
+     *
+     * @param trafficKey - The key that identifies the entity related to this event.
+     * @param trafficType - The traffic type of the entity related to this event. See {@link https://developer.harness.io/docs/feature-management-experimentation/management-and-administration/fme-settings/traffic-types/}
+     * @param eventType - The event type corresponding to this event.
+     * @param value - The value of this event.
+     * @param properties - The properties of this event. Values can be string, number, boolean or null.
+     * @returns Whether the event was added to the queue successfully or not.
+     */
+    track(trafficKey: SplitKey, trafficType: string, eventType: string, value?: number, properties?: Properties): boolean;
+  }
 }

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSplitsCacheAsync = void 0;
-var objectAssign_1 = require("../utils/lang/objectAssign");
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheAsync = /** @class */ (function () {
-    function AbstractSplitsCacheAsync() {
-    }
-    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
-            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
-        return Promise.resolve(true);
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     * The promise will never be rejected.
-     */
-    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-                var newSplit = (0, objectAssign_1.objectAssign)({}, split);
-                newSplit.killed = true;
-                newSplit.defaultTreatment = defaultTreatment;
-                newSplit.changeNumber = changeNumber;
-                return _this.addSplit(newSplit);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractSplitsCacheAsync;
-}());
-exports.AbstractSplitsCacheAsync = AbstractSplitsCacheAsync;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.usesSegmentsSync = exports.usesSegments = exports.AbstractSplitsCacheSync = void 0;
-var objectAssign_1 = require("../utils/lang/objectAssign");
-var constants_1 = require("../utils/constants");
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheSync = /** @class */ (function () {
-    function AbstractSplitsCacheSync() {
-    }
-    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
-        this.setChangeNumber(changeNumber);
-        return updated;
-    };
-    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
-        var _this = this;
-        var splits = {};
-        names.forEach(function (name) {
-            splits[name] = _this.getSplit(name);
-        });
-        return splits;
-    };
-    AbstractSplitsCacheSync.prototype.getAll = function () {
-        var _this = this;
-        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     */
-    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var split = this.getSplit(name);
-        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-            var newSplit = (0, objectAssign_1.objectAssign)({}, split);
-            newSplit.killed = true;
-            newSplit.defaultTreatment = defaultTreatment;
-            newSplit.changeNumber = changeNumber;
-            return this.addSplit(newSplit);
-        }
-        return false;
-    };
-    return AbstractSplitsCacheSync;
-}());
-exports.AbstractSplitsCacheSync = AbstractSplitsCacheSync;
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-function usesSegments(ruleEntity) {
-    var conditions = ruleEntity.conditions || [];
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
-                return true;
-        }
-    }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
-    return false;
-}
-exports.usesSegments = usesSegments;
-function usesSegmentsSync(storage) {
-    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}
-exports.usesSegmentsSync = usesSegmentsSync;