@featbit/js-client-sdk 3.0.13 → 3.0.14

package/src/bootstrap/JsonBootstrapProvider.ts

@@ -1,35 +1,35 @@
-import { IBootstrapProvider } from "./IBootstrapProvider";
-import { deserializeAll } from "../store/serialization";
-import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
-import { IStoreDataStorage } from "../store/store";
-import { isNullOrUndefined } from "../utils/isNullOrUndefined";
-import { IFlag, IFlagBase } from "../evaluation/data/IFlag";
-
-export class JsonBootstrapProvider implements IBootstrapProvider {
-  private dataSet?: IStoreDataStorage;
-
-  constructor(bootstrap: IFlagBase[]) {
-    const flags: IFlag[] = (bootstrap || []).map((flag: IFlagBase) => ({...flag, variationOptions: flag.variationOptions || [{id: null, variation: flag.variation}]})) as IFlag[];
-
-    const data = deserializeAll(flags);
-    this.dataSet = {
-      flags: data.flags,
-      version: 0
-    };
-  }
-
-  populate(userKeyId: string, dataSourceUpdates: IDataSourceUpdates, callback?: () => void): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (isNullOrUndefined(this.dataSet)) {
-        return resolve();
-      }
-
-      const internalCallback = () => {
-        resolve();
-        callback?.();
-      }
-
-      dataSourceUpdates.init(userKeyId, this.dataSet!, internalCallback);
-    });
-  }
+import { IBootstrapProvider } from "./IBootstrapProvider";
+import { deserializeAll } from "../store/serialization";
+import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
+import { IStoreDataStorage } from "../store/store";
+import { isNullOrUndefined } from "../utils/isNullOrUndefined";
+import { IFlag, IFlagBase } from "../evaluation/data/IFlag";
+
+export class JsonBootstrapProvider implements IBootstrapProvider {
+  private dataSet?: IStoreDataStorage;
+
+  constructor(bootstrap: IFlagBase[]) {
+    const flags: IFlag[] = (bootstrap || []).map((flag: IFlagBase) => ({...flag, variationOptions: flag.variationOptions || [{id: null, variation: flag.variation}]})) as IFlag[];
+
+    const data = deserializeAll(flags);
+    this.dataSet = {
+      flags: data.flags,
+      version: 0
+    };
+  }
+
+  populate(userKeyId: string, dataSourceUpdates: IDataSourceUpdates, callback?: () => void): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (isNullOrUndefined(this.dataSet)) {
+        return resolve();
+      }
+
+      const internalCallback = () => {
+        resolve();
+        callback?.();
+      }
+
+      dataSourceUpdates.init(userKeyId, this.dataSet!, internalCallback);
+    });
+  }
 }

package/src/bootstrap/NullBootstrapProvider.ts

@@ -1,21 +1,21 @@
-import { IBootstrapProvider } from "./IBootstrapProvider";
-import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
-import { IStoreDataStorage } from "../store/store";
-
-export class NullBootstrapProvider implements IBootstrapProvider {
-  private dataSet?: IStoreDataStorage;
-
-  constructor() {
-    this.dataSet = {
-      flags: {},
-      version: 0
-    };
-  }
-
-  populate(userKeyId: string, dataSourceUpdates: IDataSourceUpdates, callback?: () => void): Promise<void> {
-    return new Promise((resolve, reject) => {
-      resolve();
-      callback?.();
-    });
-  }
+import { IBootstrapProvider } from "./IBootstrapProvider";
+import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
+import { IStoreDataStorage } from "../store/store";
+
+export class NullBootstrapProvider implements IBootstrapProvider {
+  private dataSet?: IStoreDataStorage;
+
+  constructor() {
+    this.dataSet = {
+      flags: {},
+      version: 0
+    };
+  }
+
+  populate(userKeyId: string, dataSourceUpdates: IDataSourceUpdates, callback?: () => void): Promise<void> {
+    return new Promise((resolve, reject) => {
+      resolve();
+      callback?.();
+    });
+  }
 }

package/src/bootstrap/index.ts

@@ -1,3 +1,3 @@
-export * from './IBootstrapProvider';
-export * from './JsonBootstrapProvider';
+export * from './IBootstrapProvider';
+export * from './JsonBootstrapProvider';
 export * from './NullBootstrapProvider';

package/src/constants.ts

@@ -1,2 +1,2 @@
-export const EmptyString = '';
+export const EmptyString = '';
 export const MinInt: number = 0x80000000;

package/src/data-sources/DataSourceUpdates.ts

@@ -1,117 +1,117 @@
-import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
-import {
-  IStoreDataStorage,
-  IStoreItem,
-  IKeyedStoreItem
-} from "../store/store";
-import { IStore } from "../platform/IStore";
-import { IDataKind } from "../IDataKind";
-import DataKinds from "../store/DataKinds";
-
-/**
- * @internal
- */
-export default class DataSourceUpdates implements IDataSourceUpdates {
-
-  constructor(
-    private readonly store: IStore,
-    private readonly hasEventListeners: () => boolean,
-    private readonly onChange: (keys: string[]) => void,
-  ) {
-  }
-
-  async init(userKeyId: string, allData: IStoreDataStorage, callback?: () => void): Promise<void> {
-    if (userKeyId !== this.store.user.keyId) {
-      callback?.();
-      return;
-    }
-
-    const checkForChanges = this.hasEventListeners();
-    const doInit = async (oldData?: IStoreDataStorage) => {
-      await this.store.init(allData);
-      Promise.resolve().then(() => {
-        if (checkForChanges) {
-          const updatedKeys = Object.keys(allData)
-            .flatMap((namespace) => {
-              const oldDataForKind = oldData?.[namespace] || {};
-              const newDataForKind = allData[namespace];
-              const mergedData = {...oldDataForKind, ...newDataForKind};
-              return Object.keys(mergedData)
-                .filter((key: string) => this.isUpdated(oldDataForKind && oldDataForKind[key], newDataForKind && newDataForKind[key]));
-            });
-          updatedKeys.length > 0 && this.onChange(updatedKeys);
-        }
-      });
-      callback?.();
-    };
-
-    if (checkForChanges) {
-      const [flags, version] = this.store.all(DataKinds.Flags);
-      const oldData = {
-        flags,
-        version
-      };
-      await doInit(oldData);
-    } else {
-      await doInit();
-    }
-  }
-
-  checkUpdates(oldData: IStoreDataStorage, newData: IStoreDataStorage, callback?: () => void): void {
-    const checkForChanges = this.hasEventListeners();
-
-    if (!checkForChanges) {
-      return;
-    }
-
-    const updatedKeys = Object.keys(newData)
-    .flatMap((namespace) => {
-      const oldDataForKind = oldData?.[namespace] || {};
-      const newDataForKind = newData[namespace];
-      const mergedData = {...oldDataForKind, ...newDataForKind};
-      return Object.keys(mergedData)
-      .filter((key: string) => this.isUpdated(oldDataForKind && oldDataForKind[key], newDataForKind && newDataForKind[key]));
-    });
-    updatedKeys.length > 0 && this.onChange(updatedKeys);
-
-    callback?.();
-  }
-
-  async upsert(userKeyId: string, kind: IDataKind, data: IKeyedStoreItem, callback: () => void): Promise<void> {
-    if (userKeyId !== this.store.user.keyId) {
-      callback?.();
-      return;
-    }
-
-    const {key} = data;
-    const checkForChanges = this.hasEventListeners();
-    const doUpsert = async (oldItem?: IStoreItem) => {
-      await this.store.upsert(kind, data);
-      Promise.resolve().then(() => {
-        if (checkForChanges && this.isUpdated(oldItem, data[key])) {
-          this.onChange([key]);
-        }
-      });
-
-      callback?.();
-    };
-    if (checkForChanges) {
-      const item = this.store.get(kind, key);
-      await doUpsert(item || undefined);
-    } else {
-      await doUpsert();
-    }
-  }
-
-  private isUpdated(oldData?: IStoreItem, newData?: IStoreItem): boolean {
-    if (!oldData && !newData) {
-      return false;
-    }
-
-    if (!oldData || !newData) {
-      return true;
-    }
-
-    return newData.version >= oldData.version && newData.variation !== oldData.variation;
-  }
+import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
+import {
+  IStoreDataStorage,
+  IStoreItem,
+  IKeyedStoreItem
+} from "../store/store";
+import { IStore } from "../platform/IStore";
+import { IDataKind } from "../IDataKind";
+import DataKinds from "../store/DataKinds";
+
+/**
+ * @internal
+ */
+export default class DataSourceUpdates implements IDataSourceUpdates {
+
+  constructor(
+    private readonly store: IStore,
+    private readonly hasEventListeners: () => boolean,
+    private readonly onChange: (keys: string[]) => void,
+  ) {
+  }
+
+  async init(userKeyId: string, allData: IStoreDataStorage, callback?: () => void): Promise<void> {
+    if (userKeyId !== this.store.user.keyId) {
+      callback?.();
+      return;
+    }
+
+    const checkForChanges = this.hasEventListeners();
+    const doInit = async (oldData?: IStoreDataStorage) => {
+      await this.store.init(allData);
+      Promise.resolve().then(() => {
+        if (checkForChanges) {
+          const updatedKeys = Object.keys(allData)
+            .flatMap((namespace) => {
+              const oldDataForKind = oldData?.[namespace] || {};
+              const newDataForKind = allData[namespace];
+              const mergedData = {...oldDataForKind, ...newDataForKind};
+              return Object.keys(mergedData)
+                .filter((key: string) => this.isUpdated(oldDataForKind && oldDataForKind[key], newDataForKind && newDataForKind[key]));
+            });
+          updatedKeys.length > 0 && this.onChange(updatedKeys);
+        }
+      });
+      callback?.();
+    };
+
+    if (checkForChanges) {
+      const [flags, version] = this.store.all(DataKinds.Flags);
+      const oldData = {
+        flags,
+        version
+      };
+      await doInit(oldData);
+    } else {
+      await doInit();
+    }
+  }
+
+  checkUpdates(oldData: IStoreDataStorage, newData: IStoreDataStorage, callback?: () => void): void {
+    const checkForChanges = this.hasEventListeners();
+
+    if (!checkForChanges) {
+      return;
+    }
+
+    const updatedKeys = Object.keys(newData)
+    .flatMap((namespace) => {
+      const oldDataForKind = oldData?.[namespace] || {};
+      const newDataForKind = newData[namespace];
+      const mergedData = {...oldDataForKind, ...newDataForKind};
+      return Object.keys(mergedData)
+      .filter((key: string) => this.isUpdated(oldDataForKind && oldDataForKind[key], newDataForKind && newDataForKind[key]));
+    });
+    updatedKeys.length > 0 && this.onChange(updatedKeys);
+
+    callback?.();
+  }
+
+  async upsert(userKeyId: string, kind: IDataKind, data: IKeyedStoreItem, callback: () => void): Promise<void> {
+    if (userKeyId !== this.store.user.keyId) {
+      callback?.();
+      return;
+    }
+
+    const {key} = data;
+    const checkForChanges = this.hasEventListeners();
+    const doUpsert = async (oldItem?: IStoreItem) => {
+      await this.store.upsert(kind, data);
+      Promise.resolve().then(() => {
+        if (checkForChanges && this.isUpdated(oldItem, data[key])) {
+          this.onChange([key]);
+        }
+      });
+
+      callback?.();
+    };
+    if (checkForChanges) {
+      const item = this.store.get(kind, key);
+      await doUpsert(item || undefined);
+    } else {
+      await doUpsert();
+    }
+  }
+
+  private isUpdated(oldData?: IStoreItem, newData?: IStoreItem): boolean {
+    if (!oldData && !newData) {
+      return false;
+    }
+
+    if (!oldData || !newData) {
+      return true;
+    }
+
+    return newData.version >= oldData.version && newData.variation !== oldData.variation;
+  }
 }

package/src/data-sources/createStreamListeners.ts

@@ -1,67 +1,67 @@
-import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
-import { ILogger } from "../logging/ILogger";
-import { VoidFunction } from "../utils/VoidFunction";
-import {
-  deserializeAll,
-  deserializePatch,
-  IPatchData,
-  Flags
-} from "../store/serialization";
-import { IStoreDataStorage } from "../store/store";
-import { EventName, ProcessStreamResponse } from "../data-sync/types";
-
-const createPutListener = (
-  dataSourceUpdates: IDataSourceUpdates,
-  logger?: ILogger,
-  onPutCompleteHandler: VoidFunction = () => {
-  },
-) => ({
-  deserializeData: deserializeAll,
-  processJson: async (userKeyId: string, {flags}: Flags) => {
-    const initData: IStoreDataStorage = {
-      flags: flags,
-      version: 0
-    };
-
-    logger?.debug('Initializing all data');
-    await dataSourceUpdates.init(userKeyId, initData, onPutCompleteHandler);
-  },
-});
-
-const createPatchListener = (
-  dataSourceUpdates: IDataSourceUpdates,
-  logger?: ILogger,
-  onPatchCompleteHandler: VoidFunction = () => {
-  },
-) => ({
-  deserializeData: deserializePatch,
-  processJson: async (userKeyId: string, data: IPatchData[]) => {
-    if (data?.length === 0) {
-      onPatchCompleteHandler?.();
-      return;
-    }
-
-    if (data?.length > 0) {
-      for(const item of data) {
-        logger?.debug(`Updating ${ item.data.key } in ${ item.kind.namespace }`);
-        await dataSourceUpdates.upsert(userKeyId, item.kind, item.data, onPatchCompleteHandler);
-      }
-    }
-  },
-});
-
-
-export const createStreamListeners = (
-  dataSourceUpdates: IDataSourceUpdates,
-  logger?: ILogger,
-  onCompleteHandlers?: {
-    put?: VoidFunction;
-    patch?: VoidFunction;
-    delete?: VoidFunction;
-  },
-) => {
-  const listeners = new Map<EventName, ProcessStreamResponse>();
-  listeners.set('put', createPutListener(dataSourceUpdates, logger, onCompleteHandlers?.put));
-  listeners.set('patch', createPatchListener(dataSourceUpdates, logger, onCompleteHandlers?.patch));
-  return listeners;
-};
+import { IDataSourceUpdates } from "../store/IDataSourceUpdates";
+import { ILogger } from "../logging/ILogger";
+import { VoidFunction } from "../utils/VoidFunction";
+import {
+  deserializeAll,
+  deserializePatch,
+  IPatchData,
+  Flags
+} from "../store/serialization";
+import { IStoreDataStorage } from "../store/store";
+import { EventName, ProcessStreamResponse } from "../data-sync/types";
+
+const createPutListener = (
+  dataSourceUpdates: IDataSourceUpdates,
+  logger?: ILogger,
+  onPutCompleteHandler: VoidFunction = () => {
+  },
+) => ({
+  deserializeData: deserializeAll,
+  processJson: async (userKeyId: string, {flags}: Flags) => {
+    const initData: IStoreDataStorage = {
+      flags: flags,
+      version: 0
+    };
+
+    logger?.debug('Initializing all data');
+    await dataSourceUpdates.init(userKeyId, initData, onPutCompleteHandler);
+  },
+});
+
+const createPatchListener = (
+  dataSourceUpdates: IDataSourceUpdates,
+  logger?: ILogger,
+  onPatchCompleteHandler: VoidFunction = () => {
+  },
+) => ({
+  deserializeData: deserializePatch,
+  processJson: async (userKeyId: string, data: IPatchData[]) => {
+    if (data?.length === 0) {
+      onPatchCompleteHandler?.();
+      return;
+    }
+
+    if (data?.length > 0) {
+      for(const item of data) {
+        logger?.debug(`Updating ${ item.data.key } in ${ item.kind.namespace }`);
+        await dataSourceUpdates.upsert(userKeyId, item.kind, item.data, onPatchCompleteHandler);
+      }
+    }
+  },
+});
+
+
+export const createStreamListeners = (
+  dataSourceUpdates: IDataSourceUpdates,
+  logger?: ILogger,
+  onCompleteHandlers?: {
+    put?: VoidFunction;
+    patch?: VoidFunction;
+    delete?: VoidFunction;
+  },
+) => {
+  const listeners = new Map<EventName, ProcessStreamResponse>();
+  listeners.set('put', createPutListener(dataSourceUpdates, logger, onCompleteHandlers?.put));
+  listeners.set('patch', createPatchListener(dataSourceUpdates, logger, onCompleteHandlers?.patch));
+  return listeners;
+};

package/src/data-sources/index.ts

@@ -1,2 +1,2 @@
-export * from './createStreamListeners';
+export * from './createStreamListeners';
 export * from './DataSourceUpdates';

package/src/data-sync/DataSyncMode.ts

@@ -1,4 +1,4 @@
-export enum DataSyncModeEnum {
-  POLLING = 'polling',
-  STREAMING = 'streaming'
+export enum DataSyncModeEnum {
+  POLLING = 'polling',
+  STREAMING = 'streaming'
 }

package/src/data-sync/IDataSynchronizer.ts

@@ -1,15 +1,15 @@
-import { IUser } from "../options/IUser";
-
-/**
- * The client data synchronizer
- *
- * The client uses this internally to retrieve updates from the FeatBit server.
- *
- * @ignore
- */
-export interface IDataSynchronizer {
-  start: () => void;
-  stop: () => void;
-  close: () => void;
-  identify: (user: IUser) => Promise<void>;
-}
+import { IUser } from "../options/IUser";
+
+/**
+ * The client data synchronizer
+ *
+ * The client uses this internally to retrieve updates from the FeatBit server.
+ *
+ * @ignore
+ */
+export interface IDataSynchronizer {
+  start: () => void;
+  stop: () => void;
+  close: () => void;
+  identify: (user: IUser) => Promise<void>;
+}

package/src/data-sync/IRequestor.ts

@@ -1,10 +1,10 @@
-/**
- * The FeatBit client feature flag requestor
- *
- * The client uses this internally to retrieve feature flags from FeatBit.
- *
- * @ignore
- */
-export interface IRequestor {
-  requestData: (timestamp: number, payload: any, cb: (err: any, body: any) => void) => void;
-}
+/**
+ * The FeatBit client feature flag requestor
+ *
+ * The client uses this internally to retrieve feature flags from FeatBit.
+ *
+ * @ignore
+ */
+export interface IRequestor {
+  requestData: (timestamp: number, payload: any, cb: (err: any, body: any) => void) => void;
+}

package/src/data-sync/NullDataSynchronizer.ts

@@ -1,15 +1,15 @@
-import { IDataSynchronizer } from "./IDataSynchronizer";
-
-export class NullDataSynchronizer implements IDataSynchronizer {
-  close(): void {
-  }
-
-  start(): void {
-  }
-
-  stop(): void {
-  }
-
-  async identify(): Promise<void> {
-  }
+import { IDataSynchronizer } from "./IDataSynchronizer";
+
+export class NullDataSynchronizer implements IDataSynchronizer {
+  close(): void {
+  }
+
+  start(): void {
+  }
+
+  stop(): void {
+  }
+
+  async identify(): Promise<void> {
+  }
 }