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

package/esm/utils/settingsValidation/types.js

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

package/esm/utils/settingsValidation/url.js

@@ -1,27 +0,0 @@
-var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
-var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/v2\/auth/;
-var streamingEndpointMatcher = /^\/(sse|event-stream)/;
-/**
- * Get URL based on a given target (path).
- * ATM, it is only used for testing purposes.
- *
- * @param settings - settings object
- * @param target - url path
- * @returns complete url
- */
-export function url(settings, target) {
-    if (telemetryEndpointMatcher.test(target)) {
-        return "" + settings.urls.telemetry + target;
-    }
-    if (eventsEndpointMatcher.test(target)) {
-        return "" + settings.urls.events + target;
-    }
-    if (authEndpointMatcher.test(target)) {
-        return "" + settings.urls.auth + target;
-    }
-    if (streamingEndpointMatcher.test(target)) {
-        return "" + settings.urls.streaming + target;
-    }
-    return "" + settings.urls.sdk + target;
-}

package/esm/utils/time/index.js

@@ -1,7 +0,0 @@
-var DEDUP_WINDOW_SIZE_MS = 3600 * 1000;
-/**
-* Truncates de time frame received with the time window.
-*/
-export function truncateTimeFrame(timestampInMs) {
-    return timestampInMs - (timestampInMs % DEDUP_WINDOW_SIZE_MS);
-}

package/esm/utils/timeTracker/now/browser.js

@@ -1,12 +0,0 @@
-// Can be used on any runtime, since it fallbacks to `Date.now` if `performance.now` is not available
-function nowFactory() {
-    // eslint-disable-next-line
-    if (typeof performance === 'object' && typeof performance.now === 'function') {
-        // eslint-disable-next-line
-        return performance.now.bind(performance);
-    }
-    else {
-        return Date.now;
-    }
-}
-export var now = nowFactory();

package/esm/utils/timeTracker/now/node.js

@@ -1,5 +0,0 @@
-export function now() {
-    // eslint-disable-next-line no-undef
-    var time = process.hrtime();
-    return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
-}

package/esm/utils/timeTracker/timer.js

@@ -1,6 +0,0 @@
-export function timer(now) {
-    var st = now();
-    return function stop() {
-        return Math.round(now() - st);
-    };
-}

package/src/consent/index.ts

@@ -1,8 +0,0 @@
-import { ISettings } from '../types';
-import { CONSENT_GRANTED } from '../utils/constants';
-
-export function isConsentGranted(settings: ISettings) {
-  const userConsent = settings.userConsent;
-  // undefined userConsent is handled as granted (default)
-  return !userConsent || userConsent === CONSENT_GRANTED;
-}

package/src/consent/sdkUserConsent.ts

@@ -1,60 +0,0 @@
-import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED, USER_CONSENT_INITIAL } from '../logger/constants';
-import { isConsentGranted } from './index';
-import { CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../utils/constants';
-import { isBoolean } from '../utils/lang';
-import { ISdkFactoryContext } from '../sdkFactory/types';
-
-// User consent enum
-const ConsentStatus = {
-  GRANTED: CONSENT_GRANTED,
-  DECLINED: CONSENT_DECLINED,
-  UNKNOWN: CONSENT_UNKNOWN,
-};
-
-/**
- * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
- */
-export function createUserConsentAPI(params: ISdkFactoryContext) {
-  const { settings, settings: { log }, syncManager, storage: { events, impressions, impressionCounts, uniqueKeys } } = params;
-
-  if (!isConsentGranted(settings)) log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
-
-  return {
-    setStatus(consent: unknown) {
-      // validate input param
-      if (!isBoolean(consent)) {
-        log.warn(ERROR_NOT_BOOLEAN, ['UserConsent.setStatus']);
-        return false;
-      }
-
-      const newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
-
-      if (settings.userConsent !== newConsentStatus) {
-        log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
-        settings.userConsent = newConsentStatus;
-
-        if (consent) { // resumes submitters if transitioning to GRANTED
-          syncManager?.submitterManager?.start();
-        } else { // pauses submitters (except telemetry), and drops tracked data if transitioning to DECLINED
-          syncManager?.submitterManager?.stop(true);
-
-          // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
-          if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear(); // @ts-ignore
-          if (impressionCounts.clear) impressionCounts.clear(); // @ts-ignore
-          if (uniqueKeys.clear) uniqueKeys.clear();
-        }
-      } else {
-        log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
-      }
-
-      return true;
-    },
-
-    getStatus() {
-      return settings.userConsent;
-    },
-
-    Status: ConsentStatus
-  };
-}

package/src/dtos/types.ts

@@ -1,294 +0,0 @@
-import SplitIO from '../../types/splitio';
-
-export type MaybeThenable<T> = T | Promise<T>
-
-/** Split Matchers */
-
-export type IMatcherDataType = null | 'DATETIME' | 'NUMBER'
-
-export interface IUnaryNumericMatcherData {
-  dataType: IMatcherDataType
-  value: number
-}
-
-export interface IBetweenMatcherData {
-  dataType: IMatcherDataType
-  start: number
-  end: number
-}
-
-export interface IBetweenStringMatcherData {
-  start: string
-  end: string
-}
-
-export interface IWhitelistMatcherData {
-  whitelist: string[]
-}
-
-export interface IInSegmentMatcherData {
-  segmentName: string
-}
-
-export interface IInLargeSegmentMatcherData {
-  largeSegmentName: string
-}
-
-export interface IDependencyMatcherData {
-  split: string,
-  treatments: string[]
-}
-
-interface ISplitMatcherBase {
-  matcherType: string
-  negate: boolean
-  keySelector: null | {
-    trafficType: string,
-    attribute: string | null
-  }
-  userDefinedSegmentMatcherData?: null | IInSegmentMatcherData
-  userDefinedLargeSegmentMatcherData?: null | IInLargeSegmentMatcherData
-  whitelistMatcherData?: null | IWhitelistMatcherData
-  unaryNumericMatcherData?: null | IUnaryNumericMatcherData
-  betweenMatcherData?: null | IBetweenMatcherData
-  dependencyMatcherData?: null | IDependencyMatcherData
-  booleanMatcherData?: null | boolean
-  stringMatcherData?: null | string
-  betweenStringMatcherData?: null | IBetweenStringMatcherData
-}
-
-interface IAllKeysMatcher extends ISplitMatcherBase {
-  matcherType: 'ALL_KEYS'
-}
-
-interface IInSegmentMatcher extends ISplitMatcherBase {
-  matcherType: 'IN_SEGMENT',
-  userDefinedSegmentMatcherData: IInSegmentMatcherData
-}
-
-interface IInRBSegmentMatcher extends ISplitMatcherBase {
-  matcherType: 'IN_RULE_BASED_SEGMENT',
-  userDefinedSegmentMatcherData: IInSegmentMatcherData
-}
-
-interface IInLargeSegmentMatcher extends ISplitMatcherBase {
-  matcherType: 'IN_LARGE_SEGMENT',
-  userDefinedLargeSegmentMatcherData: IInLargeSegmentMatcherData
-}
-
-interface IWhitelistMatcher extends ISplitMatcherBase {
-  matcherType: 'WHITELIST',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IEqualToMatcher extends ISplitMatcherBase {
-  matcherType: 'EQUAL_TO',
-  unaryNumericMatcherData: IUnaryNumericMatcherData
-}
-
-interface IGreaterThanOrEqualToMatcher extends ISplitMatcherBase {
-  matcherType: 'GREATER_THAN_OR_EQUAL_TO',
-  unaryNumericMatcherData: IUnaryNumericMatcherData
-}
-
-interface ILessThanOrEqualToMatcher extends ISplitMatcherBase {
-  matcherType: 'LESS_THAN_OR_EQUAL_TO',
-  unaryNumericMatcherData: IUnaryNumericMatcherData
-}
-
-interface IBetweenMatcher extends ISplitMatcherBase {
-  matcherType: 'BETWEEN'
-  betweenMatcherData: IBetweenMatcherData
-}
-
-interface IEqualToSetMatcher extends ISplitMatcherBase {
-  matcherType: 'EQUAL_TO_SET',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IContainsAnyOfSetMatcher extends ISplitMatcherBase {
-  matcherType: 'CONTAINS_ANY_OF_SET',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IContainsAllOfSetMatcher extends ISplitMatcherBase {
-  matcherType: 'CONTAINS_ALL_OF_SET',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IPartOfSetMatcher extends ISplitMatcherBase {
-  matcherType: 'PART_OF_SET',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IStartsWithMatcher extends ISplitMatcherBase {
-  matcherType: 'STARTS_WITH',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IEndsWithMatcher extends ISplitMatcherBase {
-  matcherType: 'ENDS_WITH',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IContainsStringMatcher extends ISplitMatcherBase {
-  matcherType: 'CONTAINS_STRING',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-interface IInSplitTreatmentMatcher extends ISplitMatcherBase {
-  matcherType: 'IN_SPLIT_TREATMENT',
-  dependencyMatcherData: IDependencyMatcherData,
-}
-
-interface IEqualToBooleanMatcher extends ISplitMatcherBase {
-  matcherType: 'EQUAL_TO_BOOLEAN',
-  booleanMatcherData: boolean
-}
-
-interface IMatchesStringMatcher extends ISplitMatcherBase {
-  matcherType: 'MATCHES_STRING',
-  stringMatcherData: string
-}
-
-interface IEqualToSemverMatcher extends ISplitMatcherBase {
-  matcherType: 'EQUAL_TO_SEMVER',
-  stringMatcherData: string
-}
-
-interface IGreaterThanOrEqualToSemverMatcher extends ISplitMatcherBase {
-  matcherType: 'GREATER_THAN_OR_EQUAL_TO_SEMVER',
-  stringMatcherData: string
-}
-
-
-interface ILessThanOrEqualToSemverMatcher extends ISplitMatcherBase {
-  matcherType: 'LESS_THAN_OR_EQUAL_TO_SEMVER',
-  stringMatcherData: string
-}
-
-interface IBetweenSemverMatcher extends ISplitMatcherBase {
-  matcherType: 'BETWEEN_SEMVER'
-  betweenStringMatcherData: IBetweenStringMatcherData
-}
-
-interface IInListSemverMatcher extends ISplitMatcherBase {
-  matcherType: 'IN_LIST_SEMVER',
-  whitelistMatcherData: IWhitelistMatcherData
-}
-
-export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
-  ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
-  IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
-  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher |
-  IInLargeSegmentMatcher | IInRBSegmentMatcher
-
-/** Split object */
-export interface ISplitPartition {
-  treatment: string
-  size: number
-}
-
-export interface ISplitCondition {
-  matcherGroup: {
-    combiner: 'AND',
-    matchers: ISplitMatcher[]
-  }
-  partitions?: ISplitPartition[]
-  label?: string
-  conditionType?: 'ROLLOUT' | 'WHITELIST'
-}
-
-export interface IExcludedSegment {
-  type: 'standard' | 'large' | 'rule-based',
-  name: string,
-}
-
-export interface IRBSegment {
-  name: string,
-  changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
-  conditions?: ISplitCondition[],
-  excluded?: {
-    keys?: string[] | null,
-    segments?: IExcludedSegment[] | null
-  }
-}
-
-export interface ISplit {
-  name: string,
-  changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
-  conditions: ISplitCondition[],
-  prerequisites?: {
-    n: string,
-    ts: string[]
-  }[]
-  killed: boolean,
-  defaultTreatment: string,
-  trafficTypeName: string,
-  seed: number,
-  trafficAllocation?: number,
-  trafficAllocationSeed?: number
-  configurations?: {
-    [treatmentName: string]: string
-  },
-  sets?: string[],
-  impressionsDisabled?: boolean
-}
-
-// Split definition used in offline mode
-export type ISplitPartial = Pick<ISplit, 'conditions' | 'configurations' | 'trafficTypeName'>
-
-/** Interface of the parsed JSON response of `/splitChanges` */
-export interface ISplitChangesResponse {
-  ff?: {
-    t: number,
-    s?: number,
-    d: ISplit[]
-  },
-  rbs?: {
-    t: number,
-    s?: number,
-    d: IRBSegment[]
-  }
-}
-
-/** Interface of the parsed JSON response of `/segmentChanges/{segmentName}` */
-export interface ISegmentChangesResponse {
-  name: string,
-  added: string[],
-  removed: string[],
-  since: number,
-  till: number
-}
-
-export interface IMySegmentsResponse {
-  cn?: number,
-  k?: {
-    n: string
-  }[]
-}
-
-/** Interface of the parsed JSON response of `/memberships/{userKey}` */
-export interface IMembershipsResponse {
-  ms?: IMySegmentsResponse,
-  ls?: IMySegmentsResponse
-}
-
-/** Metadata internal type for storages */
-
-export interface IMetadata {
-  /** SDK version */
-  s: string
-  /** host IP */
-  i: string
-  /** host name */
-  n: string
-}
-
-export type ISplitFiltersValidation = {
-  queryString: string | null,
-  groupedFilters: Record<SplitIO.SplitFilterType, string[]>,
-  validFilters: SplitIO.SplitFilter[],
-};

package/src/evaluator/Engine.ts

@@ -1,73 +0,0 @@
-import { get, isString } from '../utils/lang';
-import { parser } from './parser';
-import { keyParser } from '../utils/key';
-import { thenable } from '../utils/promise/thenable';
-import { NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED, PREREQUISITES_NOT_MET } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
-import { ISplit, MaybeThenable } from '../dtos/types';
-import SplitIO from '../../types/splitio';
-import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluation, IEvaluationResult, ISplitEvaluator } from './types';
-import { ILogger } from '../logger/types';
-import { ENGINE_DEFAULT } from '../logger/constants';
-import { prerequisitesMatcherContext } from './matchers/prerequisites';
-
-function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
-  return {
-    treatment: get(result, 'treatment', defaultTreatment),
-    label: get(result, 'label', NO_CONDITION_MATCH)
-  };
-}
-
-export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync | IStorageAsync) {
-  const { killed, seed, trafficAllocation, trafficAllocationSeed, status, conditions, prerequisites } = split;
-
-  const defaultTreatment = isString(split.defaultTreatment) ? split.defaultTreatment : CONTROL;
-
-  const evaluator = parser(log, conditions, storage);
-  const prerequisiteMatcher = prerequisitesMatcherContext(prerequisites, storage, log);
-
-  return {
-
-    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
-
-      const parsedKey = keyParser(key);
-
-      function evaluate(prerequisitesMet: boolean) {
-        if (!prerequisitesMet) {
-          log.debug(ENGINE_DEFAULT, ['Prerequisite not met']);
-          return {
-            treatment: defaultTreatment,
-            label: PREREQUISITES_NOT_MET
-          };
-        }
-
-        const evaluation = evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) as MaybeThenable<IEvaluation>;
-
-        return thenable(evaluation) ?
-          evaluation.then(result => evaluationResult(result, defaultTreatment)) :
-          evaluationResult(evaluation, defaultTreatment);
-      }
-
-      if (status === 'ARCHIVED') return {
-        treatment: CONTROL,
-        label: SPLIT_ARCHIVED
-      };
-
-      if (killed) {
-        log.debug(ENGINE_DEFAULT, ['Flag is killed']);
-        return {
-          treatment: defaultTreatment,
-          label: SPLIT_KILLED
-        };
-      }
-
-      const prerequisitesMet = prerequisiteMatcher({ key, attributes }, splitEvaluator);
-
-      return thenable(prerequisitesMet) ?
-        prerequisitesMet.then(evaluate) :
-        evaluate(prerequisitesMet);
-    }
-  };
-
-}

package/src/evaluator/combiners/and.ts

@@ -1,29 +0,0 @@
-import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
-import { thenable } from '../../utils/promise/thenable';
-import { MaybeThenable } from '../../dtos/types';
-import { ISplitEvaluator } from '../types';
-import { ENGINE_COMBINER_AND } from '../../logger/constants';
-import SplitIO from '../../../types/splitio';
-
-export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>>) {
-
-  function andResults(results: boolean[]): boolean {
-    // Array.prototype.every is supported by target environments
-    const hasMatchedAll = results.every(value => value);
-
-    log.debug(ENGINE_COMBINER_AND, [hasMatchedAll]);
-    return hasMatchedAll;
-  }
-
-  return function andCombiner(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator): MaybeThenable<boolean> {
-    const matcherResults = matchers.map(matcher => matcher(key, attributes, splitEvaluator));
-
-    // If any matching result is a thenable we should use Promise.all
-    if (findIndex(matcherResults, thenable) !== -1) {
-      return Promise.all(matcherResults).then(andResults);
-    } else {
-      return andResults(matcherResults as boolean[]);
-    }
-  };
-}

package/src/evaluator/combiners/ifelseif.ts

@@ -1,56 +0,0 @@
-import { findIndex, isBoolean } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
-import { thenable } from '../../utils/promise/thenable';
-import { UNSUPPORTED_MATCHER_TYPE } from '../../utils/labels';
-import { CONTROL } from '../../utils/constants';
-import SplitIO from '../../../types/splitio';
-import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
-import { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants';
-
-export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator {
-
-  function unexpectedInputHandler() {
-    log.error(ERROR_ENGINE_COMBINER_IFELSEIF);
-
-    return {
-      treatment: CONTROL,
-      label: UNSUPPORTED_MATCHER_TYPE
-    };
-  }
-
-  function computeEvaluation(predicateResults: Array<IEvaluation | boolean | undefined>): IEvaluation | boolean | undefined {
-    for (let i = 0, len = predicateResults.length; i < len; i++) {
-      const evaluation = predicateResults[i];
-
-      if (evaluation !== undefined) {
-        if (!isBoolean(evaluation)) log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
-
-        return evaluation;
-      }
-    }
-
-    log.debug(ENGINE_COMBINER_IFELSEIF_NO_TREATMENT);
-    return undefined;
-  }
-
-  function ifElseIfCombiner(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
-    // In Async environments we are going to have async predicates. There is none way to know
-    // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
-    // define how to return the treatment (wrap result into a Promise or not).
-    const predicateResults = predicates.map(evaluator => evaluator(key, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator));
-
-    // if we find a thenable
-    if (findIndex(predicateResults, thenable) !== -1) {
-      return Promise.all(predicateResults).then(results => computeEvaluation(results));
-    }
-
-    return computeEvaluation(predicateResults as IEvaluation[]);
-  }
-
-  // if there is none predicates, then there was an error in parsing phase
-  if (!Array.isArray(predicates) || predicates.length === 0) {
-    return unexpectedInputHandler;
-  } else {
-    return ifElseIfCombiner;
-  }
-}

package/src/evaluator/condition/engineUtils.ts

@@ -1,31 +0,0 @@
-import { ENGINE_BUCKET } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import { bucket } from '../../utils/murmur3/murmur3';
-
-/**
- * Get the treatment name given a key, a seed, and the percentage of each treatment.
- */
-export function getTreatment(log: ILogger, key: string, seed: number | undefined, treatments: { getTreatmentFor: (x: number) => string }) {
-  const _bucket = bucket(key, seed);
-
-  const treatment = treatments.getTreatmentFor(_bucket);
-
-  log.debug(ENGINE_BUCKET, [_bucket, key, seed, treatment]);
-
-  return treatment;
-}
-
-/**
- * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
- */
-export function shouldApplyRollout(trafficAllocation: number, key: string, trafficAllocationSeed: number) {
-  // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
-  if (trafficAllocation < 100) {
-    const _bucket = bucket(key, trafficAllocationSeed);
-
-    if (_bucket > trafficAllocation) {
-      return false;
-    }
-  }
-  return true;
-}

package/src/evaluator/condition/index.ts

@@ -1,50 +0,0 @@
-import { getTreatment, shouldApplyRollout } from './engineUtils';
-import { thenable } from '../../utils/promise/thenable';
-import { NOT_IN_SPLIT } from '../../utils/labels';
-import { MaybeThenable } from '../../dtos/types';
-import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
-import SplitIO from '../../../types/splitio';
-import { ILogger } from '../../logger/types';
-
-// Build Evaluation object if and only if matchingResult is true
-function match(log: ILogger, matchingResult: boolean, bucketingKey: string | undefined, seed?: number, treatments?: { getTreatmentFor: (x: number) => string }, label?: string): IEvaluation | boolean | undefined {
-  if (matchingResult) {
-    return treatments ? // Feature flag
-      {
-        treatment: getTreatment(log, bucketingKey as string, seed, treatments),
-        label: label!
-      } : // Rule-based segment
-      true;
-  }
-
-  // else we should notify the engine to continue evaluating
-  return undefined;
-}
-
-// Condition factory
-export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.SplitKeyObject, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>, treatments?: { getTreatmentFor: (x: number) => string }, label?: string, conditionType?: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
-
-  return function conditionEvaluator(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
-
-    // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
-    if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation!, key.bucketingKey, trafficAllocationSeed!)) {
-      return {
-        treatment: undefined, // treatment value is assigned later
-        label: NOT_IN_SPLIT
-      };
-    }
-
-    // matcherEvaluator could be Async, this relays on matchers return value, so we need
-    // to verify for thenable before play with the result.
-    // Also, we pass splitEvaluator function in case we have a matcher that needs to evaluate another split,
-    // as well as the entire key object for the same reason.
-    const matches = matcherEvaluator(key, attributes, splitEvaluator);
-
-    if (thenable(matches)) {
-      return matches.then(result => match(log, result, key.bucketingKey, seed, treatments, label));
-    }
-
-    return match(log, matches, key.bucketingKey, seed, treatments, label);
-  };
-
-}

package/src/evaluator/convertions/index.ts

@@ -1,7 +0,0 @@
-export function zeroSinceHH(millisSinceEpoch: number): number {
-  return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
-}
-
-export function zeroSinceSS(millisSinceEpoch: number): number {
-  return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
-}