@featbit/js-client-sdk 3.0.11 → 3.0.13

package/src/store/serialization.ts

@@ -1,52 +1,52 @@
-import { IFlag } from "../evaluation/data/IFlag";
-import DataKinds from "./DataKinds";
-import { IVersionedData } from "../IVersionedData";
-import { IDataKind } from "../IDataKind";
-
-export interface Flags {
-  flags: { [name: string]: IFlag };
-}
-
-type VersionedFlag = IVersionedData & IFlag;
-
-export interface IPatchData {
-  data: VersionedFlag;
-  kind: IDataKind;
-}
-
-/**
- * @internal
- */
-export function deserializeAll(flags: IFlag[]): Flags {
-  const result = {
-    [DataKinds.Flags.namespace]: {}
-  };
-
-  if (flags?.length) {
-    result[DataKinds.Flags.namespace] = flags.reduce((acc: any, cur: any) => {
-      acc[cur.id] = {...cur, version: cur.timestamp || 0, key: cur.id, variations: cur.variationOptions};
-      return acc;
-    }, {});
-  }
-
-  return result as any as Flags;
-}
-
-/**
- * @internal
- */
-export function deserializePatch(flags: IFlag[]): IPatchData[] {
-  const result = [
-    ...flags?.map(item => ({
-      data: {
-        ...item,
-        version:item.timestamp,
-        key: item.id,
-        variations: item.variationOptions
-      },
-      kind: DataKinds.Flags
-    })) || []
-  ];
-
-  return result as any as IPatchData[];
-}
+import { IFlag } from "../evaluation/data/IFlag";
+import DataKinds from "./DataKinds";
+import { IVersionedData } from "../IVersionedData";
+import { IDataKind } from "../IDataKind";
+
+export interface Flags {
+  flags: { [name: string]: IFlag };
+}
+
+type VersionedFlag = IVersionedData & IFlag;
+
+export interface IPatchData {
+  data: VersionedFlag;
+  kind: IDataKind;
+}
+
+/**
+ * @internal
+ */
+export function deserializeAll(flags: IFlag[]): Flags {
+  const result = {
+    [DataKinds.Flags.namespace]: {}
+  };
+
+  if (flags?.length) {
+    result[DataKinds.Flags.namespace] = flags.reduce((acc: any, cur: any) => {
+      acc[cur.id] = {...cur, version: cur.timestamp || 0, key: cur.id, variations: cur.variationOptions};
+      return acc;
+    }, {});
+  }
+
+  return result as any as Flags;
+}
+
+/**
+ * @internal
+ */
+export function deserializePatch(flags: IFlag[]): IPatchData[] {
+  const result = [
+    ...flags?.map(item => ({
+      data: {
+        ...item,
+        version:item.timestamp,
+        key: item.id,
+        variations: item.variationOptions
+      },
+      kind: DataKinds.Flags
+    })) || []
+  ];
+
+  return result as any as IPatchData[];
+}

package/src/store/store.ts

@@ -1,38 +1,38 @@
-export const StoreStorageKey = 'fb-datastore';
-
-export const CurrentUserStorageKey = 'fb-user';
-
-/**
- * Represents an item which can be stored in the feature store.
- */
-export interface IStoreItem {
-  version: number;
-
-  // The actual data associated with the item.
-  [attribute: string]: any;
-}
-
-/**
- * When upserting an item it must contain a key.
- */
-export interface IKeyedStoreItem extends IStoreItem {
-  key: string;
-}
-
-/**
- * Represents the storage for a single kind of data. e.g. 'flag' or 'segment'.
- */
-export interface IStoreKindData {
-  [key: string]: IStoreItem;
-}
-
-/**
- * Represents the storage for the full data store.
- */
-export interface IStoreDataStorage {
-  flags: IStoreKindData;
-  version: number;
-
-  // This attribute is to ingore the type check error
-  [attribute: string]: any;
+export const StoreStorageKey = 'fb-datastore';
+
+export const CurrentUserStorageKey = 'fb-user';
+
+/**
+ * Represents an item which can be stored in the feature store.
+ */
+export interface IStoreItem {
+  version: number;
+
+  // The actual data associated with the item.
+  [attribute: string]: any;
+}
+
+/**
+ * When upserting an item it must contain a key.
+ */
+export interface IKeyedStoreItem extends IStoreItem {
+  key: string;
+}
+
+/**
+ * Represents the storage for a single kind of data. e.g. 'flag' or 'segment'.
+ */
+export interface IStoreKindData {
+  [key: string]: IStoreItem;
+}
+
+/**
+ * Represents the storage for the full data store.
+ */
+export interface IStoreDataStorage {
+  flags: IStoreKindData;
+  version: number;
+
+  // This attribute is to ingore the type check error
+  [attribute: string]: any;
 }

package/src/utils/Emits.ts

@@ -1,76 +1,76 @@
-import { IEventEmitter } from "./IEventEmitter";
-
-export type EventableConstructor<T = {}> = new (...args: any[]) => T;
-export type Eventable = EventableConstructor<{ emitter: IEventEmitter }>;
-
-/**
- * Adds the implementation of an event emitter to something that contains
- * a field of `emitter` with type `EventEmitter`.
- * @param Base The class to derive the mixin from.
- * @returns A class extending the base with an event emitter.
- */
-export function Emits<TBase extends Eventable>(Base: TBase) {
-  return class WithEvents extends Base implements IEventEmitter {
-    on(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
-      this.emitter.on(eventName, listener, context);
-      return this;
-    }
-
-    addListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
-      this.emitter.addListener(eventName, listener, context);
-      return this;
-    }
-
-    once(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
-      this.emitter.once(eventName, listener, context);
-      return this;
-    }
-
-    removeListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
-      this.emitter.removeListener(eventName, listener, context);
-      return this;
-    }
-
-    off(eventName: string | symbol, listener: (...args: any) => void, context?: any): this {
-      this.emitter.off(eventName, listener, context);
-      return this;
-    }
-
-    removeAllListeners(event?: string | symbol): this {
-      this.emitter.removeAllListeners(event);
-      return this;
-    }
-
-    listeners(eventName: string | symbol): Function[] {
-      return this.emitter.listeners(eventName);
-    }
-
-    emit(eventName: string | symbol, ...args: any[]): this  {
-      this.emitter.emit(eventName, args);
-      return this;
-    }
-
-    listenerCount(eventName: string | symbol): number {
-      return this.emitter.listenerCount(eventName);
-    }
-
-    prependListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
-      this.emitter.prependListener(eventName, listener, context);
-      return this;
-    }
-
-    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
-      this.emitter.prependOnceListener(eventName, listener, context);
-      return this;
-    }
-
-    eventNames(): (string | symbol)[] {
-      return this.emitter.eventNames();
-    }
-
-    maybeReportError (error: any): this {
-      this.emitter.maybeReportError(error);
-      return this;
-    }
-  };
+import { IEventEmitter } from "./IEventEmitter";
+
+export type EventableConstructor<T = {}> = new (...args: any[]) => T;
+export type Eventable = EventableConstructor<{ emitter: IEventEmitter }>;
+
+/**
+ * Adds the implementation of an event emitter to something that contains
+ * a field of `emitter` with type `EventEmitter`.
+ * @param Base The class to derive the mixin from.
+ * @returns A class extending the base with an event emitter.
+ */
+export function Emits<TBase extends Eventable>(Base: TBase) {
+  return class WithEvents extends Base implements IEventEmitter {
+    on(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.on(eventName, listener, context);
+      return this;
+    }
+
+    addListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.addListener(eventName, listener, context);
+      return this;
+    }
+
+    once(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.once(eventName, listener, context);
+      return this;
+    }
+
+    removeListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.removeListener(eventName, listener, context);
+      return this;
+    }
+
+    off(eventName: string | symbol, listener: (...args: any) => void, context?: any): this {
+      this.emitter.off(eventName, listener, context);
+      return this;
+    }
+
+    removeAllListeners(event?: string | symbol): this {
+      this.emitter.removeAllListeners(event);
+      return this;
+    }
+
+    listeners(eventName: string | symbol): Function[] {
+      return this.emitter.listeners(eventName);
+    }
+
+    emit(eventName: string | symbol, ...args: any[]): this  {
+      this.emitter.emit(eventName, args);
+      return this;
+    }
+
+    listenerCount(eventName: string | symbol): number {
+      return this.emitter.listenerCount(eventName);
+    }
+
+    prependListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.prependListener(eventName, listener, context);
+      return this;
+    }
+
+    prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void, context?: any): this {
+      this.emitter.prependOnceListener(eventName, listener, context);
+      return this;
+    }
+
+    eventNames(): (string | symbol)[] {
+      return this.emitter.eventNames();
+    }
+
+    maybeReportError (error: any): this {
+      this.emitter.maybeReportError(error);
+      return this;
+    }
+  };
 }

package/src/utils/EventEmitter.ts

@@ -1,129 +1,129 @@
-import { ILogger } from "../logging/ILogger";
-import { IEventEmitter } from "./IEventEmitter";
-
-interface Events {
-  [key: string | symbol]: {
-    handler: (...args: any[]) => void;
-    context: any;
-  }[];
-}
-
-export class EventEmitter implements IEventEmitter {
-  private events: Events = {};
-
-  constructor(private logger?: ILogger) {}
-
-  private listeningTo (event: string) {
-    return !!this.events[event];
-  }
-
-  on (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    this.events[event] = this.events[event] || [];
-    this.events[event] = this.events[event].concat({
-      handler: handler,
-      context: context,
-    });
-
-    return this;
-  }
-
-  addListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    return this.on(event, handler, context);
-  }
-
-  once (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    const onceHandler = (...args: any[]) => {
-      this.off(event, onceHandler, context);
-      handler.apply(context, args);
-    };
-    return this.on(event, onceHandler, context);
-  }
-
-  off (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    if (!this.events[event]) {
-      return this;
-    }
-    for (let i = 0; i < this.events[event].length; i++) {
-      if (this.events[event][i].handler === handler && this.events[event][i].context === context) {
-        this.events[event] = this.events[event].slice(0, i).concat(this.events[event].slice(i + 1));
-      }
-    }
-
-    return this;
-  }
-
-  removeListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    return this.off(event, handler, context);
-  }
-
-  removeAllListeners (event?: string | symbol): this {
-    if (event) {
-      delete this.events[event];
-    } else {
-      this.events = {};
-    }
-
-    return this;
-  }
-
-  listeners (event: string | symbol): Function[] {
-    return this.events[event] ? this.events[event].map((event) => event.handler) : [];
-  }
-
-  emit (event: string | symbol, ...args: any[]): this {
-    if (!this.events[event]) {
-      return this;
-    }
-    // Copy the list of handlers before iterating, in case any handler adds or removes another handler.
-    // Any such changes should not affect what we do here-- we want to notify every handler that existed
-    // at the moment that the event was fired.
-    const copiedHandlers = [...this.events[event]];
-    for (let i = 0; i < copiedHandlers.length; i++) {
-      copiedHandlers[i].handler.apply(copiedHandlers[i].context, Array.prototype.slice.call(arguments, 1));
-    }
-
-    return this;
-  }
-
-  listenerCount (event: string | symbol): number {
-    return this.events[event] ? this.events[event].length : 0;
-  }
-
-  prependListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    this.events[event] = this.events[event] || [];
-    this.events[event] = [
-      {
-        handler: handler,
-        context: context,
-      },
-      ...this.events[event]
-    ];
-
-    return this;
-  }
-
-  prependOnceListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
-    const onceHandler = (...args: any[]) => {
-      this.off(event, onceHandler, context);
-      handler.apply(context, args);
-    };
-    return this.prependListener(event, onceHandler, context);
-  }
-
-  eventNames (): (string | symbol)[] {
-    return Object.keys(this.events);
-  }
-
-  maybeReportError (error: any): this {
-    if (!error) {
-      return this;
-    }
-    if (this.listeningTo('error')) {
-      this.emit('error', error);
-    } else {
-      this.logger?.error(error);
-    }
-
-    return this;
-  }
+import { ILogger } from "../logging/ILogger";
+import { IEventEmitter } from "./IEventEmitter";
+
+interface Events {
+  [key: string | symbol]: {
+    handler: (...args: any[]) => void;
+    context: any;
+  }[];
+}
+
+export class EventEmitter implements IEventEmitter {
+  private events: Events = {};
+
+  constructor(private logger?: ILogger) {}
+
+  private listeningTo (event: string) {
+    return !!this.events[event];
+  }
+
+  on (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    this.events[event] = this.events[event] || [];
+    this.events[event] = this.events[event].concat({
+      handler: handler,
+      context: context,
+    });
+
+    return this;
+  }
+
+  addListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    return this.on(event, handler, context);
+  }
+
+  once (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    const onceHandler = (...args: any[]) => {
+      this.off(event, onceHandler, context);
+      handler.apply(context, args);
+    };
+    return this.on(event, onceHandler, context);
+  }
+
+  off (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    if (!this.events[event]) {
+      return this;
+    }
+    for (let i = 0; i < this.events[event].length; i++) {
+      if (this.events[event][i].handler === handler && this.events[event][i].context === context) {
+        this.events[event] = this.events[event].slice(0, i).concat(this.events[event].slice(i + 1));
+      }
+    }
+
+    return this;
+  }
+
+  removeListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    return this.off(event, handler, context);
+  }
+
+  removeAllListeners (event?: string | symbol): this {
+    if (event) {
+      delete this.events[event];
+    } else {
+      this.events = {};
+    }
+
+    return this;
+  }
+
+  listeners (event: string | symbol): Function[] {
+    return this.events[event] ? this.events[event].map((event) => event.handler) : [];
+  }
+
+  emit (event: string | symbol, ...args: any[]): this {
+    if (!this.events[event]) {
+      return this;
+    }
+    // Copy the list of handlers before iterating, in case any handler adds or removes another handler.
+    // Any such changes should not affect what we do here-- we want to notify every handler that existed
+    // at the moment that the event was fired.
+    const copiedHandlers = [...this.events[event]];
+    for (let i = 0; i < copiedHandlers.length; i++) {
+      copiedHandlers[i].handler.apply(copiedHandlers[i].context, Array.prototype.slice.call(arguments, 1));
+    }
+
+    return this;
+  }
+
+  listenerCount (event: string | symbol): number {
+    return this.events[event] ? this.events[event].length : 0;
+  }
+
+  prependListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    this.events[event] = this.events[event] || [];
+    this.events[event] = [
+      {
+        handler: handler,
+        context: context,
+      },
+      ...this.events[event]
+    ];
+
+    return this;
+  }
+
+  prependOnceListener (event: string | symbol, handler: (...args: any[]) => void, context?: any): this {
+    const onceHandler = (...args: any[]) => {
+      this.off(event, onceHandler, context);
+      handler.apply(context, args);
+    };
+    return this.prependListener(event, onceHandler, context);
+  }
+
+  eventNames (): (string | symbol)[] {
+    return Object.keys(this.events);
+  }
+
+  maybeReportError (error: any): this {
+    if (!error) {
+      return this;
+    }
+    if (this.listeningTo('error')) {
+      this.emit('error', error);
+    } else {
+      this.logger?.error(error);
+    }
+
+    return this;
+  }
 }

package/src/utils/IEventEmitter.ts

@@ -1,15 +1,15 @@
-export interface IEventEmitter {
-  on(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  addListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  once(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  off(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  removeListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  removeAllListeners(event?: string | symbol): this;
-  listeners(event: string | symbol): Function[];
-  emit(event: string | symbol, ...args: any[]): this;
-  listenerCount(event: string | symbol): number;
-  prependListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  prependOnceListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
-  eventNames(): (string | symbol)[];
-  maybeReportError(error: any): this;
+export interface IEventEmitter {
+  on(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  addListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  once(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  off(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  removeListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  removeAllListeners(event?: string | symbol): this;
+  listeners(event: string | symbol): Function[];
+  emit(event: string | symbol, ...args: any[]): this;
+  listenerCount(event: string | symbol): number;
+  prependListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  prependOnceListener(event: string | symbol, handler: (...args: any[]) => void, context?: any): this;
+  eventNames(): (string | symbol)[];
+  maybeReportError(error: any): this;
 }

package/src/utils/Regex.ts

@@ -1,22 +1,22 @@
-import { isNullOrUndefined } from "./isNullOrUndefined";
-
-export class Regex {
-  private static patternWithFlags = /\/(.*)\/([a-z]*)/i;
-  private static whiteSpaceRegex = /\s/g;
-
-  static fromString(patternString: string): RegExp {
-    let flags = '';
-    const match = patternString.match(Regex.patternWithFlags);
-
-    if (match) {
-      patternString = match[1]; // Update the pattern string
-      flags = match[2]; // Update the flags
-    }
-
-    return new RegExp(patternString, flags);
-  }
-
-  static isNullOrWhiteSpace(str: string) {
-    return isNullOrUndefined(str) || !str.replace(Regex.whiteSpaceRegex, '').length;
-  }
+import { isNullOrUndefined } from "./isNullOrUndefined";
+
+export class Regex {
+  private static patternWithFlags = /\/(.*)\/([a-z]*)/i;
+  private static whiteSpaceRegex = /\s/g;
+
+  static fromString(patternString: string): RegExp {
+    let flags = '';
+    const match = patternString.match(Regex.patternWithFlags);
+
+    if (match) {
+      patternString = match[1]; // Update the pattern string
+      flags = match[2]; // Update the flags
+    }
+
+    return new RegExp(patternString, flags);
+  }
+
+  static isNullOrWhiteSpace(str: string) {
+    return isNullOrUndefined(str) || !str.replace(Regex.whiteSpaceRegex, '').length;
+  }
 }