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

package/dist/cjs/index.cjs

@@ -222,6 +222,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 (jsSdkCommon.isNullish(input)) {
+        return result;
+    }
+    if (!jsSdkCommon.TypeValidators.Object.is(input)) {
+        logger?.warn(jsSdkCommon.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(jsSdkCommon.OptionMessages.unknownOption(name));
+            return;
+        }
+        if (jsSdkCommon.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(jsSdkCommon.OptionMessages.wrongOptionTypeBoolean(name, typeof value));
+            result[key] = !!value;
+        }
+        else if (validatorType === 'boolean | undefined | null') {
+            logger?.warn(jsSdkCommon.OptionMessages.wrongOptionTypeBoolean(name, typeof value));
+            if (typeof value !== 'boolean' && typeof value !== 'undefined' && value !== null) {
+                result[key] = !!value;
+            }
+        }
+        else if (validator instanceof jsSdkCommon.NumberWithMinimum && jsSdkCommon.TypeValidators.Number.is(value)) {
+            logger?.warn(jsSdkCommon.OptionMessages.optionBelowMinimum(name, value, validator.min));
+            result[key] = validator.min;
+        }
+        else {
+            logger?.warn(jsSdkCommon.OptionMessages.wrongOptionType(name, validatorType, typeof value));
+        }
+    });
+    return result;
+}
+
 // eslint-disable-next-line max-classes-per-file
 const validators = {
     logger: jsSdkCommon.TypeValidators.Object,
@@ -291,8 +359,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 jsSdkCommon.ServiceEndpoints(this.streamUri, this.baseUri, this.eventsUri, internalOptions.analyticsEventPath, internalOptions.diagnosticEventPath, internalOptions.includeAuthorizationHeader, pristineOptions.payloadFilterKey);
         this.useReport = pristineOptions.useReport ?? false;
         this.tags = new jsSdkCommon.ApplicationTags({ application: this.applicationInfo, logger: this.logger });
@@ -301,44 +373,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(jsSdkCommon.OptionMessages.wrongOptionTypeBoolean(k, typeof v));
-                        this[k] = !!v;
-                    }
-                    else if (validatorType === 'boolean | undefined | null') {
-                        errors.push(jsSdkCommon.OptionMessages.wrongOptionTypeBoolean(k, typeof v));
-                        if (typeof v !== 'boolean' && typeof v !== 'undefined' && v !== null) {
-                            this[k] = !!v;
-                        }
-                    }
-                    else if (validator instanceof jsSdkCommon.NumberWithMinimum && jsSdkCommon.TypeValidators.Number.is(v)) {
-                        const { min } = validator;
-                        errors.push(jsSdkCommon.OptionMessages.optionBelowMinimum(k, v, min));
-                        this[k] = min;
-                    }
-                    else {
-                        errors.push(jsSdkCommon.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(jsSdkCommon.OptionMessages.unknownOption(k));
-            }
-        });
-        return errors;
-    }
 }
 
 async function digest(hasher, encoding) {
@@ -1980,6 +2014,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/${jsSdkCommon.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}/${jsSdkCommon.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/${jsSdkCommon.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/${jsSdkCommon.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/${jsSdkCommon.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/${jsSdkCommon.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) {
@@ -2437,9 +2580,13 @@ exports.platform = jsSdkCommon__namespace;
 exports.BaseDataManager = BaseDataManager;
 exports.DataSourceState = DataSourceState;
 exports.LDClientImpl = LDClientImpl;
+exports.browserFdv1Endpoints = browserFdv1Endpoints;
+exports.fdv2Endpoints = fdv2Endpoints;
 exports.makeRequestor = makeRequestor;
+exports.mobileFdv1Endpoints = mobileFdv1Endpoints;
 exports.readFlagsFromBootstrap = readFlagsFromBootstrap;
 exports.safeRegisterDebugOverridePlugins = safeRegisterDebugOverridePlugins;
+exports.validateOptions = validateOptions;
 Object.keys(jsSdkCommon).forEach(function (k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
         enumerable: true,