launchdarkly-js-sdk-common 5.0.0-alpha.1 → 5.0.0-alpha.2

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to the `launchdarkly-js-sdk-common` package will be documented in this file. Changes that affect the dependent SDKs such as `launchdarkly-js-client-sdk` should also be logged in those projects, in the next release that uses the updated version of this package. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [4.3.2] - 2022-10-20
+### Added:
+- Implemented `jitter` and `backoff` for streaming connections. When a connection fails the retry will start at the `streamReconnectDelay` and will double on each unsuccessful consecutive connection attempt (`backoff`) to a max of 30 seconds. The delay will be adjusted from 50%-100% of the calculated delay to prevent many clients from attempting to reconnect at the same time (`jitter`).
+
+### Changed:
+- Removed usage of `flatMap`. (Thanks [@mateuszsikora](https://github.com/launchdarkly/js-sdk-common/pull/77))
+
 ## [4.3.1] - 2022-10-17
 ### Fixed:
 - Fixed an issue that prevented the `flag-used` inspector from being called.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchdarkly-js-sdk-common",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.2",
   "description": "LaunchDarkly SDK for JavaScript - common code",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",

package/src/ContextFilter.js

@@ -41,12 +41,6 @@ function ContextFilter(config) {
       cloned._meta.redactedAttributes = excluded;
     }
     if (cloned._meta) {
-      if (cloned._meta.secondary === null) {
-        delete cloned._meta.secondary;
-      }
-      if (cloned._meta.secondary !== undefined) {
-        cloned._meta.secondary = String(cloned._meta.secondary);
-      }
       delete cloned._meta['privateAttributes'];
       if (Object.keys(cloned._meta).length === 0) {
         delete cloned._meta;
@@ -123,10 +117,6 @@ function ContextFilter(config) {
         literal => (literal.startsWith('/') ? AttributeReference.literalToReference(literal) : literal)
       );
     }
-    if (user.secondary !== undefined && user.secondary !== null) {
-      filtered._meta = filtered._meta || {};
-      filtered._meta.secondary = String(user.secondary);
-    }
 
     return filtered;
   };

package/src/InspectorManager.js

@@ -1,4 +1,4 @@
-const { messages } = require('.');
+const messages = require('./messages');
 const SafeInspector = require('./SafeInspector');
 const { onNextTick } = require('./utils');
 

package/src/SafeInspector.js

@@ -1,4 +1,4 @@
-const { messages } = require('.');
+const messages = require('./messages');
 
 /**
  * Wrap an inspector ensuring that calling its methods are safe.

package/src/__tests__/ContextFilter-test.js

@@ -216,22 +216,6 @@ describe('when handling single kind contexts', () => {
     dizzle: 'ghi',
   };
 
-  const contextWithNonStringKeyKeyAndSecondary = {
-    kind: 'rebel',
-    key: 42,
-    _meta: {
-      secondary: 0,
-    },
-  };
-
-  const contextWithNullSecondary = {
-    kind: 'rebel',
-    key: 42,
-    _meta: {
-      secondary: null,
-    },
-  };
-
   // expected results from serializing context
   const userWithAllAttrsHidden = {
     kind: 'organization',
@@ -269,19 +253,6 @@ describe('when handling single kind contexts', () => {
     },
   };
 
-  const contextWithStringifiedKeyKeyAndSecondary = {
-    kind: 'rebel',
-    key: '42',
-    _meta: {
-      secondary: '0',
-    },
-  };
-
-  const contextWithNullSecondaryFiltered = {
-    kind: 'rebel',
-    key: '42',
-  };
-
   it('includes all attributes by default', () => {
     const uf = ContextFilter({});
     expect(uf.filter(context)).toEqual(context);
@@ -312,16 +283,6 @@ describe('when handling single kind contexts', () => {
     expect(uf.filter(anonymousContext)).toEqual(contextWithAllAttrsHidden);
   });
 
-  it('handles non-string key and secondary', () => {
-    const uf = ContextFilter({ allAttributesPrivate: true });
-    expect(uf.filter(contextWithNonStringKeyKeyAndSecondary)).toEqual(contextWithStringifiedKeyKeyAndSecondary);
-  });
-
-  it('does not produce "null" as a secondary attribute', () => {
-    const cf = ContextFilter({});
-    expect(cf.filter(contextWithNullSecondary)).toEqual(contextWithNullSecondaryFiltered);
-  });
-
   it('converts non-boolean anonymous to boolean.', () => {
     const uf = ContextFilter({});
     expect(uf.filter({ kind: 'user', key: 'user', anonymous: 'string' })).toEqual({
@@ -376,7 +337,6 @@ describe('when handling mult-kind contexts', () => {
         b: 'b',
       },
       _meta: {
-        secondary: 'order',
         privateAttributes: ['letters', '/object/b'],
       },
     },
@@ -393,7 +353,6 @@ describe('when handling mult-kind contexts', () => {
     user: {
       key: 'abc',
       _meta: {
-        secondary: 'order',
         redactedAttributes: ['/letters', '/name', '/object', '/order'],
       },
     },
@@ -418,7 +377,6 @@ describe('when handling mult-kind contexts', () => {
         a: 'a',
       },
       _meta: {
-        secondary: 'order',
         redactedAttributes: ['/letters', '/name', '/object/b'],
       },
     },
@@ -442,7 +400,6 @@ describe('when handling mult-kind contexts', () => {
         a: 'a',
       },
       _meta: {
-        secondary: 'order',
         redactedAttributes: ['/letters', '/object/b'],
       },
     },

package/src/__tests__/testUtils.js

@@ -2,7 +2,6 @@ import { AsyncQueue } from 'launchdarkly-js-test-helpers';
 
 export const numericUser = {
   key: 1,
-  secondary: 2,
   ip: 3,
   country: 4,
   email: 5,
@@ -33,7 +32,6 @@ export function promiseListener() {
 
 export const stringifiedNumericUser = {
   key: '1',
-  secondary: '2',
   ip: '3',
   country: '4',
   email: '5',

package/src/utils.js

@@ -1,7 +1,7 @@
 const base64 = require('base64-js');
 const fastDeepEqual = require('fast-deep-equal');
 
-const userAttrsToStringify = ['key', 'secondary', 'ip', 'country', 'email', 'firstName', 'lastName', 'avatar', 'name'];
+const userAttrsToStringify = ['key', 'ip', 'country', 'email', 'firstName', 'lastName', 'avatar', 'name'];
 
 function appendUrlPath(baseUrl, path) {
   // Ensure that URL concatenation is done correctly regardless of whether the

package/test-types.ts

@@ -9,7 +9,6 @@ var anonUserWithNoKey: ld.LDUser = { anonymous: true };
 var anonUserWithKey: ld.LDUser = { key: 'anon-user', anonymous: true };
 var user: ld.LDContext = {
   key: 'user',
-  secondary: 'otherkey',
   name: 'name',
   firstName: 'first',
   lastName: 'last',

package/typings.d.ts

@@ -58,8 +58,8 @@ declare module 'launchdarkly-js-sdk-common' {
      * The initial set of flags to use until the remote set is retrieved.
      *
      * If `"localStorage"` is specified, the flags will be saved and retrieved from browser local
-     * storage. Alternatively, an [[LDFlagSet]] can be specified which will be used as the initial
-     * source of flag values. In the latter case, the flag values will be available via [[variation]]
+     * storage. Alternatively, an {@link LDFlagSet} can be specified which will be used as the initial
+     * source of flag values. In the latter case, the flag values will be available via {@link LDClient.variation}
      * immediately after calling `initialize()` (normally they would not be available until the
      * client signals that it is ready).
      *
@@ -93,7 +93,7 @@ declare module 'launchdarkly-js-sdk-common' {
      *
      * If this is true, the client will always attempt to maintain a streaming connection; if false,
      * it never will. If you leave the value undefined (the default), the client will open a streaming
-     * connection if you subscribe to `"change"` or `"change:flag-key"` events (see [[LDClient.on]]).
+     * connection if you subscribe to `"change"` or `"change:flag-key"` events (see {@link LDClient.on}).
      *
      * This is equivalent to calling `client.setStreaming()` with the same value.
      */
@@ -139,7 +139,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * calculated.
      *
      * The additional information will then be available through the client's
-     * [[LDClient.variationDetail]] method. Since this increases the size of network requests,
+     * {@link LDClient.variationDetail} method. Since this increases the size of network requests,
      * such information is not sent unless you set this option to true.
      */
     evaluationReasons?: boolean;
@@ -158,9 +158,21 @@ declare module 'launchdarkly-js-sdk-common' {
     allAttributesPrivate?: boolean;
 
     /**
-     * The names of context attributes that should be marked as private, and not sent
-     * to LaunchDarkly in analytics events. You can also specify this on a per-context basis
-     * with [[LDContextMeta.privateAttributes]].
+     * Specifies a list of attribute names (either built-in or custom) which should be marked as
+     * private, and not sent to LaunchDarkly in analytics events. You can also specify this on a
+     * per-context basis with {@link LDContextMeta.privateAttributes}.
+     * 
+     * Any contexts sent to LaunchDarkly with this configuration active will have attributes with
+     * these names removed in analytic events. This is in addition to any attributes that were
+     * marked as private for an individual context with {@link LDContextMeta.privateAttributes}.
+     * Setting {@link LDOptions.allAttributesPrivate} to true overrides this.
+     * 
+     * If and only if a parameter starts with a slash, it is interpreted as a slash-delimited path
+     * that can denote a nested property within a JSON object. For instance, "/address/street" means
+     * that if there is an attribute called "address" that is a JSON object, and one of the object's
+     * properties is "street", the "street" property will be redacted from the analytics data but
+     * other properties within "address" will still be sent. This syntax also uses the JSON Pointer
+     * convention of escaping a literal slash character as "~1" and a tilde as "~0".
      */
     privateAttributes?: Array<string>;
 
@@ -197,7 +209,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * How long (in milliseconds) to wait after a failure of the stream connection before trying to
      * reconnect.
      *
-     * This only applies if streaming has been enabled by setting [[streaming]] to true or
+     * This only applies if streaming has been enabled by setting {@link streaming} to true or
      * subscribing to `"change"` events. The default is 1000ms.
      */
     streamReconnectDelay?: number;
@@ -216,7 +228,7 @@ declare module 'launchdarkly-js-sdk-common' {
     /**
      * The interval at which periodic diagnostic data is sent, in milliseconds.
      *
-     * The default is 900000 (every 15 minutes) and the minimum value is 6000. See [[diagnosticOptOut]]
+     * The default is 900000 (every 15 minutes) and the minimum value is 6000. See {@link diagnosticOptOut}
      * for more information on the diagnostics data being sent.
      */
     diagnosticRecordingInterval?: number;
@@ -239,7 +251,7 @@ declare module 'launchdarkly-js-sdk-common' {
     /**
      * Information about the application where the LaunchDarkly SDK is running.
      */
-     application?: {
+    application?: {
       /**
        * A unique identifier representing the application where the LaunchDarkly SDK is running.
        * 
@@ -268,105 +280,164 @@ declare module 'launchdarkly-js-sdk-common' {
   }
 
   /**
-   * 
-   * TKTK
-   * 
    * Meta attributes are used to control behavioral aspects of the Context.
-   * They cannot be addressed in targetting rules.
+   * They cannot be addressed in targeting rules.
    */
-   export interface LDContextMeta {
-    /**
-     * An optional secondary key for a context.
-     *
-     * TKTK
-     * 
-     * This affects [feature flag targeting](https://docs.launchdarkly.com/home/flags/targeting-users#targeting-rules-based-on-user-attributes) 
-     * as follows: if you have chosen to bucket context by a specific attribute, the secondary key (if set)
-     * is used to further distinguish between contexts which are otherwise identical according to that attribute.
-     */
-    secondary?: string;
+  export interface LDContextMeta {
 
     /**
      * 
-     * TKTK
+     * Designate any number of Context attributes, or properties within them, as private: that is,
+     * their values will not be sent to LaunchDarkly in analytics events.
      * 
-     * Specifies a list of attribute names (either built-in or custom) which should be
-     * marked as private, and not sent to LaunchDarkly in analytics events. This is in
-     * addition to any private attributes designated in the global configuration
-     * with [[LDOptions.privateAttributes]] or [[LDOptions.allAttributesPrivate]].
+     * Each parameter can be a simple attribute name, such as "email". Or, if the first character is
+     * a slash, the parameter is interpreted as a slash-delimited path to a property within a JSON
+     * object, where the first path component is a Context attribute name and each following
+     * component is a nested property name: for example, suppose the attribute "address" had the
+     * following JSON object value:
+     * 
+     * ```
+     * 	{"street": {"line1": "abc", "line2": "def"}}
+     * ```
+     * 
+     * Using ["/address/street/line1"] in this case would cause the "line1" property to be marked as
+     * private. This syntax deliberately resembles JSON Pointer, but other JSON Pointer features
+     * such as array indexing are not supported for Private.
+     * 
+     * This action only affects analytics events that involve this particular Context. To mark some
+     * (or all) Context attributes as private for all users, use the overall configuration for the
+     * SDK.
+     * See {@link LDOptions.allAttributesPrivate} and {@link LDOptions.privateAttributes}.
+     * 
+     * The attributes "kind" and "key", and the "_meta" attributes cannot be made private.
+     * 
+     * In this example, firstName is marked as private, but lastName is not:
+     * 
+     * ```
+     * const context = {
+     *   kind: 'org',
+     *   key: 'my-key',
+     *   firstName: 'Pierre',
+     *   lastName: 'Menard',
+     *   _meta: {
+     *     privateAttributes: ['firstName'], 
+     *   }
+     * };
+     * ```
+     * 
+     * This is a metadata property, rather than an attribute that can be addressed in evaluations:
+     * that is, a rule clause that references the attribute name "privateAttributes", will not use
+     * this value, but instead will use whatever value (if any) you have set for that name with a
+     * method such as SetString.
      */
     privateAttributes?: string[];
   }
 
   /**
-   * TKTK
+   * Interface containing elements which are common to both single kind contexts as well as the
+   * parts that compose a multi context. For more information see {@link LDSingleKindContext} and
+   * {@link LDMultiKindContext}.
    */
   interface LDContextCommon {
-      /**
-       * If true, the context will _not_ appear on the Contexts page in the LaunchDarkly dashboard.
-       */
-      anonymous?: boolean;
+    /**
+     * If true, the context will _not_ appear on the Contexts page in the LaunchDarkly dashboard.
+     */
+    anonymous?: boolean;
 
-      /**
-       * A unique string identifying a context.
-       */
-      key: string;
+    /**
+     * A unique string identifying a context.
+     */
+    key: string;
 
-      /**
-       * The context's name.
-       *
-       * You can search for contexts on the Contexts page by name.
-       */
-      name?: string;
+    /**
+     * The context's name.
+     *
+     * You can search for contexts on the Contexts page by name.
+     */
+    name?: string;
 
-      /**
-       * 
-       * TODO: U2C We will need some uniform description for this.
-       * 
-       * Meta attributes are used to control behavioral aspects of the Context.
-       * They cannot be addressed in targetting rules.
-       */
-      _meta?: LDContextMeta;
+    /**
+     * Meta attributes are used to control behavioral aspects of the Context, such as private
+     * private attributes. See {@link LDContextMeta.privateAttributes} as an example.
+     *
+     * They cannot be addressed in targeting rules.
+     */
+    _meta?: LDContextMeta;
 
-      /**
-       * Any additional attributes associated with the context.
-       */
-      [attribute: string]: any;
+    /**
+     * Any additional attributes associated with the context.
+     */
+    [attribute: string]: any;
   }
 
 
   /**
+   * A context which represents a single kind.
+   * 
+   * For a single kind context the 'kind' may not be 'multi'.
    * 
-   * TTKTK
+   * ```
+   * const myOrgContext = {
+   *   kind: 'org',
+   *   key: 'my-org-key',
+   *   someAttribute: 'my-attribute-value'
+   * };
+   * ```
    * 
-   * A single-kind context.
+   * The above context would be a single kind context representing an organization. It has a key
+   * for that organization, and a single attribute 'someAttribute'.
    */
   interface LDSingleKindContext extends LDContextCommon {
-      /**
-       * The kind of the context.
-       */
-      kind: string;
+    /**
+     * The kind of the context.
+     */
+    kind: string;
   }
 
   /**
+   * A context which represents multiple kinds. Each kind having its own key and attributes.
    * 
-   * TKTK
+   * A multi-context must contain `kind: 'multi'` at the root.
+   * 
+   * ```
+   * const myMultiContext = {
+   *   // Multi-contexts must be of kind 'multi'.
+   *   kind: 'multi',
+   *   // The context is namespaced by its kind. This is an 'org' kind context.
+   *   org: {
+   *     // Each component context has its own key and attributes.
+   *     key: 'my-org-key',
+   *     someAttribute: 'my-attribute-value',
+   *   },
+   *   user: {
+   *     key: 'my-user-key',
+   *     firstName: 'Bob',
+   *     lastName: 'Bobberson',
+   *     _meta: {
+   *       // Each component context has its own _meta attributes. This will only apply the this
+   *       // 'user' context.
+   *       privateAttributes: ['firstName']
+   *     }
+   *   }
+   * };
+   * ```
    * 
-   * A multi-kind context.
+   * The above multi-context contains both an 'org' and a 'user'. Each with their own key,
+   * attributes, and _meta attributes.
    */
   interface LDMultiKindContext {
-      /**
-       * The kind of the context.
-       */
-      kind: "multi",
+    /**
+     * The kind of the context.
+     */
+    kind: "multi",
 
-      /**
-       * The contexts which compose this multi-kind context.
-       * 
-       * These should be of type LDContextCommon. "multi" is to allow
-       * for the top level "kind" attribute.
-       */
-      [kind: string]: "multi" | LDContextCommon;
+    /**
+     * The contexts which compose this multi-kind context.
+     * 
+     * These should be of type LDContextCommon. "multi" is to allow
+     * for the top level "kind" attribute.
+     */
+    [kind: string]: "multi" | LDContextCommon;
   }
 
   /**
@@ -376,6 +447,36 @@ declare module 'launchdarkly-js-sdk-common' {
 
   /**
    * A LaunchDarkly user object.
+   *
+   * @deprecated
+   * The LDUser object is currently supported for ease of upgrade.
+   * In order to convert an LDUser into a LDSingleKindContext the following changes should
+   * be made.
+   * 
+   * 1.) Add a kind to the object. `kind: 'user'`.
+   * 
+   * 2.) Move custom attributes to the top level of the object.
+   * 
+   * 3.) Move `privateAttributeNames` to `_meta.privateAttributes`.
+   * 
+   * ```
+   * const LDUser: user = {
+   *   key: '1234',
+   *   privateAttributeNames: ['myAttr']
+   *   custom: {
+   *     myAttr: 'value'
+   *   }
+   * }
+   * 
+   * const LDSingleKindContext: context = {
+   *   kind: 'user',
+   *   key: '1234',
+   *   myAttr: 'value'
+   *   _meta: {
+   *     privateAttributes: ['myAttr']
+   *   }
+   * }
+   * ```
    */
   export interface LDUser {
     /**
@@ -390,14 +491,6 @@ declare module 'launchdarkly-js-sdk-common' {
      */
     key?: string;
 
-    /**
-     * An optional secondary key for a user. This affects
-     * [feature flag targeting](https://docs.launchdarkly.com/home/flags/targeting-users#targeting-rules-based-on-user-attributes)
-     * as follows: if you have chosen to bucket users by a specific attribute, the secondary key (if set)
-     * is used to further distinguish between users who are otherwise identical according to that attribute.
-     */
-    secondary?: string;
-
     /**
      * The user's name.
      *
@@ -454,14 +547,14 @@ declare module 'launchdarkly-js-sdk-common' {
      * Specifies a list of attribute names (either built-in or custom) which should be
      * marked as private, and not sent to LaunchDarkly in analytics events. This is in
      * addition to any private attributes designated in the global configuration
-     * with [[LDOptions.privateAttributeNames]] or [[LDOptions.allAttributesPrivate]].
+     * with {@link LDOptions.privateAttributes} or {@link LDOptions.allAttributesPrivate}.
      */
     privateAttributeNames?: Array<string>;
   }
 
   /**
    * Describes the reason that a flag evaluation produced a particular value. This is
-   * part of the [[LDEvaluationDetail]] object returned by [[LDClient.variationDetail]].
+   * part of the {@link LDEvaluationDetail} object returned by {@link LDClient.variationDetail]].
    */
   interface LDEvaluationReason {
     /**
@@ -503,14 +596,14 @@ declare module 'launchdarkly-js-sdk-common' {
    * An object that combines the result of a feature flag evaluation with information about
    * how it was calculated.
    *
-   * This is the result of calling [[LDClient.variationDetail]].
+   * This is the result of calling {@link LDClient.variationDetail}.
    *
    * For more information, see the [SDK reference guide](https://docs.launchdarkly.com/sdk/features/evaluation-reasons#javascript).
    */
   export interface LDEvaluationDetail {
     /**
      * The result of the flag evaluation. This will be either one of the flag's variations or
-     * the default value that was passed to [[LDClient.variationDetail]].
+     * the default value that was passed to {@link LDClient.variationDetail}.
      */
     value: LDFlagValue;
 
@@ -555,9 +648,9 @@ declare module 'launchdarkly-js-sdk-common' {
      * ```
      *
      * If you want to distinguish between these success and failure conditions, use
-     * [[waitForInitialization]] instead.
+     * {@link waitForInitialization} instead.
      *
-     * If you prefer to use event listeners ([[on]]) rather than Promises, you can listen on the
+     * If you prefer to use event listeners ({@link on}) rather than Promises, you can listen on the
      * client for a `"ready"` event, which will be fired in either case.
      *
      * @returns
@@ -593,7 +686,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * request it, so if you never call `waitForInitialization()` then you do not have to worry about
      * unhandled rejections.
      *
-     * Note that you can also use event listeners ([[on]]) for the same purpose: the event `"initialized"`
+     * Note that you can also use event listeners ({@link on}) for the same purpose: the event `"initialized"`
      * indicates success, and `"failed"` indicates failure.
      *
      * @returns
@@ -610,7 +703,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * since then.
      *
      * Changing the current context also causes all feature flag values to be reloaded. Until that has
-     * finished, calls to [[variation]] will still return flag values for the previous context. You can
+     * finished, calls to {@link variation} will still return flag values for the previous context. You can
      * use a callback or a Promise to determine when the new flag values are available.
      *
      * @param context
@@ -619,20 +712,20 @@ declare module 'launchdarkly-js-sdk-common' {
      *   The signed context key if you are using [Secure Mode](https://docs.launchdarkly.com/sdk/features/secure-mode#configuring-secure-mode-in-the-javascript-client-side-sdk).
      * @param onDone
      *   A function which will be called as soon as the flag values for the new context are available,
-     *   with two parameters: an error value (if any), and an [[LDFlagSet]] containing the new values
-     *   (which can also be obtained by calling [[variation]]). If the callback is omitted, you will
+     *   with two parameters: an error value (if any), and an {@link LDFlagSet} containing the new values
+     *   (which can also be obtained by calling {@link variation}). If the callback is omitted, you will
      *   receive a Promise instead.
      * @returns
      *   If you provided a callback, then nothing. Otherwise, a Promise which resolve once the flag
-     *   values for the new context are available, providing an [[LDFlagSet]] containing the new values
-     *   (which can also be obtained by calling [[variation]]).
+     *   values for the new context are available, providing an {@link LDFlagSet} containing the new values
+     *   (which can also be obtained by calling {@link variation}).
      */
     identify(context: LDContext, hash?: string, onDone?: (err: Error | null, flags: LDFlagSet | null) => void): Promise<LDFlagSet>;
 
     /**
      * Returns the client's current context.
      *
-     * This is the context that was most recently passed to [[identify]], or, if [[identify]] has never
+     * This is the context that was most recently passed to {@link identify}, or, if {@link identify} has never
      * been called, the initial context specified when the client was created.
      */
     getContext(): LDContext;
@@ -641,7 +734,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * Flushes all pending analytics events.
      *
      * Normally, batches of events are delivered in the background at intervals determined by the
-     * `flushInterval` property of [[LDOptions]]. Calling `flush()` triggers an immediate delivery.
+     * `flushInterval` property of {@link LDOptions}. Calling `flush()` triggers an immediate delivery.
      *
      * @param onDone
      *   A function which will be called when the flush completes. If omitted, you
@@ -673,7 +766,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * Determines the variation of a feature flag for a context, along with information about how it was
      * calculated.
      *
-     * Note that this will only work if you have set `evaluationExplanations` to true in [[LDOptions]].
+     * Note that this will only work if you have set `evaluationExplanations` to true in {@link LDOptions}.
      * Otherwise, the `reason` property of the result will be null.
      *
      * The `reason` property of the result will also be included in analytics events, if you are
@@ -687,7 +780,7 @@ declare module 'launchdarkly-js-sdk-common' {
      *   The default value of the flag, to be used if the value is not available from LaunchDarkly.
      *
      * @returns
-     *   An [[LDEvaluationDetail]] object containing the value and explanation.
+     *   An {@link LDEvaluationDetail} object containing the value and explanation.
      */
     variationDetail(key: string, defaultValue?: LDFlagValue): LDEvaluationDetail;
 
@@ -696,9 +789,9 @@ declare module 'launchdarkly-js-sdk-common' {
      *
      * If this is true, the client will always attempt to maintain a streaming connection; if false,
      * it never will. If you leave the value undefined (the default), the client will open a streaming
-     * connection if you subscribe to `"change"` or `"change:flag-key"` events (see [[LDClient.on]]).
+     * connection if you subscribe to `"change"` or `"change:flag-key"` events (see {@link LDClient.on}).
      *
-     * This can also be set as the `streaming` property of [[LDOptions]].
+     * This can also be set as the `streaming` property of {@link LDOptions}.
      */
     setStreaming(value?: boolean): void;
 
@@ -719,9 +812,9 @@ declare module 'launchdarkly-js-sdk-common' {
      *   The callback parameter is an Error object. If you do not listen for "error"
      *   events, then the errors will be logged with `console.log()`.
      * - `"change"`: The client has received new feature flag data. This can happen either
-     *   because you have switched contexts with [[identify]], or because the client has a
+     *   because you have switched contexts with {@link identify}, or because the client has a
      *   stream connection and has received a live change to a flag value (see below).
-     *   The callback parameter is an [[LDFlagChangeset]].
+     *   The callback parameter is an {@link LDFlagChangeset}.
      * - `"change:FLAG-KEY"`: The client has received a new value for a specific flag
      *   whose key is `FLAG-KEY`. The callback receives two parameters: the current (new)
      *   flag value, and the previous value. This is always accompanied by a general
@@ -730,27 +823,27 @@ declare module 'launchdarkly-js-sdk-common' {
      * The `"change"` and `"change:FLAG-KEY"` events have special behavior: by default, the
      * client will open a streaming connection to receive live changes if and only if
      * you are listening for one of these events. This behavior can be overridden by
-     * setting `streaming` in [[LDOptions]] or calling [[LDClient.setStreaming]].
+     * setting `streaming` in {@link LDOptions} or calling {@link LDClient.setStreaming}.
      *
      * @param key
      *   The name of the event for which to listen.
      * @param callback
      *   The function to execute when the event fires. The callback may or may not
-     *   receive parameters, depending on the type of event; see [[LDEventSignature]].
+     *   receive parameters, depending on the type of event.
      * @param context
      *   The `this` context to use for the callback.
      */
     on(key: string, callback: (...args: any[]) => void, context?: any): void;
 
     /**
-     * Deregisters an event listener. See [[on]] for the available event types.
+     * Deregisters an event listener. See {@link on} for the available event types.
      *
      * @param key
      *   The name of the event for which to stop listening.
      * @param callback
      *   The function to deregister.
      * @param context
-     *   The `this` context for the callback, if one was specified for [[on]].
+     *   The `this` context for the callback, if one was specified for {@link on}.
      */
     off(key: string, callback: (...args: any[]) => void, context?: any): void;
 
@@ -779,35 +872,35 @@ declare module 'launchdarkly-js-sdk-common' {
      * @returns
      *   An object in which each key is a feature flag key and each value is the flag value.
      *   Note that there is no way to specify a default value for each flag as there is with
-     *   [[variation]], so any flag that cannot be evaluated will have a null value.
+     *   {@link variation}, so any flag that cannot be evaluated will have a null value.
      */
     allFlags(): LDFlagSet;
 
-   /**
-    * Shuts down the client and releases its resources, after delivering any pending analytics
-    * events. After the client is closed, all calls to [[variation]] will return default values,
-    * and it will not make any requests to LaunchDarkly.
-    *
-    * @param onDone
-    *   A function which will be called when the operation completes. If omitted, you
-    *   will receive a Promise instead.
-    *
-    * @returns
-    *   If you provided a callback, then nothing. Otherwise, a Promise which resolves once
-    *   closing is finished. It will never be rejected.
-    */
-   close(onDone?: () => void): Promise<void>;
+    /**
+     * Shuts down the client and releases its resources, after delivering any pending analytics
+     * events. After the client is closed, all calls to {@link variation} will return default values,
+     * and it will not make any requests to LaunchDarkly.
+     *
+     * @param onDone
+     *   A function which will be called when the operation completes. If omitted, you
+     *   will receive a Promise instead.
+     *
+     * @returns
+     *   If you provided a callback, then nothing. Otherwise, a Promise which resolves once
+     *   closing is finished. It will never be rejected.
+     */
+    close(onDone?: () => void): Promise<void>;
   }
 
   /**
-   * Provides a simple [[LDLogger]] implementation.
+   * Provides a simple {@link LDLogger} implementation.
    *
    * This logging implementation uses a simple format that includes only the log level
    * and the message text. Output is written to the console unless otherwise specified.
-   * You can filter by log level as described in [[BasicLoggerOptions.level]].
+   * You can filter by log level as described in {@link BasicLoggerOptions.level}.
    *
-   * To use the logger created by this function, put it into [[LDOptions.logger]]. If
-   * you do not set [[LDOptions.logger]] to anything, the SDK uses a default logger
+   * To use the logger created by this function, put it into {@link LDOptions.logger}. If
+   * you do not set {@link LDOptions.logger} to anything, the SDK uses a default logger
    * that is equivalent to `ld.basicLogger({ level: 'info' })`.
    *
    * @param options Configuration for the logger. If no options are specified, the
@@ -838,19 +931,19 @@ declare module 'launchdarkly-js-sdk-common' {
    * @ignore (don't need to show this separately in TypeDoc output; each SDK should provide its own
    *   basicLogger function that delegates to this and sets the formatter parameter)
    */
-   export function commonBasicLogger(
+  export function commonBasicLogger(
     options?: BasicLoggerOptions,
     formatter?: (format: string, ...args: any[]) => void
   ): LDLogger;
 
   /**
-   * Configuration for [[basicLogger]].
+   * Configuration for {@link basicLogger}.
    */
   export interface BasicLoggerOptions {
     /**
      * The lowest level of log message to enable.
      *
-     * See [[LDLogLevel]] for a list of possible levels. Setting a level here causes
+     * See {@link LDLogLevel} for a list of possible levels. Setting a level here causes
      * all lower-importance levels to be disabled: for instance, if you specify
      * `'warn'`, then `'debug'` and `'info'` are disabled.
      *
@@ -882,9 +975,9 @@ declare module 'launchdarkly-js-sdk-common' {
   }
 
   /**
-   * Logging levels that can be used with [[basicLogger]].
+   * Logging levels that can be used with {@link basicLogger}.
    *
-   * Set [[BasicLoggerOptions.level]] to one of these values to control what levels
+   * Set {@link BasicLoggerOptions.level} to one of these values to control what levels
    * of log messages are enabled. Going from lowest importance (and most verbose)
    * to most importance, the levels are `'debug'`, `'info'`, `'warn'`, and `'error'`.
    * You can also specify `'none'` instead to disable all logging.
@@ -914,7 +1007,7 @@ declare module 'launchdarkly-js-sdk-common' {
      */
     method: (flagKey: string, flagDetail: LDEvaluationDetail, context: LDContext) => void;
   }
-  
+
   /**
    * Callback interface for collecting information about the SDK at runtime.
    * 
@@ -933,15 +1026,15 @@ declare module 'launchdarkly-js-sdk-common' {
      * Name of the inspector. Will be used for logging issues with the inspector.
      */
     name: string,
-    
+
     /**
      * This method is called when the flags in the store are replaced with new flags. It will contain all flags
      * regardless of if they have been evaluated.
      */
     method: (details: Record<string, LDEvaluationDetail>) => void;
   }
-  
-    
+
+
   /**
    * Callback interface for collecting information about the SDK at runtime.
    * 
@@ -959,7 +1052,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * Name of the inspector. Will be used for logging issues with the inspector.
      */
     name: string,
-  
+
     /**
      * This method is called when a flag is updated. It will not be called
      * when all flags are updated.
@@ -982,7 +1075,7 @@ declare module 'launchdarkly-js-sdk-common' {
      * Name of the inspector. Will be used for logging issues with the inspector.
      */
     name: string,
-  
+
     /**
      * This method will be called when an identify operation completes.
      */