@launchdarkly/js-client-sdk-common 1.19.1 → 1.21.0

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-import { getPollingUri, TypeValidators, createSafeLogger, ServiceEndpoints, ApplicationTags, OptionMessages, NumberWithMinimum, SafeLogger, internal, deepCompact, clone, secondsToMillis, ClientContext, fastDeepEqual, defaultHeaders, Context, LDTimeoutError, AutoEnvAttributes, cancelableTimedPromise, LDClientError, isHttpRecoverable, httpErrorMessage, LDPollingError, DataSourceErrorKind, getStreamingUri, shouldRetry, LDStreamingError } from '@launchdarkly/js-sdk-common';
+import { getPollingUri, isNullish, TypeValidators, OptionMessages, NumberWithMinimum, createSafeLogger, ServiceEndpoints, ApplicationTags, SafeLogger, internal, deepCompact, clone, secondsToMillis, ClientContext, fastDeepEqual, defaultHeaders, Context, LDTimeoutError, AutoEnvAttributes, cancelableTimedPromise, LDClientError, base64UrlEncode, isHttpRecoverable, httpErrorMessage, LDPollingError, DataSourceErrorKind, getStreamingUri, shouldRetry, LDStreamingError } from '@launchdarkly/js-sdk-common';
 export * from '@launchdarkly/js-sdk-common';
 import * as jsSdkCommon from '@launchdarkly/js-sdk-common';
 export { jsSdkCommon as platform };
@@ -204,6 +204,74 @@ function createAsyncTaskQueue(logger) {
     };
 }
 
+function isCompoundValidator(v) {
+    return 'validate' in v;
+}
+/**
+ * Validates an options object against a map of validators and defaults.
+ *
+ * If `input` is null, undefined, or not an object the defaults are returned
+ * (with a warning for non-nullish non-objects).
+ *
+ * Supports special validator types created by:
+ * - {@link validatorOf}: recursively validates nested objects
+ * - {@link arrayOf}: validates arrays with per-item validation
+ * - {@link anyOf}: accepts the first matching validator from a list
+ * - {@link recordOf}: validates objects with dynamic keys
+ */
+function validateOptions(input, validatorMap, defaults, logger, prefix) {
+    const result = { ...defaults };
+    if (isNullish(input)) {
+        return result;
+    }
+    if (!TypeValidators.Object.is(input)) {
+        logger?.warn(OptionMessages.wrongOptionType(prefix ?? 'config', 'object', typeof input));
+        return result;
+    }
+    Object.entries(input).forEach(([key, value]) => {
+        const validator = validatorMap[key];
+        const name = prefix ? `${prefix}.${key}` : key;
+        if (!validator) {
+            logger?.warn(OptionMessages.unknownOption(name));
+            return;
+        }
+        if (isNullish(value)) {
+            return;
+        }
+        if (isCompoundValidator(validator)) {
+            const validated = validator.validate(value, name, logger, defaults[key]);
+            if (validated !== undefined) {
+                result[key] = validated.value;
+            }
+            return;
+        }
+        if (validator.is(value)) {
+            result[key] = value;
+            return;
+        }
+        // Validation failed — apply correction or fall back to default.
+        const validatorType = validator.getType();
+        if (validatorType === 'boolean') {
+            logger?.warn(OptionMessages.wrongOptionTypeBoolean(name, typeof value));
+            result[key] = !!value;
+        }
+        else if (validatorType === 'boolean | undefined | null') {
+            logger?.warn(OptionMessages.wrongOptionTypeBoolean(name, typeof value));
+            if (typeof value !== 'boolean' && typeof value !== 'undefined' && value !== null) {
+                result[key] = !!value;
+            }
+        }
+        else if (validator instanceof NumberWithMinimum && TypeValidators.Number.is(value)) {
+            logger?.warn(OptionMessages.optionBelowMinimum(name, value, validator.min));
+            result[key] = validator.min;
+        }
+        else {
+            logger?.warn(OptionMessages.wrongOptionType(name, validatorType, typeof value));
+        }
+    });
+    return result;
+}
+
 // eslint-disable-next-line max-classes-per-file
 const validators = {
     logger: TypeValidators.Object,
@@ -273,8 +341,12 @@ class ConfigurationImpl {
         this.hooks = [];
         this.inspectors = [];
         this.logger = ensureSafeLogger(pristineOptions.logger);
-        const errors = this._validateTypesAndNames(pristineOptions);
-        errors.forEach((e) => this.logger.warn(e));
+        const validated = validateOptions(pristineOptions, validators, {}, this.logger);
+        Object.entries(validated).forEach(([k, v]) => {
+            if (k !== 'logger') {
+                this[k] = v;
+            }
+        });
         this.serviceEndpoints = new ServiceEndpoints(this.streamUri, this.baseUri, this.eventsUri, internalOptions.analyticsEventPath, internalOptions.diagnosticEventPath, internalOptions.includeAuthorizationHeader, pristineOptions.payloadFilterKey);
         this.useReport = pristineOptions.useReport ?? false;
         this.tags = new ApplicationTags({ application: this.applicationInfo, logger: this.logger });
@@ -283,44 +355,6 @@ class ConfigurationImpl {
         this.credentialType = internalOptions.credentialType;
         this.getImplementationHooks = internalOptions.getImplementationHooks;
     }
-    _validateTypesAndNames(pristineOptions) {
-        const errors = [];
-        Object.entries(pristineOptions).forEach(([k, v]) => {
-            const validator = validators[k];
-            if (validator) {
-                if (!validator.is(v)) {
-                    const validatorType = validator.getType();
-                    if (validatorType === 'boolean') {
-                        errors.push(OptionMessages.wrongOptionTypeBoolean(k, typeof v));
-                        this[k] = !!v;
-                    }
-                    else if (validatorType === 'boolean | undefined | null') {
-                        errors.push(OptionMessages.wrongOptionTypeBoolean(k, typeof v));
-                        if (typeof v !== 'boolean' && typeof v !== 'undefined' && v !== null) {
-                            this[k] = !!v;
-                        }
-                    }
-                    else if (validator instanceof NumberWithMinimum && TypeValidators.Number.is(v)) {
-                        const { min } = validator;
-                        errors.push(OptionMessages.optionBelowMinimum(k, v, min));
-                        this[k] = min;
-                    }
-                    else {
-                        errors.push(OptionMessages.wrongOptionType(k, validator.getType(), typeof v));
-                    }
-                }
-                else if (k === 'logger') ;
-                else {
-                    // if an option is explicitly null, coerce to undefined
-                    this[k] = v ?? undefined;
-                }
-            }
-            else {
-                errors.push(OptionMessages.unknownOption(k));
-            }
-        });
-        return errors;
-    }
 }
 
 async function digest(hasher, encoding) {
@@ -1962,6 +1996,115 @@ function readFlagsFromBootstrap(logger, data) {
     return ret;
 }
 
+/**
+ * Creates endpoint paths for browser (client-side ID) FDv1 evaluation.
+ *
+ * @param clientSideId The client-side ID for this environment.
+ */
+function browserFdv1Endpoints(clientSideId) {
+    return {
+        polling: () => ({
+            pathGet(encoding, plainContextString) {
+                return `/sdk/evalx/${clientSideId}/contexts/${base64UrlEncode(plainContextString, encoding)}`;
+            },
+            pathReport(_encoding, _plainContextString) {
+                return `/sdk/evalx/${clientSideId}/context`;
+            },
+            pathPost(_encoding, _plainContextString) {
+                throw new Error('Post for FDv1 unsupported.');
+            },
+            pathPing(_encoding, _plainContextString) {
+                throw new Error('Ping for polling unsupported.');
+            },
+        }),
+        streaming: () => ({
+            pathGet(encoding, plainContextString) {
+                return `/eval/${clientSideId}/${base64UrlEncode(plainContextString, encoding)}`;
+            },
+            pathReport(_encoding, _plainContextString) {
+                return `/eval/${clientSideId}`;
+            },
+            pathPost(_encoding, _plainContextString) {
+                throw new Error('Post for FDv1 unsupported.');
+            },
+            pathPing(_encoding, _plainContextString) {
+                return `/ping/${clientSideId}`;
+            },
+        }),
+    };
+}
+/**
+ * Creates endpoint paths for mobile (mobile key) FDv1 evaluation.
+ */
+function mobileFdv1Endpoints() {
+    return {
+        polling: () => ({
+            pathGet(encoding, plainContextString) {
+                return `/msdk/evalx/contexts/${base64UrlEncode(plainContextString, encoding)}`;
+            },
+            pathReport(_encoding, _plainContextString) {
+                return `/msdk/evalx/context`;
+            },
+            pathPost(_encoding, _plainContextString) {
+                throw new Error('Post for FDv1 unsupported.');
+            },
+            pathPing(_encoding, _plainContextString) {
+                throw new Error('Ping for polling unsupported.');
+            },
+        }),
+        streaming: () => ({
+            pathGet(encoding, plainContextString) {
+                return `/meval/${base64UrlEncode(plainContextString, encoding)}`;
+            },
+            pathReport(_encoding, _plainContextString) {
+                return `/meval`;
+            },
+            pathPost(_encoding, _plainContextString) {
+                throw new Error('Post for FDv1 unsupported.');
+            },
+            pathPing(_encoding, _plainContextString) {
+                return `/mping`;
+            },
+        }),
+    };
+}
+/**
+ * Creates endpoint paths for FDv2 evaluation.
+ * Unified for all client-side platforms per CSFDV2 Requirement 2.1.1.
+ */
+function fdv2Endpoints() {
+    return {
+        polling: () => ({
+            pathGet(encoding, plainContextString) {
+                return `/sdk/poll/eval/${base64UrlEncode(plainContextString, encoding)}`;
+            },
+            pathReport(_encoding, _plainContextString) {
+                throw new Error('Report for FDv2 unsupported.');
+            },
+            pathPost(_encoding, _plainContextString) {
+                return `/sdk/poll/eval`;
+            },
+            pathPing(_encoding, _plainContextString) {
+                throw new Error('Ping for polling unsupported.');
+            },
+        }),
+        streaming: () => ({
+            pathGet(encoding, plainContextString) {
+                return `/sdk/stream/eval/${base64UrlEncode(plainContextString, encoding)}`;
+            },
+            pathReport(_encoding, _plainContextString) {
+                throw new Error('Report for FDv2 unsupported.');
+            },
+            pathPost(_encoding, _plainContextString) {
+                return `/sdk/stream/eval`;
+            },
+            pathPing(_encoding, _plainContextString) {
+                throw new Error('Ping for streaming unsupported.');
+            },
+        }),
+    };
+}
+
 function createDataSourceEventHandler(flagManager, statusManager, logger) {
     return {
         async handlePut(context, flags) {
@@ -2415,5 +2558,5 @@ class BaseDataManager {
     }
 }
 
-export { BaseDataManager, DataSourceState, LDClientImpl, makeRequestor, readFlagsFromBootstrap, safeRegisterDebugOverridePlugins };
+export { BaseDataManager, DataSourceState, LDClientImpl, browserFdv1Endpoints, fdv2Endpoints, makeRequestor, mobileFdv1Endpoints, readFlagsFromBootstrap, safeRegisterDebugOverridePlugins, validateOptions };
 //# sourceMappingURL=index.mjs.map