@splitsoftware/splitio-commons 1.1.0 → 1.1.1-rc.0

package/src/sdkClient/clientAttributesDecoration.ts

@@ -0,0 +1,122 @@
+import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+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<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
+
+  const attributeStorage = new AttributesCacheInMemory();
+
+  // Keep a reference to the original methods
+  const clientGetTreatment = client.getTreatment;
+  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  const clientGetTreatments = client.getTreatments;
+  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  const clientTrack = client.track;
+
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+    return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+  }
+
+  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined{
+    const storedAttributes = attributeStorage.getAll();
+    if (Object.keys(storedAttributes).length > 0) {
+      return objectAssign({}, storedAttributes, maybeAttributes);
+    }
+    return maybeAttributes;
+  }
+
+  return objectAssign(client, {
+    getTreatment: getTreatment,
+    getTreatmentWithConfig: getTreatmentWithConfig,
+    getTreatments: getTreatments,
+    getTreatmentsWithConfig: getTreatmentsWithConfig,
+    track: track,
+    
+    /**
+     * Add an attribute to client's in memory attributes storage
+     * 
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object) {
+      const attribute: Record<string, Object> = {};
+      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 key
+     * 
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string) {
+      log.debug(`retrieved attribute ${attributeName}`);
+      return attributeStorage.getAttribute(attributeName + '');
+    },
+
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     * 
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>) {
+      if (!validateAttributesDeep(log, attributes, 'setAttributes')) return false;
+      return attributeStorage.setAttributes(attributes);
+    },
+
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     * 
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object> {
+      return attributeStorage.getAll();
+    },
+
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     * 
+     * @param {string} attributeName 
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string) {
+      log.debug(`removed attribute ${attributeName}`);
+      return attributeStorage.removeAttribute(attributeName + '');
+    },
+
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes() {
+      return attributeStorage.clear();
+    }
+    
+  });
+
+}

package/src/sdkClient/clientCS.ts

@@ -1,5 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
+import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
 /**
@@ -9,15 +11,18 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
-  return objectAssign(client, {
+export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
+
+  let clientCS = clientAttributesDecoration(log, client);
+
+  return objectAssign(clientCS, {
     // In the client-side API, we bind a key to the client `getTreatment*` methods
-    getTreatment: client.getTreatment.bind(client, key),
-    getTreatmentWithConfig: client.getTreatmentWithConfig.bind(client, key),
-    getTreatments: client.getTreatments.bind(client, key),
-    getTreatmentsWithConfig: client.getTreatmentsWithConfig.bind(client, key),
+    getTreatment: clientCS.getTreatment.bind(clientCS, key),
+    getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
+    getTreatments: clientCS.getTreatments.bind(clientCS, key),
+    getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
 
     // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-    track: trafficType ? client.track.bind(client, key, trafficType) : client.track.bind(client, key)
+    track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key)
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -29,6 +29,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
   const validKey = validateKey(log, key, method);
 
   const mainClientInstance = clientCSDecorator(
+    log,
     sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
     validKey
   );
@@ -74,6 +75,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
       clientInstances[instanceId] = clientCSDecorator(
+        log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -35,6 +35,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
   }
 
   const mainClientInstance = clientCSDecorator(
+    log,
     sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
     validKey,
     validTrafficType
@@ -88,6 +89,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
       clientInstances[instanceId] = clientCSDecorator(
+        log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -0,0 +1,73 @@
+import { objectAssign } from '../../utils/lang/objectAssign';
+
+export class AttributesCacheInMemory {
+
+  private attributesCache: Record<string, Object> = {};
+
+
+  /**
+   * Create or update the value for the given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored 
+   */
+  setAttribute(attributeName: string, attributeValue: Object): boolean {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+
+  /**
+   * Retrieves the value of a given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  getAttribute(attributeName: string): Object {
+    return this.attributesCache[attributeName];
+  }
+
+  /**
+   * Create or update all the given attributes
+   * 
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  setAttributes(attributes: Record<string, Object>): boolean {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+
+  /**
+   * Retrieve the full attributes map
+   * 
+   * @returns {Map<string, Object>} stored attributes
+   */
+  getAll(): Record<string, Object> {
+    return this.attributesCache;
+  }
+
+  /**
+   * Removes a given attribute from the map
+   * 
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  removeAttribute(attributeName: string): boolean {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clears all attributes stored in the SDK
+   * 
+   */
+  clear() {
+    this.attributesCache = {};
+    return true;
+  }
+
+}

package/src/types.ts

@@ -1108,6 +1108,45 @@ export namespace SplitIO {
      * @returns {boolean} Whether the event was added to the queue succesfully or not.
      */
     track(...args: [trafficType: string, eventType: string, value?: number, properties?: Properties] | [eventType: string, value?: number, properties?: Properties]): boolean,
+    /**
+     * Add an attribute to client's in memory attributes storage
+     * @function setAttribute
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean,
+    /**
+     * Returns the attribute with the given key
+     * @function getAttribute
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object,
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     * @function setAttributes
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean,
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     * @function getAttributes
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>,
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     * @function removeAttribute
+     * @param {string} attributeName 
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean,
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean
   }
   /**
    * Representation of a manager instance with synchronous storage of the SDK.

package/src/utils/inputValidation/attribute.ts

@@ -0,0 +1,21 @@
+import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+
+export function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean {
+  if (!isString(attributeKey) || attributeKey.length === 0) {
+    log.warn(`${method}: you passed an invalid attribute name, attribute name must be a non-empty string.`);
+    return false;
+  }
+
+  const isStringVal = isString(attributeValue);
+  const isFiniteVal = isFiniteNumber(attributeValue);
+  const isBoolVal = isBoolean(attributeValue);
+  const isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
+    log.warn(`${method}: you passed an invalid attribute value for ${attributeKey}. Acceptable types are: string, number, boolean and array of strings.`);
+    return false;
+  }
+
+  return true;
+}

package/src/utils/inputValidation/attributes.ts

@@ -1,6 +1,7 @@
 import { isObject } from '../lang';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
+import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
@@ -11,3 +12,16 @@ export function validateAttributes(log: ILogger, maybeAttrs: any, method: string
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
   return false;
 }
+
+export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<string, Object>, method: string): boolean {
+  if (!validateAttributes(log, maybeAttributes, method)) return false;
+
+  let result = true;
+  Object.keys(maybeAttributes).forEach(attributeKey => {
+    if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+      result = false;
+  });
+
+  return result;
+
+}

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -0,0 +1,51 @@
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+export declare function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient): TClient & {
+    getTreatment: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => string | SplitIO.AsyncTreatment;
+    getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
+    getTreatments: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => import("../dtos/types").MaybeThenable<boolean>;
+    /**
+     * Add an attribute to client's in memory attributes storage
+     *
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean;
+    /**
+     * Returns the attribute with the given key
+     *
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     *
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean;
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     *
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>;
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     *
+     * @param {string} attributeName
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean;
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean;
+};

package/types/sdkClient/clientCS.d.ts

@@ -1,3 +1,4 @@
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
@@ -6,4 +7,4 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export declare function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;
+export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;

package/types/storages/inMemory/AttributesCacheInMemory.d.ts

@@ -0,0 +1,43 @@
+export declare class AttributesCacheInMemory {
+    private attributesCache;
+    /**
+     * Create or update the value for the given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @param {Object} attributeValue attribute value
+     * @returns {boolean} the attribute was stored
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean;
+    /**
+     * Retrieves the value of a given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @returns {Object?} stored attribute value
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * Create or update all the given attributes
+     *
+     * @param {[string, Object]} attributes attributes to create or update
+     * @returns {boolean} attributes were stored
+     */
+    setAttributes(attributes: Record<string, Object>): boolean;
+    /**
+     * Retrieve the full attributes map
+     *
+     * @returns {Map<string, Object>} stored attributes
+     */
+    getAll(): Record<string, Object>;
+    /**
+     * Removes a given attribute from the map
+     *
+     * @param {string} attributeName attribute to remove
+     * @returns {boolean} attribute removed
+     */
+    removeAttribute(attributeName: string): boolean;
+    /**
+     * Clears all attributes stored in the SDK
+     *
+     */
+    clear(): boolean;
+}

package/types/types.d.ts

@@ -1108,6 +1108,45 @@ export declare namespace SplitIO {
          * @returns {boolean} Whether the event was added to the queue succesfully or not.
          */
         track(...args: [trafficType: string, eventType: string, value?: number, properties?: Properties] | [eventType: string, value?: number, properties?: Properties]): boolean;
+        /**
+         * Add an attribute to client's in memory attributes storage
+         * @function setAttribute
+         * @param {string} attributeName Attrinute name
+         * @param {string, number, boolean, list} attributeValue Attribute value
+         * @returns {boolean} true if the attribute was stored and false otherways
+         */
+        setAttribute(attributeName: string, attributeValue: Object): boolean;
+        /**
+         * Returns the attribute with the given key
+         * @function getAttribute
+         * @param {string} attributeName Attribute name
+         * @returns {Object} Attribute with the given key
+         */
+        getAttribute(attributeName: string): Object;
+        /**
+         * Add to client's in memory attributes storage the attributes in 'attributes'
+         * @function setAttributes
+         * @param {Object} attributes Object with attributes to store
+         * @returns true if attributes were stored an false otherways
+         */
+        setAttributes(attributes: Record<string, Object>): boolean;
+        /**
+         * Return all the attributes stored in client's in memory attributes storage
+         * @function getAttributes
+         * @returns {Object} returns all the stored attributes
+         */
+        getAttributes(): Record<string, Object>;
+        /**
+         * Removes from client's in memory attributes storage the attribute with the given key
+         * @function removeAttribute
+         * @param {string} attributeName
+         * @returns {boolean} true if attribute was removed and false otherways
+         */
+        removeAttribute(attributeName: string): boolean;
+        /**
+         * Remove all the stored attributes in the client's in memory attribute storage
+         */
+        clearAttributes(): boolean;
     }
     /**
      * Representation of a manager instance with synchronous storage of the SDK.

package/types/utils/inputValidation/attribute.d.ts

@@ -0,0 +1,2 @@
+import { ILogger } from '../../logger/types';
+export declare function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean;

package/types/utils/inputValidation/attributes.d.ts

@@ -1,3 +1,4 @@
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 export declare function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false;
+export declare function validateAttributesDeep(log: ILogger, maybeAttributes: Record<string, Object>, method: string): boolean;

package/types/integrations/ga/GaToSplitPlugin.d.ts

@@ -1,3 +0,0 @@
-import { IIntegrationFactoryParams } from '../types';
-import { GoogleAnalyticsToSplitOptions } from './types';
-export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): (params: IIntegrationFactoryParams) => void;

package/types/integrations/ga/SplitToGaPlugin.d.ts

@@ -1,4 +0,0 @@
-import { IIntegrationFactoryParams } from '../types';
-import SplitToGa from './SplitToGa';
-import { SplitToGoogleAnalyticsOptions } from './types';
-export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): (params: IIntegrationFactoryParams) => SplitToGa;

package/types/logger/codes.d.ts

@@ -1,2 +0,0 @@
-import { ICodes } from './types';
-export declare const codes: ICodes;

package/types/logger/codesConstants.d.ts

@@ -1,117 +0,0 @@
-export declare const DEBUG_0 = 0;
-export declare const DEBUG_1 = 1;
-export declare const DEBUG_2 = 2;
-export declare const DEBUG_3 = 3;
-export declare const DEBUG_4 = 4;
-export declare const DEBUG_5 = 5;
-export declare const DEBUG_6 = 6;
-export declare const DEBUG_7 = 7;
-export declare const DEBUG_8 = 8;
-export declare const DEBUG_9 = 9;
-export declare const DEBUG_10 = 10;
-export declare const DEBUG_11 = 11;
-export declare const DEBUG_12 = 12;
-export declare const DEBUG_13 = 13;
-export declare const DEBUG_14 = 14;
-export declare const DEBUG_15 = 15;
-export declare const DEBUG_16 = 16;
-export declare const DEBUG_17 = 17;
-export declare const DEBUG_18 = 18;
-export declare const DEBUG_19 = 19;
-export declare const DEBUG_20 = 20;
-export declare const DEBUG_21 = 21;
-export declare const DEBUG_22 = 22;
-export declare const DEBUG_23 = 23;
-export declare const DEBUG_24 = 24;
-export declare const DEBUG_25 = 25;
-export declare const DEBUG_31 = 31;
-export declare const DEBUG_32 = 32;
-export declare const DEBUG_33 = 33;
-export declare const DEBUG_36 = 36;
-export declare const DEBUG_42 = 42;
-export declare const DEBUG_43 = 43;
-export declare const DEBUG_44 = 44;
-export declare const DEBUG_45 = 45;
-export declare const DEBUG_46 = 46;
-export declare const DEBUG_47 = 47;
-export declare const DEBUG_48 = 48;
-export declare const DEBUG_49 = 49;
-export declare const DEBUG_50 = 50;
-export declare const DEBUG_51 = 51;
-export declare const INFO_0 = 100;
-export declare const INFO_1 = 101;
-export declare const INFO_2 = 102;
-export declare const INFO_3 = 103;
-export declare const INFO_4 = 104;
-export declare const INFO_5 = 105;
-export declare const INFO_6 = 106;
-export declare const INFO_7 = 107;
-export declare const INFO_8 = 108;
-export declare const INFO_9 = 109;
-export declare const INFO_10 = 110;
-export declare const INFO_11 = 111;
-export declare const INFO_12 = 112;
-export declare const INFO_13 = 113;
-export declare const INFO_14 = 114;
-export declare const INFO_15 = 115;
-export declare const INFO_16 = 116;
-export declare const INFO_17 = 117;
-export declare const INFO_18 = 118;
-export declare const INFO_19 = 119;
-export declare const INFO_20 = 120;
-export declare const INFO_21 = 121;
-export declare const WARN_0 = 200;
-export declare const WARN_1 = 201;
-export declare const WARN_2 = 202;
-export declare const WARN_4 = 204;
-export declare const WARN_5 = 205;
-export declare const WARN_6 = 206;
-export declare const WARN_7 = 207;
-export declare const WARN_8 = 208;
-export declare const WARN_9 = 209;
-export declare const WARN_10 = 210;
-export declare const WARN_11 = 211;
-export declare const WARN_12 = 212;
-export declare const WARN_13 = 213;
-export declare const WARN_14 = 214;
-export declare const WARN_15 = 215;
-export declare const WARN_17 = 217;
-export declare const WARN_18 = 218;
-export declare const WARN_19 = 219;
-export declare const WARN_20 = 220;
-export declare const WARN_21 = 221;
-export declare const WARN_22 = 222;
-export declare const WARN_23 = 223;
-export declare const WARN_24 = 224;
-export declare const WARN_25 = 225;
-export declare const ERROR_0 = 300;
-export declare const ERROR_2 = 302;
-export declare const ERROR_3 = 303;
-export declare const ERROR_4 = 304;
-export declare const ERROR_5 = 305;
-export declare const ERROR_7 = 307;
-export declare const ERROR_9 = 309;
-export declare const ERROR_10 = 310;
-export declare const ERROR_11 = 311;
-export declare const ERROR_12 = 312;
-export declare const ERROR_13 = 313;
-export declare const ERROR_14 = 314;
-export declare const ERROR_15 = 315;
-export declare const ERROR_16 = 316;
-export declare const ERROR_17 = 317;
-export declare const ERROR_18 = 318;
-export declare const ERROR_19 = 319;
-export declare const ERROR_20 = 320;
-export declare const ERROR_21 = 321;
-export declare const ERROR_22 = 322;
-export declare const ERROR_23 = 323;
-export declare const ERROR_24 = 324;
-export declare const ERROR_25 = 325;
-export declare const ERROR_26 = 326;
-export declare const ERROR_32 = 332;
-export declare const ERROR_33 = 333;
-export declare const ERROR_34 = 334;
-export declare const ERROR_35 = 335;
-export declare const ERROR_36 = 336;
-export declare const ERROR_37 = 337;
-export declare const ERROR_38 = 338;

package/types/logger/codesConstantsBrowser.d.ts

@@ -1,2 +0,0 @@
-export declare const DEBUG_26 = 26;
-export declare const DEBUG_27 = 27;