@flopflip/launchdarkly-adapter 13.0.0 → 13.0.2

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