@flopflip/launchdarkly-adapter 12.5.6 → 13.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/declarations/src/adapter/adapter.d.ts +3 -4
  2. package/dist/flopflip-launchdarkly-adapter.cjs.dev.js +185 -326
  3. package/dist/flopflip-launchdarkly-adapter.cjs.prod.js +185 -326
  4. package/dist/flopflip-launchdarkly-adapter.esm.js +186 -326
  5. package/package.json +4 -4
package/dist/flopflip-launchdarkly-adapter.esm.js CHANGED
@@ -1,14 +1,9 @@
1
- import _asyncToGenerator from '@babel/runtime/helpers/esm/asyncToGenerator';
2
- import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
3
1
  import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
4
2
  import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
5
- import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
6
- import _createClass from '@babel/runtime/helpers/esm/createClass';
7
3
  import _classPrivateFieldLooseBase from '@babel/runtime/helpers/esm/classPrivateFieldLooseBase';
8
4
  import _classPrivateFieldLooseKey from '@babel/runtime/helpers/esm/classPrivateFieldLooseKey';
9
- import _regeneratorRuntime from '@babel/runtime/regenerator';
10
5
  import { exposeGlobally, denormalizeFlagName, normalizeFlags, normalizeFlag } from '@flopflip/adapter-utilities';
11
- import { AdapterConfigurationStatus, AdapterInitializationStatus, AdapterSubscriptionStatus, adapterIdentifiers } from '@flopflip/types';
6
+ import { AdapterSubscriptionStatus, AdapterConfigurationStatus, AdapterInitializationStatus, adapterIdentifiers } from '@flopflip/types';
12
7
  import debounce from 'debounce-fn';
13
8
  import { initialize } from 'launchdarkly-js-client-sdk';
14
9
  import isEqual from 'lodash/isEqual';
@@ -22,17 +17,15 @@ var _getIsAdapterUnsubscribed = /*#__PURE__*/_classPrivateFieldLooseKey("getIsAd
22
17
  var _getIsFlagUnsubcribed = /*#__PURE__*/_classPrivateFieldLooseKey("getIsFlagUnsubcribed");
23
18
  var _getIsFlagLocked = /*#__PURE__*/_classPrivateFieldLooseKey("getIsFlagLocked");
24
19
  var _withoutUnsubscribedOrLockedFlags = /*#__PURE__*/_classPrivateFieldLooseKey("withoutUnsubscribedOrLockedFlags");
25
- var _getIsAnonymousUser = /*#__PURE__*/_classPrivateFieldLooseKey("getIsAnonymousUser");
26
- var _ensureUser = /*#__PURE__*/_classPrivateFieldLooseKey("ensureUser");
20
+ var _getIsAnonymousContext = /*#__PURE__*/_classPrivateFieldLooseKey("getIsAnonymousContext");
21
+ var _ensureContext = /*#__PURE__*/_classPrivateFieldLooseKey("ensureContext");
27
22
  var _initializeClient = /*#__PURE__*/_classPrivateFieldLooseKey("initializeClient");
28
- var _changeUserContext = /*#__PURE__*/_classPrivateFieldLooseKey("changeUserContext");
23
+ var _changeClientContext = /*#__PURE__*/_classPrivateFieldLooseKey("changeClientContext");
29
24
  var _getInitialFlags = /*#__PURE__*/_classPrivateFieldLooseKey("getInitialFlags");
30
25
  var _didFlagChange = /*#__PURE__*/_classPrivateFieldLooseKey("didFlagChange");
31
26
  var _setupFlagSubcription = /*#__PURE__*/_classPrivateFieldLooseKey("setupFlagSubcription");
32
- var LaunchDarklyAdapter = /*#__PURE__*/function () {
33
- function LaunchDarklyAdapter() {
34
- var _this = this;
35
- _classCallCheck(this, LaunchDarklyAdapter);
27
+ class LaunchDarklyAdapter {
28
+ constructor() {
36
29
  this.id = void 0;
37
30
  Object.defineProperty(this, _adapterState, {
38
31
  writable: true,
@@ -40,216 +33,155 @@ var LaunchDarklyAdapter = /*#__PURE__*/function () {
40
33
  });
41
34
  Object.defineProperty(this, _updateFlagsInAdapterState, {
42
35
  writable: true,
43
- value: function value(flags, options) {
44
- var updatedFlags = Object.entries(flags).reduce(function (updatedFlags, _ref) {
45
- var _ref2 = _slicedToArray(_ref, 2),
36
+ value: (flags, options) => {
37
+ const updatedFlags = Object.entries(flags).reduce((updatedFlags, _ref) => {
38
+ let _ref2 = _slicedToArray(_ref, 2),
46
39
  flagName = _ref2[0],
47
40
  flagValue = _ref2[1];
48
- if (_classPrivateFieldLooseBase(_this, _getIsFlagLocked)[_getIsFlagLocked](flagName)) return updatedFlags;
41
+ if (_classPrivateFieldLooseBase(this, _getIsFlagLocked)[_getIsFlagLocked](flagName)) return updatedFlags;
49
42
  if (options !== null && options !== void 0 && options.lockFlags) {
50
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].lockedFlags.add(flagName);
43
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].lockedFlags.add(flagName);
51
44
  }
52
45
  if (options !== null && options !== void 0 && options.unsubscribeFlags) {
53
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].unsubscribedFlags.add(flagName);
46
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].unsubscribedFlags.add(flagName);
54
47
  }
55
- updatedFlags = _objectSpread(_objectSpread({}, updatedFlags), {}, _defineProperty({}, flagName, flagValue));
48
+ updatedFlags = _objectSpread(_objectSpread({}, updatedFlags), {}, {
49
+ [flagName]: flagValue
50
+ });
56
51
  return updatedFlags;
57
52
  }, {});
58
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].flags = _objectSpread(_objectSpread({}, _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].flags), updatedFlags);
53
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].flags = _objectSpread(_objectSpread({}, _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].flags), updatedFlags);
59
54
  }
60
55
  });
61
56
  Object.defineProperty(this, _getIsAdapterUnsubscribed, {
62
57
  writable: true,
63
- value: function value() {
64
- return _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].subscriptionStatus === AdapterSubscriptionStatus.Unsubscribed;
65
- }
58
+ value: () => _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].subscriptionStatus === AdapterSubscriptionStatus.Unsubscribed
66
59
  });
67
60
  Object.defineProperty(this, _getIsFlagUnsubcribed, {
68
61
  writable: true,
69
- value: function value(flagName) {
70
- return _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].unsubscribedFlags.has(flagName);
71
- }
62
+ value: flagName => _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].unsubscribedFlags.has(flagName)
72
63
  });
73
64
  Object.defineProperty(this, _getIsFlagLocked, {
74
65
  writable: true,
75
- value: function value(flagName) {
76
- return _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].lockedFlags.has(flagName);
77
- }
66
+ value: flagName => _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].lockedFlags.has(flagName)
78
67
  });
79
68
  Object.defineProperty(this, _withoutUnsubscribedOrLockedFlags, {
80
69
  writable: true,
81
- value: function value(flags) {
82
- return Object.fromEntries(Object.entries(flags).filter(function (_ref3) {
83
- var _ref4 = _slicedToArray(_ref3, 1),
84
- flagName = _ref4[0];
85
- return !_classPrivateFieldLooseBase(_this, _getIsFlagUnsubcribed)[_getIsFlagUnsubcribed](flagName) && !_classPrivateFieldLooseBase(_this, _getIsFlagLocked)[_getIsFlagLocked](flagName);
86
- }));
87
- }
70
+ value: flags => Object.fromEntries(Object.entries(flags).filter(_ref3 => {
71
+ let _ref4 = _slicedToArray(_ref3, 1),
72
+ flagName = _ref4[0];
73
+ return !_classPrivateFieldLooseBase(this, _getIsFlagUnsubcribed)[_getIsFlagUnsubcribed](flagName) && !_classPrivateFieldLooseBase(this, _getIsFlagLocked)[_getIsFlagLocked](flagName);
74
+ }))
88
75
  });
89
- Object.defineProperty(this, _getIsAnonymousUser, {
76
+ Object.defineProperty(this, _getIsAnonymousContext, {
90
77
  writable: true,
91
- value: function value(user) {
92
- return !(user !== null && user !== void 0 && user.key);
93
- }
78
+ value: context => !(context !== null && context !== void 0 && context.key)
94
79
  });
95
- Object.defineProperty(this, _ensureUser, {
80
+ Object.defineProperty(this, _ensureContext, {
96
81
  writable: true,
97
- value: function value(user) {
98
- var isAnonymousUser = _classPrivateFieldLooseBase(_this, _getIsAnonymousUser)[_getIsAnonymousUser](user);
82
+ value: context => {
83
+ const isAnonymousContext = _classPrivateFieldLooseBase(this, _getIsAnonymousContext)[_getIsAnonymousContext](context);
99
84
 
100
85
  // NOTE: When marked `anonymous` the SDK will generate a unique key and cache it in local storage
101
- return merge(user, {
102
- key: isAnonymousUser ? undefined : user.key,
103
- anonymous: isAnonymousUser
86
+ return merge(context, {
87
+ key: isAnonymousContext ? undefined : context.key,
88
+ anonymous: isAnonymousContext
104
89
  });
105
90
  }
106
91
  });
107
92
  Object.defineProperty(this, _initializeClient, {
108
93
  writable: true,
109
- value: function value(clientSideId, user, options) {
110
- return initialize(clientSideId, user, options);
111
- }
94
+ value: (clientSideId, context, options) => initialize(clientSideId, context, options)
112
95
  });
113
- Object.defineProperty(this, _changeUserContext, {
96
+ Object.defineProperty(this, _changeClientContext, {
114
97
  writable: true,
115
- value: function () {
116
- var _value = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(nextUser) {
117
- var _classPrivateFieldLoo;
118
- return _regeneratorRuntime.wrap(function _callee$(_context) {
119
- while (1) switch (_context.prev = _context.next) {
120
- case 0:
121
- return _context.abrupt("return", (_classPrivateFieldLoo = _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client) !== null && _classPrivateFieldLoo !== void 0 && _classPrivateFieldLoo.identify ? _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client.identify(nextUser) : Promise.reject(new Error('Can not change user context: client not yet initialized.')));
122
- case 1:
123
- case "end":
124
- return _context.stop();
125
- }
126
- }, _callee);
127
- }));
128
- function value(_x) {
129
- return _value.apply(this, arguments);
130
- }
131
- return value;
132
- }()
98
+ value: async nextContext => {
99
+ var _classPrivateFieldLoo;
100
+ return (_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client) !== null && _classPrivateFieldLoo !== void 0 && _classPrivateFieldLoo.identify ? _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client.identify(nextContext) : Promise.reject(new Error('Can not change user context: client not yet initialized.'));
101
+ }
133
102
  });
134
103
  Object.defineProperty(this, _getInitialFlags, {
135
104
  writable: true,
136
- value: function () {
137
- var _value2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref5) {
138
- var flags, throwOnInitializationFailure;
139
- return _regeneratorRuntime.wrap(function _callee4$(_context4) {
140
- while (1) switch (_context4.prev = _context4.next) {
141
- case 0:
142
- flags = _ref5.flags, throwOnInitializationFailure = _ref5.throwOnInitializationFailure;
143
- if (!_classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client) {
144
- _context4.next = 3;
145
- break;
146
- }
147
- return _context4.abrupt("return", _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client.waitForInitialization().then( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
148
- var flagsFromSdk, _i, _Object$entries, _ref7, _ref8, requestedFlagName, defaultFlagValue, denormalizedRequestedFlagName, normalizedFlags, _flags;
149
- return _regeneratorRuntime.wrap(function _callee2$(_context2) {
150
- while (1) switch (_context2.prev = _context2.next) {
151
- case 0:
152
- if (_classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client && !flags) {
153
- flagsFromSdk = _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client.allFlags();
154
- } else if (_classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client && flags) {
155
- flagsFromSdk = {};
156
- for (_i = 0, _Object$entries = Object.entries(flags); _i < _Object$entries.length; _i++) {
157
- _ref7 = _Object$entries[_i];
158
- _ref8 = _slicedToArray(_ref7, 2);
159
- requestedFlagName = _ref8[0];
160
- defaultFlagValue = _ref8[1];
161
- denormalizedRequestedFlagName = denormalizeFlagName(requestedFlagName);
162
- flagsFromSdk[denormalizedRequestedFlagName] = _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client.variation(denormalizedRequestedFlagName, defaultFlagValue);
163
- }
164
- }
165
- if (flagsFromSdk) {
166
- normalizedFlags = normalizeFlags(flagsFromSdk);
167
- _flags = _classPrivateFieldLooseBase(_this, _withoutUnsubscribedOrLockedFlags)[_withoutUnsubscribedOrLockedFlags](normalizedFlags);
168
- _this.updateFlags(_flags);
169
- }
170
- _this.setConfigurationStatus(AdapterConfigurationStatus.Configured);
171
- return _context2.abrupt("return", Promise.resolve({
172
- flagsFromSdk: flagsFromSdk,
173
- initializationStatus: AdapterInitializationStatus.Succeeded
174
- }));
175
- case 4:
176
- case "end":
177
- return _context2.stop();
178
- }
179
- }, _callee2);
180
- }))).catch( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
181
- return _regeneratorRuntime.wrap(function _callee3$(_context3) {
182
- while (1) switch (_context3.prev = _context3.next) {
183
- case 0:
184
- if (!throwOnInitializationFailure) {
185
- _context3.next = 2;
186
- break;
187
- }
188
- return _context3.abrupt("return", Promise.reject(new Error('@flopflip/launchdarkly-adapter: adapter failed to initialize.')));
189
- case 2:
190
- console.warn('@flopflip/launchdarkly-adapter: adapter failed to initialize.');
191
- return _context3.abrupt("return", Promise.resolve({
192
- flagsFromSdk: undefined,
193
- initializationStatus: AdapterInitializationStatus.Failed
194
- }));
195
- case 4:
196
- case "end":
197
- return _context3.stop();
198
- }
199
- }, _callee3);
200
- }))));
201
- case 3:
202
- return _context4.abrupt("return", Promise.reject(new Error('@flopflip/launchdarkly-adapter: can not subscribe with non initialized client.')));
203
- case 4:
204
- case "end":
205
- return _context4.stop();
105
+ value: async _ref5 => {
106
+ let flags = _ref5.flags,
107
+ throwOnInitializationFailure = _ref5.throwOnInitializationFailure;
108
+ if (_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client) {
109
+ return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client.waitForInitialization().then(async () => {
110
+ let flagsFromSdk;
111
+ if (_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client && !flags) {
112
+ flagsFromSdk = _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client.allFlags();
113
+ } else if (_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client && flags) {
114
+ flagsFromSdk = {};
115
+ for (const _ref6 of Object.entries(flags)) {
116
+ var _ref7 = _slicedToArray(_ref6, 2);
117
+ const requestedFlagName = _ref7[0];
118
+ const defaultFlagValue = _ref7[1];
119
+ const denormalizedRequestedFlagName = denormalizeFlagName(requestedFlagName);
120
+ flagsFromSdk[denormalizedRequestedFlagName] = _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client.variation(denormalizedRequestedFlagName, defaultFlagValue);
121
+ }
122
+ }
123
+ if (flagsFromSdk) {
124
+ const normalizedFlags = normalizeFlags(flagsFromSdk);
125
+ const flags = _classPrivateFieldLooseBase(this, _withoutUnsubscribedOrLockedFlags)[_withoutUnsubscribedOrLockedFlags](normalizedFlags);
126
+ this.updateFlags(flags);
206
127
  }
207
- }, _callee4);
208
- }));
209
- function value(_x2) {
210
- return _value2.apply(this, arguments);
128
+ this.setConfigurationStatus(AdapterConfigurationStatus.Configured);
129
+ return Promise.resolve({
130
+ flagsFromSdk,
131
+ initializationStatus: AdapterInitializationStatus.Succeeded
132
+ });
133
+ }).catch(async () => {
134
+ if (throwOnInitializationFailure) return Promise.reject(new Error('@flopflip/launchdarkly-adapter: adapter failed to initialize.'));
135
+ console.warn('@flopflip/launchdarkly-adapter: adapter failed to initialize.');
136
+ return Promise.resolve({
137
+ flagsFromSdk: undefined,
138
+ initializationStatus: AdapterInitializationStatus.Failed
139
+ });
140
+ });
211
141
  }
212
- return value;
213
- }()
142
+ return Promise.reject(new Error('@flopflip/launchdarkly-adapter: can not subscribe with non initialized client.'));
143
+ }
214
144
  });
215
145
  Object.defineProperty(this, _didFlagChange, {
216
146
  writable: true,
217
- value: function value(flagName, nextFlagValue) {
218
- var previousFlagValue = _this.getFlag(flagName);
147
+ value: (flagName, nextFlagValue) => {
148
+ const previousFlagValue = this.getFlag(flagName);
219
149
  if (previousFlagValue === undefined) return true;
220
150
  return previousFlagValue !== nextFlagValue;
221
151
  }
222
152
  });
223
153
  Object.defineProperty(this, _setupFlagSubcription, {
224
154
  writable: true,
225
- value: function value(_ref10) {
226
- var flagsFromSdk = _ref10.flagsFromSdk,
227
- flagsUpdateDelayMs = _ref10.flagsUpdateDelayMs;
228
- var _loop = function _loop(flagName) {
155
+ value: _ref8 => {
156
+ let flagsFromSdk = _ref8.flagsFromSdk,
157
+ flagsUpdateDelayMs = _ref8.flagsUpdateDelayMs;
158
+ for (const flagName in flagsFromSdk) {
229
159
  // Dispatch whenever a configured flag value changes
230
- if (Object.prototype.hasOwnProperty.call(flagsFromSdk, flagName) && _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client) {
231
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].client.on("change:".concat(flagName), function (flagValue) {
232
- var _normalizeFlag = normalizeFlag(flagName, flagValue),
160
+ if (Object.prototype.hasOwnProperty.call(flagsFromSdk, flagName) && _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client) {
161
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client.on(`change:${flagName}`, flagValue => {
162
+ const _normalizeFlag = normalizeFlag(flagName, flagValue),
233
163
  _normalizeFlag2 = _slicedToArray(_normalizeFlag, 2),
234
164
  normalizedFlagName = _normalizeFlag2[0],
235
165
  normalizedFlagValue = _normalizeFlag2[1];
236
- if (_classPrivateFieldLooseBase(_this, _getIsFlagUnsubcribed)[_getIsFlagUnsubcribed](normalizedFlagName)) return;
166
+ if (_classPrivateFieldLooseBase(this, _getIsFlagUnsubcribed)[_getIsFlagUnsubcribed](normalizedFlagName)) return;
237
167
 
238
168
  // Sometimes the SDK flushes flag changes without a value having changed.
239
- if (!_classPrivateFieldLooseBase(_this, _didFlagChange)[_didFlagChange](normalizedFlagName, normalizedFlagValue)) return;
240
- var updatedFlags = _defineProperty({}, normalizedFlagName, normalizedFlagValue);
169
+ if (!_classPrivateFieldLooseBase(this, _didFlagChange)[_didFlagChange](normalizedFlagName, normalizedFlagValue)) return;
170
+ const updatedFlags = {
171
+ [normalizedFlagName]: normalizedFlagValue
172
+ };
241
173
 
242
174
  // NOTE: Adapter state needs to be updated outside of debounced-fn
243
175
  // so that no flag updates are lost.
244
- _classPrivateFieldLooseBase(_this, _updateFlagsInAdapterState)[_updateFlagsInAdapterState](updatedFlags);
245
- var flushFlagsUpdate = function flushFlagsUpdate() {
246
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].emitter.emit('flagsStateChange', _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].flags);
176
+ _classPrivateFieldLooseBase(this, _updateFlagsInAdapterState)[_updateFlagsInAdapterState](updatedFlags);
177
+ const flushFlagsUpdate = () => {
178
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.emit('flagsStateChange', _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].flags);
247
179
  };
248
- var scheduleImmediately = {
180
+ const scheduleImmediately = {
249
181
  before: true,
250
182
  after: false
251
183
  };
252
- var scheduleTrailingEdge = {
184
+ const scheduleTrailingEdge = {
253
185
  before: false,
254
186
  after: true
255
187
  };
@@ -258,28 +190,26 @@ var LaunchDarklyAdapter = /*#__PURE__*/function () {
258
190
  }, flagsUpdateDelayMs ? scheduleTrailingEdge : scheduleImmediately))();
259
191
  });
260
192
  }
261
- };
262
- for (var flagName in flagsFromSdk) {
263
- _loop(flagName);
264
193
  }
265
194
  }
266
195
  });
267
- this.updateFlags = function (flags, options) {
268
- _classPrivateFieldLooseBase(_this, _updateFlagsInAdapterState)[_updateFlagsInAdapterState](flags, options);
196
+ // External. Flags are autolocked when updated.
197
+ this.updateFlags = (flags, options) => {
198
+ _classPrivateFieldLooseBase(this, _updateFlagsInAdapterState)[_updateFlagsInAdapterState](flags, options);
269
199
 
270
200
  // ...and flush initial state of flags
271
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].emitter.emit('flagsStateChange', _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].flags);
201
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.emit('flagsStateChange', _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].flags);
272
202
  };
273
- this.unsubscribe = function () {
274
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].subscriptionStatus = AdapterSubscriptionStatus.Unsubscribed;
203
+ this.unsubscribe = () => {
204
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].subscriptionStatus = AdapterSubscriptionStatus.Unsubscribed;
275
205
  };
276
- this.subscribe = function () {
277
- _classPrivateFieldLooseBase(_this, _adapterState)[_adapterState].subscriptionStatus = AdapterSubscriptionStatus.Subscribed;
206
+ this.subscribe = () => {
207
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].subscriptionStatus = AdapterSubscriptionStatus.Subscribed;
278
208
  };
279
209
  _classPrivateFieldLooseBase(this, _adapterState)[_adapterState] = {
280
210
  subscriptionStatus: AdapterSubscriptionStatus.Subscribed,
281
211
  configurationStatus: AdapterConfigurationStatus.Unconfigured,
282
- user: undefined,
212
+ context: undefined,
283
213
  client: undefined,
284
214
  flags: {},
285
215
  // Typings are incorrect and state that mitt is not callable.
@@ -290,162 +220,92 @@ var LaunchDarklyAdapter = /*#__PURE__*/function () {
290
220
  };
291
221
  this.id = adapterIdentifiers.launchdarkly;
292
222
  }
293
- _createClass(LaunchDarklyAdapter, [{
294
- key: "configure",
295
- value: function () {
296
- var _configure = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(adapterArgs, adapterEventHandlers) {
297
- var _this2 = this,
298
- _sdk$clientOptions;
299
- var handleFlagsChange, handleStatusChange, sdk, user, flags, _adapterArgs$subscrib, subscribeToFlagChanges, _adapterArgs$throwOnI, throwOnInitializationFailure, flagsUpdateDelayMs;
300
- return _regeneratorRuntime.wrap(function _callee5$(_context5) {
301
- while (1) switch (_context5.prev = _context5.next) {
302
- case 0:
303
- handleFlagsChange = function handleFlagsChange(nextFlags) {
304
- if (_classPrivateFieldLooseBase(_this2, _getIsAdapterUnsubscribed)[_getIsAdapterUnsubscribed]()) return;
305
- adapterEventHandlers.onFlagsStateChange({
306
- flags: nextFlags,
307
- id: _this2.id
308
- });
309
- };
310
- handleStatusChange = function handleStatusChange(nextStatus) {
311
- if (_classPrivateFieldLooseBase(_this2, _getIsAdapterUnsubscribed)[_getIsAdapterUnsubscribed]()) return;
312
- adapterEventHandlers.onStatusStateChange({
313
- status: nextStatus,
314
- id: _this2.id
315
- });
316
- };
317
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus = AdapterConfigurationStatus.Configuring;
318
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.on('flagsStateChange', handleFlagsChange);
319
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.on('statusStateChange', handleStatusChange);
320
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.emit('statusStateChange', {
321
- configurationStatus: _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus
322
- });
323
- sdk = adapterArgs.sdk, user = adapterArgs.user, flags = adapterArgs.flags, _adapterArgs$subscrib = adapterArgs.subscribeToFlagChanges, subscribeToFlagChanges = _adapterArgs$subscrib === void 0 ? true : _adapterArgs$subscrib, _adapterArgs$throwOnI = adapterArgs.throwOnInitializationFailure, throwOnInitializationFailure = _adapterArgs$throwOnI === void 0 ? false : _adapterArgs$throwOnI, flagsUpdateDelayMs = adapterArgs.flagsUpdateDelayMs;
324
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].user = _classPrivateFieldLooseBase(this, _ensureUser)[_ensureUser](user);
325
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client = _classPrivateFieldLooseBase(this, _initializeClient)[_initializeClient](sdk.clientSideId, _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].user, (_sdk$clientOptions = sdk.clientOptions) !== null && _sdk$clientOptions !== void 0 ? _sdk$clientOptions : {});
326
- return _context5.abrupt("return", _classPrivateFieldLooseBase(this, _getInitialFlags)[_getInitialFlags]({
327
- flags: flags,
328
- throwOnInitializationFailure: throwOnInitializationFailure
329
- }).then(function (_ref11) {
330
- var flagsFromSdk = _ref11.flagsFromSdk,
331
- initializationStatus = _ref11.initializationStatus;
332
- if (subscribeToFlagChanges && flagsFromSdk) _classPrivateFieldLooseBase(_this2, _setupFlagSubcription)[_setupFlagSubcription]({
333
- flagsFromSdk: flagsFromSdk,
334
- flagsUpdateDelayMs: flagsUpdateDelayMs
335
- });
336
- return {
337
- initializationStatus: initializationStatus
338
- };
339
- }));
340
- case 10:
341
- case "end":
342
- return _context5.stop();
343
- }
344
- }, _callee5, this);
345
- }));
346
- function configure(_x3, _x4) {
347
- return _configure.apply(this, arguments);
348
- }
349
- return configure;
350
- }()
351
- }, {
352
- key: "reconfigure",
353
- value: function () {
354
- var _reconfigure = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(adapterArgs, _adapterEventHandlers) {
355
- var nextUser;
356
- return _regeneratorRuntime.wrap(function _callee6$(_context6) {
357
- while (1) switch (_context6.prev = _context6.next) {
358
- case 0:
359
- if (this.getIsConfigurationStatus(AdapterConfigurationStatus.Configured)) {
360
- _context6.next = 2;
361
- break;
362
- }
363
- return _context6.abrupt("return", Promise.reject(new Error('@flopflip/launchdarkly-adapter: please configure adapter before reconfiguring.')));
364
- case 2:
365
- nextUser = adapterArgs.user;
366
- if (isEqual(_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].user, nextUser)) {
367
- _context6.next = 8;
368
- break;
369
- }
370
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].user = _classPrivateFieldLooseBase(this, _ensureUser)[_ensureUser](nextUser);
371
- _context6.next = 7;
372
- return _classPrivateFieldLooseBase(this, _changeUserContext)[_changeUserContext](_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].user);
373
- case 7:
374
- return _context6.abrupt("return", Promise.resolve({
375
- initializationStatus: AdapterInitializationStatus.Succeeded
376
- }));
377
- case 8:
378
- return _context6.abrupt("return", Promise.resolve({
379
- initializationStatus: AdapterInitializationStatus.Succeeded
380
- }));
381
- case 9:
382
- case "end":
383
- return _context6.stop();
384
- }
385
- }, _callee6, this);
386
- }));
387
- function reconfigure(_x5, _x6) {
388
- return _reconfigure.apply(this, arguments);
389
- }
390
- return reconfigure;
391
- }()
392
- }, {
393
- key: "getIsConfigurationStatus",
394
- value: function getIsConfigurationStatus(configurationStatus) {
395
- return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus === configurationStatus;
396
- }
397
- }, {
398
- key: "setConfigurationStatus",
399
- value: function setConfigurationStatus(nextConfigurationStatus) {
400
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus = nextConfigurationStatus;
401
- _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.emit('statusStateChange', {
402
- configurationStatus: _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus
223
+ async configure(adapterArgs, adapterEventHandlers) {
224
+ var _sdk$clientOptions;
225
+ const handleFlagsChange = nextFlags => {
226
+ if (_classPrivateFieldLooseBase(this, _getIsAdapterUnsubscribed)[_getIsAdapterUnsubscribed]()) return;
227
+ adapterEventHandlers.onFlagsStateChange({
228
+ flags: nextFlags,
229
+ id: this.id
230
+ });
231
+ };
232
+ const handleStatusChange = nextStatus => {
233
+ if (_classPrivateFieldLooseBase(this, _getIsAdapterUnsubscribed)[_getIsAdapterUnsubscribed]()) return;
234
+ adapterEventHandlers.onStatusStateChange({
235
+ status: nextStatus,
236
+ id: this.id
237
+ });
238
+ };
239
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus = AdapterConfigurationStatus.Configuring;
240
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.on('flagsStateChange', handleFlagsChange);
241
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.on('statusStateChange', handleStatusChange);
242
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.emit('statusStateChange', {
243
+ configurationStatus: _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus
244
+ });
245
+ const sdk = adapterArgs.sdk,
246
+ context = adapterArgs.context,
247
+ flags = adapterArgs.flags,
248
+ _adapterArgs$subscrib = adapterArgs.subscribeToFlagChanges,
249
+ subscribeToFlagChanges = _adapterArgs$subscrib === void 0 ? true : _adapterArgs$subscrib,
250
+ _adapterArgs$throwOnI = adapterArgs.throwOnInitializationFailure,
251
+ throwOnInitializationFailure = _adapterArgs$throwOnI === void 0 ? false : _adapterArgs$throwOnI,
252
+ flagsUpdateDelayMs = adapterArgs.flagsUpdateDelayMs;
253
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].context = _classPrivateFieldLooseBase(this, _ensureContext)[_ensureContext](context);
254
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client = _classPrivateFieldLooseBase(this, _initializeClient)[_initializeClient](sdk.clientSideId, _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].context, (_sdk$clientOptions = sdk.clientOptions) !== null && _sdk$clientOptions !== void 0 ? _sdk$clientOptions : {});
255
+ return _classPrivateFieldLooseBase(this, _getInitialFlags)[_getInitialFlags]({
256
+ flags,
257
+ throwOnInitializationFailure
258
+ }).then(_ref9 => {
259
+ let flagsFromSdk = _ref9.flagsFromSdk,
260
+ initializationStatus = _ref9.initializationStatus;
261
+ if (subscribeToFlagChanges && flagsFromSdk) _classPrivateFieldLooseBase(this, _setupFlagSubcription)[_setupFlagSubcription]({
262
+ flagsFromSdk,
263
+ flagsUpdateDelayMs
264
+ });
265
+ return {
266
+ initializationStatus
267
+ };
268
+ });
269
+ }
270
+ async reconfigure(adapterArgs, _adapterEventHandlers) {
271
+ if (!this.getIsConfigurationStatus(AdapterConfigurationStatus.Configured)) return Promise.reject(new Error('@flopflip/launchdarkly-adapter: please configure adapter before reconfiguring.'));
272
+ const nextContext = adapterArgs.context;
273
+ if (!isEqual(_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].context, nextContext)) {
274
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].context = _classPrivateFieldLooseBase(this, _ensureContext)[_ensureContext](nextContext);
275
+ await _classPrivateFieldLooseBase(this, _changeClientContext)[_changeClientContext](_classPrivateFieldLooseBase(this, _adapterState)[_adapterState].context);
276
+ return Promise.resolve({
277
+ initializationStatus: AdapterInitializationStatus.Succeeded
403
278
  });
404
279
  }
405
- }, {
406
- key: "getClient",
407
- value: function getClient() {
408
- return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client;
409
- }
410
- }, {
411
- key: "getFlag",
412
- value: function getFlag(flagName) {
413
- return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].flags[flagName];
414
- }
415
- }, {
416
- key: "updateUserContext",
417
- value: function () {
418
- var _updateUserContext = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(updatedUserProps) {
419
- var isAdapterConfigured;
420
- return _regeneratorRuntime.wrap(function _callee7$(_context7) {
421
- while (1) switch (_context7.prev = _context7.next) {
422
- case 0:
423
- isAdapterConfigured = this.getIsConfigurationStatus(AdapterConfigurationStatus.Configured);
424
- warning(isAdapterConfigured, '@flopflip/launchdarkly-adapter: adapter not configured. User context can not be updated before.');
425
- if (isAdapterConfigured) {
426
- _context7.next = 4;
427
- break;
428
- }
429
- return _context7.abrupt("return", Promise.reject(new Error('Can not update user context: adapter not yet configured.')));
430
- case 4:
431
- return _context7.abrupt("return", _classPrivateFieldLooseBase(this, _changeUserContext)[_changeUserContext](_objectSpread(_objectSpread({}, _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].user), updatedUserProps)));
432
- case 5:
433
- case "end":
434
- return _context7.stop();
435
- }
436
- }, _callee7, this);
437
- }));
438
- function updateUserContext(_x7) {
439
- return _updateUserContext.apply(this, arguments);
440
- }
441
- return updateUserContext;
442
- }()
443
- }]);
444
- return LaunchDarklyAdapter;
445
- }();
446
- var adapter = new LaunchDarklyAdapter();
280
+ return Promise.resolve({
281
+ initializationStatus: AdapterInitializationStatus.Succeeded
282
+ });
283
+ }
284
+ getIsConfigurationStatus(configurationStatus) {
285
+ return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus === configurationStatus;
286
+ }
287
+ setConfigurationStatus(nextConfigurationStatus) {
288
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus = nextConfigurationStatus;
289
+ _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].emitter.emit('statusStateChange', {
290
+ configurationStatus: _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].configurationStatus
291
+ });
292
+ }
293
+ getClient() {
294
+ return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].client;
295
+ }
296
+ getFlag(flagName) {
297
+ return _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].flags[flagName];
298
+ }
299
+ async updateClientContext(updatedContextProps) {
300
+ const isAdapterConfigured = this.getIsConfigurationStatus(AdapterConfigurationStatus.Configured);
301
+ warning(isAdapterConfigured, '@flopflip/launchdarkly-adapter: adapter not configured. Client context can not be updated before.');
302
+ if (!isAdapterConfigured) return Promise.reject(new Error('Can not update client context: adapter not yet configured.'));
303
+ return _classPrivateFieldLooseBase(this, _changeClientContext)[_changeClientContext](_objectSpread(_objectSpread({}, _classPrivateFieldLooseBase(this, _adapterState)[_adapterState].context), updatedContextProps));
304
+ }
305
+ }
306
+ const adapter = new LaunchDarklyAdapter();
447
307
  exposeGlobally(adapter);
448
308
 
449
- var version = "12.5.6";
309
+ const version = "13.0.1";
450
310
 
451
311
  export { adapter as default, version };