feat: update svelte sdk to use browser 4.x

packages/sdk/svelte/__tests__/lib/client/SvelteLDClient.test.ts

@@ -2,11 +2,11 @@ import { EventEmitter } from 'node:events';
 import { get } from 'svelte/store';
 import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
 
-import { initialize, LDClient } from '@launchdarkly/js-client-sdk/compat';
+import { createClient, LDClient } from '@launchdarkly/js-client-sdk';
 
 import { LD } from '../../../src/lib/client/SvelteLDClient';
 
-vi.mock('@launchdarkly/js-client-sdk/compat', { spy: true });
+vi.mock('@launchdarkly/js-client-sdk', { spy: true });
 
 const clientSideID = 'test-client-side-id';
 const rawFlags = { 'test-flag': true, 'another-test-flag': 'flag-value' };
@@ -21,6 +21,7 @@ const mockLDClient = {
   allFlags: vi.fn().mockReturnValue(rawFlags),
   variation: vi.fn((_, defaultValue) => defaultValue),
   identify: vi.fn(),
+  start: vi.fn(),
 };
 
 describe('launchDarkly', () => {
@@ -40,8 +41,7 @@ describe('launchDarkly', () => {
       const ld = LD;
 
       beforeEach(() => {
-        // mocks the initialize function to return the mockLDClient
-        (initialize as Mock<typeof initialize>).mockReturnValue(
+        (createClient as Mock<typeof createClient>).mockReturnValue(
           mockLDClient as unknown as LDClient,
         );
       });
@@ -66,23 +66,23 @@ describe('launchDarkly', () => {
         ld.initialize(clientSideID, mockContext);
 
         expect(get(initializing)).toBe(true); // should be true before the ready event is emitted
-        mockLDEventEmitter.emit('ready');
+        mockLDEventEmitter.emit('initialized');
 
         expect(get(initializing)).toBe(false);
       });
 
       it('should initialize the LaunchDarkly SDK instance', () => {
         ld.initialize(clientSideID, mockContext);
 
-        expect(initialize).toHaveBeenCalledWith('test-client-side-id', mockContext);
+        expect(createClient).toHaveBeenCalledWith('test-client-side-id', mockContext, undefined);
       });
 
       it('should register function that gets flag values when client is ready', () => {
         const newFlags = { ...rawFlags, 'new-flag': true };
         const allFlagsSpy = vi.spyOn(mockLDClient, 'allFlags').mockReturnValue(newFlags);
 
         ld.initialize(clientSideID, mockContext);
-        mockLDEventEmitter.emit('ready');
+        mockLDEventEmitter.emit('initialized');
 
         expect(allFlagsSpy).toHaveBeenCalledOnce();
         expect(allFlagsSpy).toHaveReturnedWith(newFlags);
@@ -104,8 +104,7 @@ describe('launchDarkly', () => {
       const ld = LD;
 
       beforeEach(() => {
-        // mocks the initialize function to return the mockLDClient
-        (initialize as Mock<typeof initialize>).mockReturnValue(
+        (createClient as Mock<typeof createClient>).mockReturnValue(
           mockLDClient as unknown as LDClient,
         );
       });
@@ -132,7 +131,7 @@ describe('launchDarkly', () => {
         const flagStore2 = ld.watch(stringFlagKey);
 
         // emit ready event to set initial flag values
-        mockLDEventEmitter.emit('ready');
+        mockLDEventEmitter.emit('initialized');
 
         // 'test-flag' initial value is true according to `rawFlags`
         expect(get(flagStore)).toBe(true);
@@ -166,8 +165,7 @@ describe('launchDarkly', () => {
       const ld = LD;
 
       beforeEach(() => {
-        // mocks the initialize function to return the mockLDClient
-        (initialize as Mock<typeof initialize>).mockReturnValue(
+        (createClient as Mock<typeof createClient>).mockReturnValue(
           mockLDClient as unknown as LDClient,
         );
       });
@@ -191,8 +189,7 @@ describe('launchDarkly', () => {
       const ld = LD;
 
       beforeEach(() => {
-        // mocks the initialize function to return the mockLDClient
-        (initialize as Mock<typeof initialize>).mockReturnValue(
+        (createClient as Mock<typeof createClient>).mockReturnValue(
           mockLDClient as unknown as LDClient,
         );
       });

packages/sdk/svelte/src/lib/client/SvelteLDClient.ts

@@ -1,12 +1,13 @@
 import { derived, type Readable, readonly, writable, type Writable } from 'svelte/store';
 
-import type { LDFlagSet } from '@launchdarkly/js-client-sdk';
 import {
-  initialize,
+  createClient as createClientSdk,
   type LDClient,
   type LDContext,
+  type LDFlagSet,
   type LDFlagValue,
-} from '@launchdarkly/js-client-sdk/compat';
+  type LDOptions,
+} from '@launchdarkly/js-client-sdk';
 
 export type { LDContext, LDFlagValue };
 
@@ -62,35 +63,38 @@
  * Creates a LaunchDarkly instance.
  * @returns {Object} The LaunchDarkly instance object.
  */
-function createLD() {
+function init() {
   let coreLdClient: LDClient | undefined;
-  const loading = writable(true);
   const flagsWritable = writable<LDFlags>({});
+  const initializeResult = writable<string>('pending');
 
   /**
    * Initializes the LaunchDarkly client.
    * @param {LDClientID} clientId - The client ID.
    * @param {LDContext} context - The user context.
    * @returns {Object} An object with the initialization status store.
    */
-  function LDInitialize(clientId: LDClientID, context: LDContext) {
-    coreLdClient = initialize(clientId, context);
-    coreLdClient!.on('ready', () => {
-      loading.set(false);
-      const rawFlags = coreLdClient!.allFlags();
-      const allFlags = toFlagsProxy(coreLdClient!, rawFlags);
-      flagsWritable.set(allFlags);
-    });
+  function initialize(clientId: LDClientID, context: LDContext, options?: LDOptions) {
+    coreLdClient = createClientSdk(clientId, context, options);
 
-    coreLdClient!.on('change', () => {
+    coreLdClient.on('change', () => {
       const rawFlags = coreLdClient!.allFlags();
       const allFlags = toFlagsProxy(coreLdClient!, rawFlags);
       flagsWritable.set(allFlags);
     });
 
-    return {
-      initializing: loading,
-    };
+    // TODO: currently all options are defaulted which means that the client initailization will timeout in 5 seconds.
+    // we will need to address this before this SDK is marked as stable.
+    void coreLdClient.start();
+    void coreLdClient.waitForInitialization()
+      .then((result) => {
+        initializeResult.set(result.status);
+      })
+      .catch(() => {
+        // NOTE: this should never happen as we don't throw errors from initialization.
+        options?.logger?.error('Failed to initialize LaunchDarkly client');
+        initializeResult.set('failed');
+      });
   }
 
   /**
@@ -125,12 +129,12 @@
   return {
     identify,
     flags: readonly(flagsWritable),
-    initialize: LDInitialize,
-    initializing: readonly(loading),
+    initialize,
+    initalizationState: readonly(initializeResult),
     watch,
     useFlag,
   };
 }
 
 /** The LaunchDarkly instance */
-export const LD = createLD();
+export const LD = init();

packages/sdk/svelte/src/lib/provider/LDProvider.svelte

@@ -5,15 +5,17 @@
 
 	export let clientID: LDClientID;
 	export let context: LDContext;
-	const { initialize, initializing } = LD;
+	const { initialize, initalizationState } = LD;
 
 	onMount(() => {
 		initialize(clientID, context);
 	});
 </script>
 
-{#if $$slots.initializing && $initializing}
+{#if $$slots.initializing && $initalizationState === 'pending'}
 	<slot name="initializing">Loading flags (default loading slot value)...</slot>
-{:else}
+{:else if $initalizationState === 'complete'}
 	<slot />
+{:else}
+	<slot name="failed">Failed to initialize LaunchDarkly client ({$initalizationState})</slot>
 {/if}