feat: Add client-side SDK plugin support. (#834)

Adds plugin support for react native and browser.

Types are common, as well as most functionality, but SDK specific
implementation is required. This is because the leaf-node SDKs have
different types for the LDClient. Also the SDK needs control over the
ordering of operations that happen during construction in order to
register plugins at the correct point.

There is a bit more complexity in this implementation than would be
required for most SDKs. Some refactoring of the base client
implementation, potentially to use composition instead of inheritance,
may allow for some better sharing here in the long-term.

Initially I tried using generics in the base implementation, to account
for the different client implementations, but this introduced a lot of
changes to all the layers and didn't play well with configuration, which
also then needs to be generic.

The approach I took was to have the configuration in the individual SDKs
and then use generics for utility methods to collect hooks and register
plugins. In the long-term this would also benefit from the base
implementation using generics for the configuration, which would allow a
shared configuration and validation.

Author: kinyoklion

packages/sdk/browser/__tests__/BrowserClient.mocks.ts

@@ -0,0 +1,117 @@
+import {
+  EventSourceCapabilities,
+  EventSourceInitDict,
+  Platform,
+  PlatformData,
+  Requests,
+  SdkData,
+} from '@launchdarkly/js-client-sdk-common';
+
+import { BrowserOptions } from '../src/options';
+import { MockHasher } from './MockHasher';
+
+function mockResponse(value: string, statusCode: number) {
+  const response: Response = {
+    // @ts-ignore
+    headers: {
+      // @ts-ignore
+      get: jest.fn(),
+      // @ts-ignore
+      keys: jest.fn(),
+      // @ts-ignore
+      values: jest.fn(),
+      // @ts-ignore
+      entries: jest.fn(),
+      // @ts-ignore
+      has: jest.fn(),
+    },
+    status: statusCode,
+    text: () => Promise.resolve(value),
+    json: () => Promise.resolve(JSON.parse(value)),
+  };
+  return Promise.resolve(response);
+}
+
+function mockFetch(value: string, statusCode: number = 200) {
+  const f = jest.fn();
+  // @ts-ignore
+  f.mockResolvedValue(mockResponse(value, statusCode));
+  return f;
+}
+
+export function makeRequests(): Requests {
+  return {
+    // @ts-ignore
+    fetch: jest.fn((url: string, _options: any) => {
+      if (url.includes('/sdk/goals/')) {
+        return mockFetch(
+          JSON.stringify([
+            {
+              key: 'pageview',
+              kind: 'pageview',
+              urls: [{ kind: 'exact', url: 'http://browserclientintegration.com' }],
+            },
+            {
+              key: 'click',
+              kind: 'click',
+              selector: '.button',
+              urls: [{ kind: 'exact', url: 'http://browserclientintegration.com' }],
+            },
+          ]),
+          200,
+        )();
+      }
+      return mockFetch('{ "flagA": true }', 200)();
+    }),
+    // @ts-ignore
+    createEventSource(_url: string, _eventSourceInitDict: EventSourceInitDict): EventSource {
+      throw new Error('Function not implemented.');
+    },
+    getEventSourceCapabilities(): EventSourceCapabilities {
+      return {
+        readTimeout: false,
+        headers: false,
+        customMethod: false,
+      };
+    },
+  };
+}
+
+export function makeBasicPlatform(options?: BrowserOptions): Platform {
+  return {
+    requests: makeRequests(),
+    info: {
+      platformData(): PlatformData {
+        return {
+          name: 'browser',
+        };
+      },
+      sdkData(): SdkData {
+        const sdkData: SdkData = {
+          name: 'browser-sdk',
+          version: '1.0.0',
+          userAgentBase: 'MockBrowserSDK',
+        };
+        if (options?.wrapperName) {
+          sdkData.wrapperName = options.wrapperName;
+        }
+        if (options?.wrapperVersion) {
+          sdkData.wrapperVersion = options.wrapperVersion;
+        }
+        return sdkData;
+      },
+    },
+    crypto: {
+      createHash: () => new MockHasher(),
+      randomUUID: () => '123',
+    },
+    storage: {
+      get: async (_key: string) => null,
+      set: async (_key: string, _value: string) => {},
+      clear: async (_key: string) => {},
+    },
+    encoding: {
+      btoa: (str: string) => str,
+    },
+  } as Platform;
+}