@streamlayer/sdk-web-anonymous-auth 1.3.15 → 1.3.16

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.
package/lib/cjs/index.js CHANGED
@@ -7,8 +7,8 @@ const jose = require("jose");
7
7
  function getDefaultExportFromCjs(x) {
8
8
  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
9
9
  }
10
- var browser$1 = { exports: {} };
11
- var process = browser$1.exports = {};
10
+ var browser = { exports: {} };
11
+ var process = browser.exports = {};
12
12
  var cachedSetTimeout;
13
13
  var cachedClearTimeout;
14
14
  function defaultSetTimout() {
@@ -138,17 +138,17 @@ process.env = {};
138
138
  process.argv = [];
139
139
  process.version = "";
140
140
  process.versions = {};
141
- function noop$1() {
142
- }
143
- process.on = noop$1;
144
- process.addListener = noop$1;
145
- process.once = noop$1;
146
- process.off = noop$1;
147
- process.removeListener = noop$1;
148
- process.removeAllListeners = noop$1;
149
- process.emit = noop$1;
150
- process.prependListener = noop$1;
151
- process.prependOnceListener = noop$1;
141
+ function noop() {
142
+ }
143
+ process.on = noop;
144
+ process.addListener = noop;
145
+ process.once = noop;
146
+ process.off = noop;
147
+ process.removeListener = noop;
148
+ process.removeAllListeners = noop;
149
+ process.emit = noop;
150
+ process.prependListener = noop;
151
+ process.prependOnceListener = noop;
152
152
  process.listeners = function(name) {
153
153
  return [];
154
154
  };
@@ -164,539 +164,50 @@ process.chdir = function(dir) {
164
164
  process.umask = function() {
165
165
  return 0;
166
166
  };
167
- var browserExports = browser$1.exports;
167
+ var browserExports = browser.exports;
168
168
  const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
169
- var browser = { exports: {} };
170
- function tryStringify(o) {
171
- try {
172
- return JSON.stringify(o);
173
- } catch (e) {
174
- return '"[Circular]"';
175
- }
176
- }
177
- var quickFormatUnescaped = format$1;
178
- function format$1(f, args, opts) {
179
- var ss = opts && opts.stringify || tryStringify;
180
- var offset = 1;
181
- if (typeof f === "object" && f !== null) {
182
- var len = args.length + offset;
183
- if (len === 1) return f;
184
- var objects = new Array(len);
185
- objects[0] = ss(f);
186
- for (var index = 1; index < len; index++) {
187
- objects[index] = ss(args[index]);
188
- }
189
- return objects.join(" ");
190
- }
191
- if (typeof f !== "string") {
192
- return f;
193
- }
194
- var argLen = args.length;
195
- if (argLen === 0) return f;
196
- var str = "";
197
- var a = 1 - offset;
198
- var lastPos = -1;
199
- var flen = f && f.length || 0;
200
- for (var i = 0; i < flen; ) {
201
- if (f.charCodeAt(i) === 37 && i + 1 < flen) {
202
- lastPos = lastPos > -1 ? lastPos : 0;
203
- switch (f.charCodeAt(i + 1)) {
204
- case 100:
205
- case 102:
206
- if (a >= argLen)
207
- break;
208
- if (args[a] == null) break;
209
- if (lastPos < i)
210
- str += f.slice(lastPos, i);
211
- str += Number(args[a]);
212
- lastPos = i + 2;
213
- i++;
214
- break;
215
- case 105:
216
- if (a >= argLen)
217
- break;
218
- if (args[a] == null) break;
219
- if (lastPos < i)
220
- str += f.slice(lastPos, i);
221
- str += Math.floor(Number(args[a]));
222
- lastPos = i + 2;
223
- i++;
224
- break;
225
- case 79:
226
- case 111:
227
- case 106:
228
- if (a >= argLen)
229
- break;
230
- if (args[a] === void 0) break;
231
- if (lastPos < i)
232
- str += f.slice(lastPos, i);
233
- var type = typeof args[a];
234
- if (type === "string") {
235
- str += "'" + args[a] + "'";
236
- lastPos = i + 2;
237
- i++;
238
- break;
239
- }
240
- if (type === "function") {
241
- str += args[a].name || "<anonymous>";
242
- lastPos = i + 2;
243
- i++;
244
- break;
245
- }
246
- str += ss(args[a]);
247
- lastPos = i + 2;
248
- i++;
249
- break;
250
- case 115:
251
- if (a >= argLen)
252
- break;
253
- if (lastPos < i)
254
- str += f.slice(lastPos, i);
255
- str += String(args[a]);
256
- lastPos = i + 2;
257
- i++;
258
- break;
259
- case 37:
260
- if (lastPos < i)
261
- str += f.slice(lastPos, i);
262
- str += "%";
263
- lastPos = i + 2;
264
- i++;
265
- a--;
266
- break;
267
- }
268
- ++a;
269
- }
270
- ++i;
271
- }
272
- if (lastPos === -1)
273
- return f;
274
- else if (lastPos < flen) {
275
- str += f.slice(lastPos);
276
- }
277
- return str;
278
- }
279
- const format = quickFormatUnescaped;
280
- browser.exports = pino;
281
- const _console = pfGlobalThisOrFallback().console || {};
282
- const stdSerializers = {
283
- mapHttpRequest: mock,
284
- mapHttpResponse: mock,
285
- wrapRequestSerializer: passthrough,
286
- wrapResponseSerializer: passthrough,
287
- wrapErrorSerializer: passthrough,
288
- req: mock,
289
- res: mock,
290
- err: asErrValue,
291
- errWithCause: asErrValue
292
- };
293
- function levelToValue(level, logger2) {
294
- return level === "silent" ? Infinity : logger2.levels.values[level];
295
- }
296
- const baseLogFunctionSymbol = Symbol("pino.logFuncs");
297
- const hierarchySymbol = Symbol("pino.hierarchy");
298
- const logFallbackMap = {
299
- error: "log",
300
- fatal: "error",
301
- warn: "error",
302
- info: "log",
303
- debug: "log",
304
- trace: "log"
169
+ const LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
170
+ const LEVEL_MAP = {
171
+ trace: "debug",
172
+ debug: "debug",
173
+ info: "info",
174
+ warn: "warn",
175
+ error: "error",
176
+ fatal: "error"
305
177
  };
306
- function appendChildLogger(parentLogger, childLogger) {
307
- const newEntry = {
308
- logger: childLogger,
309
- parent: parentLogger[hierarchySymbol]
310
- };
311
- childLogger[hierarchySymbol] = newEntry;
312
- }
313
- function setupBaseLogFunctions(logger2, levels, proto) {
314
- const logFunctions = {};
315
- levels.forEach((level) => {
316
- logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop;
317
- });
318
- logger2[baseLogFunctionSymbol] = logFunctions;
319
- }
320
- function shouldSerialize(serialize, serializers) {
321
- if (Array.isArray(serialize)) {
322
- const hasToFilter = serialize.filter(function(k) {
323
- return k !== "!stdSerializers.err";
324
- });
325
- return hasToFilter;
326
- } else if (serialize === true) {
327
- return Object.keys(serializers);
328
- }
329
- return false;
330
- }
331
- function pino(opts) {
332
- opts = opts || {};
333
- opts.browser = opts.browser || {};
334
- const transmit2 = opts.browser.transmit;
335
- if (transmit2 && typeof transmit2.send !== "function") {
336
- throw Error("pino: transmit option must have a send function");
337
- }
338
- const proto = opts.browser.write || _console;
339
- if (opts.browser.write) opts.browser.asObject = true;
340
- const serializers = opts.serializers || {};
341
- const serialize = shouldSerialize(opts.browser.serialize, serializers);
342
- let stdErrSerialize = opts.browser.serialize;
343
- if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
344
- const customLevels = Object.keys(opts.customLevels || {});
345
- const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels);
346
- if (typeof proto === "function") {
347
- levels.forEach(function(level2) {
348
- proto[level2] = proto;
349
- });
350
- }
351
- if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
352
- const level = opts.level || "info";
353
- const logger2 = Object.create(proto);
354
- if (!logger2.log) logger2.log = noop;
355
- setupBaseLogFunctions(logger2, levels, proto);
356
- appendChildLogger({}, logger2);
357
- Object.defineProperty(logger2, "levelVal", {
358
- get: getLevelVal
359
- });
360
- Object.defineProperty(logger2, "level", {
361
- get: getLevel,
362
- set: setLevel
363
- });
364
- const setOpts = {
365
- transmit: transmit2,
366
- serialize,
367
- asObject: opts.browser.asObject,
368
- formatters: opts.browser.formatters,
369
- levels,
370
- timestamp: getTimeFunction(opts),
371
- messageKey: opts.messageKey || "msg",
372
- onChild: opts.onChild || noop
373
- };
374
- logger2.levels = getLevels(opts);
375
- logger2.level = level;
376
- logger2.setMaxListeners = logger2.getMaxListeners = logger2.emit = logger2.addListener = logger2.on = logger2.prependListener = logger2.once = logger2.prependOnceListener = logger2.removeListener = logger2.removeAllListeners = logger2.listeners = logger2.listenerCount = logger2.eventNames = logger2.write = logger2.flush = noop;
377
- logger2.serializers = serializers;
378
- logger2._serialize = serialize;
379
- logger2._stdErrSerialize = stdErrSerialize;
380
- logger2.child = function(...args) {
381
- return child.call(this, setOpts, ...args);
382
- };
383
- if (transmit2) logger2._logEvent = createLogEventShape();
384
- function getLevelVal() {
385
- return levelToValue(this.level, this);
386
- }
387
- function getLevel() {
388
- return this._level;
389
- }
390
- function setLevel(level2) {
391
- if (level2 !== "silent" && !this.levels.values[level2]) {
392
- throw Error("unknown level " + level2);
393
- }
394
- this._level = level2;
395
- set(this, setOpts, logger2, "error");
396
- set(this, setOpts, logger2, "fatal");
397
- set(this, setOpts, logger2, "warn");
398
- set(this, setOpts, logger2, "info");
399
- set(this, setOpts, logger2, "debug");
400
- set(this, setOpts, logger2, "trace");
401
- customLevels.forEach((level3) => {
402
- set(this, setOpts, logger2, level3);
403
- });
404
- }
405
- function child(setOpts2, bindings, childOptions) {
406
- if (!bindings) {
407
- throw new Error("missing bindings for child Pino");
408
- }
409
- childOptions = childOptions || {};
410
- if (serialize && bindings.serializers) {
411
- childOptions.serializers = bindings.serializers;
412
- }
413
- const childOptionsSerializers = childOptions.serializers;
414
- if (serialize && childOptionsSerializers) {
415
- var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
416
- var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
417
- delete bindings.serializers;
418
- applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
419
- }
420
- function Child(parent) {
421
- this._childLevel = (parent._childLevel | 0) + 1;
422
- this.bindings = bindings;
423
- if (childSerializers) {
424
- this.serializers = childSerializers;
425
- this._serialize = childSerialize;
426
- }
427
- if (transmit2) {
428
- this._logEvent = createLogEventShape(
429
- [].concat(parent._logEvent.bindings, bindings)
430
- );
431
- }
432
- }
433
- Child.prototype = this;
434
- const newLogger = new Child(this);
435
- appendChildLogger(this, newLogger);
436
- newLogger.child = function(...args) {
437
- return child.call(this, setOpts2, ...args);
178
+ const enabled = typeof window !== "undefined" && !!window.localStorage.getItem("SL_DEBUG");
179
+ function createLogFn(consoleFn, prefix) {
180
+ if (!enabled)
181
+ return () => {
438
182
  };
439
- newLogger.level = childOptions.level || this.level;
440
- setOpts2.onChild(newLogger);
441
- return newLogger;
442
- }
443
- return logger2;
444
- }
445
- function getLevels(opts) {
446
- const customLevels = opts.customLevels || {};
447
- const values = Object.assign({}, pino.levels.values, customLevels);
448
- const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels));
449
- return {
450
- values,
451
- labels
452
- };
453
- }
454
- function invertObject(obj) {
455
- const inverted = {};
456
- Object.keys(obj).forEach(function(key) {
457
- inverted[obj[key]] = key;
458
- });
459
- return inverted;
460
- }
461
- pino.levels = {
462
- values: {
463
- fatal: 60,
464
- error: 50,
465
- warn: 40,
466
- info: 30,
467
- debug: 20,
468
- trace: 10
469
- },
470
- labels: {
471
- 10: "trace",
472
- 20: "debug",
473
- 30: "info",
474
- 40: "warn",
475
- 50: "error",
476
- 60: "fatal"
477
- }
478
- };
479
- pino.stdSerializers = stdSerializers;
480
- pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
481
- function getBindingChain(logger2) {
482
- const bindings = [];
483
- if (logger2.bindings) {
484
- bindings.push(logger2.bindings);
485
- }
486
- let hierarchy = logger2[hierarchySymbol];
487
- while (hierarchy.parent) {
488
- hierarchy = hierarchy.parent;
489
- if (hierarchy.logger.bindings) {
490
- bindings.push(hierarchy.logger.bindings);
491
- }
492
- }
493
- return bindings.reverse();
494
- }
495
- function set(self2, opts, rootLogger, level) {
496
- Object.defineProperty(self2, level, {
497
- value: levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level],
498
- writable: true,
499
- enumerable: true,
500
- configurable: true
501
- });
502
- if (self2[level] === noop) {
503
- if (!opts.transmit) return;
504
- const transmitLevel = opts.transmit.level || self2.level;
505
- const transmitValue = rootLogger.levels.values[transmitLevel];
506
- const methodValue = rootLogger.levels.values[level];
507
- if (methodValue < transmitValue) return;
508
- }
509
- self2[level] = createWrap(self2, opts, rootLogger, level);
510
- const bindings = getBindingChain(self2);
511
- if (bindings.length === 0) {
512
- return;
513
- }
514
- self2[level] = prependBindingsInArguments(bindings, self2[level]);
515
- }
516
- function prependBindingsInArguments(bindings, logFunc) {
517
- return function() {
518
- return logFunc.apply(this, [...bindings, ...arguments]);
519
- };
520
- }
521
- function createWrap(self2, opts, rootLogger, level) {
522
- return /* @__PURE__ */ function(write) {
523
- return function LOG() {
524
- const ts = opts.timestamp();
525
- const args = new Array(arguments.length);
526
- const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
527
- for (var i = 0; i < args.length; i++) args[i] = arguments[i];
528
- var argsIsSerialized = false;
529
- if (opts.serialize) {
530
- applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
531
- argsIsSerialized = true;
532
- }
533
- if (opts.asObject || opts.formatters) {
534
- write.call(proto, asObject(this, level, args, ts, opts));
535
- } else write.apply(proto, args);
536
- if (opts.transmit) {
537
- const transmitLevel = opts.transmit.level || self2._level;
538
- const transmitValue = rootLogger.levels.values[transmitLevel];
539
- const methodValue = rootLogger.levels.values[level];
540
- if (methodValue < transmitValue) return;
541
- transmit(this, {
542
- ts,
543
- methodLevel: level,
544
- methodValue,
545
- transmitLevel,
546
- transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level],
547
- send: opts.transmit.send,
548
- val: levelToValue(self2._level, rootLogger)
549
- }, args, argsIsSerialized);
550
- }
551
- };
552
- }(self2[baseLogFunctionSymbol][level]);
553
- }
554
- function asObject(logger2, level, args, ts, opts) {
555
- const {
556
- level: levelFormatter,
557
- log: logObjectFormatter = (obj) => obj
558
- } = opts.formatters || {};
559
- const argsCloned = args.slice();
560
- let msg = argsCloned[0];
561
- const logObject = {};
562
- if (ts) {
563
- logObject.time = ts;
564
- }
565
- if (levelFormatter) {
566
- const formattedLevel = levelFormatter(level, logger2.levels.values[level]);
567
- Object.assign(logObject, formattedLevel);
568
- } else {
569
- logObject.level = logger2.levels.values[level];
570
- }
571
- let lvl = (logger2._childLevel | 0) + 1;
572
- if (lvl < 1) lvl = 1;
573
- if (msg !== null && typeof msg === "object") {
574
- while (lvl-- && typeof argsCloned[0] === "object") {
575
- Object.assign(logObject, argsCloned.shift());
576
- }
577
- msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
578
- } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
579
- if (msg !== void 0) logObject[opts.messageKey] = msg;
580
- const formattedLogObject = logObjectFormatter(logObject);
581
- return formattedLogObject;
582
- }
583
- function applySerializers(args, serialize, serializers, stdErrSerialize) {
584
- for (const i in args) {
585
- if (stdErrSerialize && args[i] instanceof Error) {
586
- args[i] = pino.stdSerializers.err(args[i]);
587
- } else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) {
588
- for (const k in args[i]) {
589
- if (serialize.indexOf(k) > -1 && k in serializers) {
590
- args[i][k] = serializers[k](args[i][k]);
591
- }
592
- }
183
+ return (...args) => {
184
+ if (args.length === 0)
185
+ return;
186
+ if (typeof args[0] === "string") {
187
+ consoleFn(`[${prefix}]`, ...args);
188
+ } else {
189
+ const [obj, ...rest] = args;
190
+ consoleFn(`[${prefix}]`, ...rest, obj);
593
191
  }
594
- }
595
- }
596
- function transmit(logger2, opts, args, argsIsSerialized = false) {
597
- const send = opts.send;
598
- const ts = opts.ts;
599
- const methodLevel = opts.methodLevel;
600
- const methodValue = opts.methodValue;
601
- const val = opts.val;
602
- const bindings = logger2._logEvent.bindings;
603
- if (!argsIsSerialized) {
604
- applySerializers(
605
- args,
606
- logger2._serialize || Object.keys(logger2.serializers),
607
- logger2.serializers,
608
- logger2._stdErrSerialize === void 0 ? true : logger2._stdErrSerialize
609
- );
610
- }
611
- logger2._logEvent.ts = ts;
612
- logger2._logEvent.messages = args.filter(function(arg) {
613
- return bindings.indexOf(arg) === -1;
614
- });
615
- logger2._logEvent.level.label = methodLevel;
616
- logger2._logEvent.level.value = methodValue;
617
- send(methodLevel, logger2._logEvent, val);
618
- logger2._logEvent = createLogEventShape(bindings);
619
- }
620
- function createLogEventShape(bindings) {
621
- return {
622
- ts: 0,
623
- messages: [],
624
- bindings: bindings || [],
625
- level: { label: "", value: 0 }
626
192
  };
627
193
  }
628
- function asErrValue(err) {
629
- const obj = {
630
- type: err.constructor.name,
631
- msg: err.message,
632
- stack: err.stack
633
- };
634
- for (const key in err) {
635
- if (obj[key] === void 0) {
636
- obj[key] = err[key];
194
+ function createLoggerInstance(bindings) {
195
+ const prefix = bindings.name || "app";
196
+ const instance = {
197
+ level: "trace",
198
+ child(childBindings, _options) {
199
+ return createLoggerInstance({ ...bindings, ...childBindings });
637
200
  }
201
+ };
202
+ for (const level of LEVELS) {
203
+ const method = LEVEL_MAP[level];
204
+ const consoleFn = (...a) => console[method](...a);
205
+ instance[level] = createLogFn(consoleFn, prefix);
638
206
  }
639
- return obj;
640
- }
641
- function getTimeFunction(opts) {
642
- if (typeof opts.timestamp === "function") {
643
- return opts.timestamp;
644
- }
645
- if (opts.timestamp === false) {
646
- return nullTime;
647
- }
648
- return epochTime;
649
- }
650
- function mock() {
651
- return {};
652
- }
653
- function passthrough(a) {
654
- return a;
655
- }
656
- function noop() {
657
- }
658
- function nullTime() {
659
- return false;
660
- }
661
- function epochTime() {
662
- return Date.now();
663
- }
664
- function unixTime() {
665
- return Math.round(Date.now() / 1e3);
666
- }
667
- function isoTime() {
668
- return new Date(Date.now()).toISOString();
669
- }
670
- function pfGlobalThisOrFallback() {
671
- function defd(o) {
672
- return typeof o !== "undefined" && o;
673
- }
674
- try {
675
- if (typeof globalThis !== "undefined") return globalThis;
676
- Object.defineProperty(Object.prototype, "globalThis", {
677
- get: function() {
678
- delete Object.prototype.globalThis;
679
- return this.globalThis = this;
680
- },
681
- configurable: true
682
- });
683
- return globalThis;
684
- } catch (e) {
685
- return defd(self) || defd(window) || defd(this) || {};
686
- }
207
+ return instance;
687
208
  }
688
- browser.exports.default = pino;
689
- var pino_1 = browser.exports.pino = pino;
690
- const logger = pino_1({
691
- level: "trace",
692
- enabled: typeof window !== "undefined" && !!window.localStorage.getItem("SL_DEBUG"),
693
- browser: {
694
- write: (o) => {
695
- console.log(o);
696
- }
697
- }
698
- });
699
- const createLogger = (name, options) => logger.child({ name }, options);
209
+ const rootLogger = createLoggerInstance({});
210
+ const createLogger = (name, options) => rootLogger.child({ name }, options);
700
211
  createLogger("event-bus");
701
212
  function protoCamelCase(snakeCase) {
702
213
  let capNext = false;
package/lib/es/index.js CHANGED
@@ -5,8 +5,8 @@ import { importJWK, EncryptJWT } from "jose";
5
5
  function getDefaultExportFromCjs(x) {
6
6
  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
7
7
  }
8
- var browser$1 = { exports: {} };
9
- var process = browser$1.exports = {};
8
+ var browser = { exports: {} };
9
+ var process = browser.exports = {};
10
10
  var cachedSetTimeout;
11
11
  var cachedClearTimeout;
12
12
  function defaultSetTimout() {
@@ -136,17 +136,17 @@ process.env = {};
136
136
  process.argv = [];
137
137
  process.version = "";
138
138
  process.versions = {};
139
- function noop$1() {
140
- }
141
- process.on = noop$1;
142
- process.addListener = noop$1;
143
- process.once = noop$1;
144
- process.off = noop$1;
145
- process.removeListener = noop$1;
146
- process.removeAllListeners = noop$1;
147
- process.emit = noop$1;
148
- process.prependListener = noop$1;
149
- process.prependOnceListener = noop$1;
139
+ function noop() {
140
+ }
141
+ process.on = noop;
142
+ process.addListener = noop;
143
+ process.once = noop;
144
+ process.off = noop;
145
+ process.removeListener = noop;
146
+ process.removeAllListeners = noop;
147
+ process.emit = noop;
148
+ process.prependListener = noop;
149
+ process.prependOnceListener = noop;
150
150
  process.listeners = function(name) {
151
151
  return [];
152
152
  };
@@ -162,539 +162,50 @@ process.chdir = function(dir) {
162
162
  process.umask = function() {
163
163
  return 0;
164
164
  };
165
- var browserExports = browser$1.exports;
165
+ var browserExports = browser.exports;
166
166
  const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
167
- var browser = { exports: {} };
168
- function tryStringify(o) {
169
- try {
170
- return JSON.stringify(o);
171
- } catch (e) {
172
- return '"[Circular]"';
173
- }
174
- }
175
- var quickFormatUnescaped = format$1;
176
- function format$1(f, args, opts) {
177
- var ss = opts && opts.stringify || tryStringify;
178
- var offset = 1;
179
- if (typeof f === "object" && f !== null) {
180
- var len = args.length + offset;
181
- if (len === 1) return f;
182
- var objects = new Array(len);
183
- objects[0] = ss(f);
184
- for (var index = 1; index < len; index++) {
185
- objects[index] = ss(args[index]);
186
- }
187
- return objects.join(" ");
188
- }
189
- if (typeof f !== "string") {
190
- return f;
191
- }
192
- var argLen = args.length;
193
- if (argLen === 0) return f;
194
- var str = "";
195
- var a = 1 - offset;
196
- var lastPos = -1;
197
- var flen = f && f.length || 0;
198
- for (var i = 0; i < flen; ) {
199
- if (f.charCodeAt(i) === 37 && i + 1 < flen) {
200
- lastPos = lastPos > -1 ? lastPos : 0;
201
- switch (f.charCodeAt(i + 1)) {
202
- case 100:
203
- case 102:
204
- if (a >= argLen)
205
- break;
206
- if (args[a] == null) break;
207
- if (lastPos < i)
208
- str += f.slice(lastPos, i);
209
- str += Number(args[a]);
210
- lastPos = i + 2;
211
- i++;
212
- break;
213
- case 105:
214
- if (a >= argLen)
215
- break;
216
- if (args[a] == null) break;
217
- if (lastPos < i)
218
- str += f.slice(lastPos, i);
219
- str += Math.floor(Number(args[a]));
220
- lastPos = i + 2;
221
- i++;
222
- break;
223
- case 79:
224
- case 111:
225
- case 106:
226
- if (a >= argLen)
227
- break;
228
- if (args[a] === void 0) break;
229
- if (lastPos < i)
230
- str += f.slice(lastPos, i);
231
- var type = typeof args[a];
232
- if (type === "string") {
233
- str += "'" + args[a] + "'";
234
- lastPos = i + 2;
235
- i++;
236
- break;
237
- }
238
- if (type === "function") {
239
- str += args[a].name || "<anonymous>";
240
- lastPos = i + 2;
241
- i++;
242
- break;
243
- }
244
- str += ss(args[a]);
245
- lastPos = i + 2;
246
- i++;
247
- break;
248
- case 115:
249
- if (a >= argLen)
250
- break;
251
- if (lastPos < i)
252
- str += f.slice(lastPos, i);
253
- str += String(args[a]);
254
- lastPos = i + 2;
255
- i++;
256
- break;
257
- case 37:
258
- if (lastPos < i)
259
- str += f.slice(lastPos, i);
260
- str += "%";
261
- lastPos = i + 2;
262
- i++;
263
- a--;
264
- break;
265
- }
266
- ++a;
267
- }
268
- ++i;
269
- }
270
- if (lastPos === -1)
271
- return f;
272
- else if (lastPos < flen) {
273
- str += f.slice(lastPos);
274
- }
275
- return str;
276
- }
277
- const format = quickFormatUnescaped;
278
- browser.exports = pino;
279
- const _console = pfGlobalThisOrFallback().console || {};
280
- const stdSerializers = {
281
- mapHttpRequest: mock,
282
- mapHttpResponse: mock,
283
- wrapRequestSerializer: passthrough,
284
- wrapResponseSerializer: passthrough,
285
- wrapErrorSerializer: passthrough,
286
- req: mock,
287
- res: mock,
288
- err: asErrValue,
289
- errWithCause: asErrValue
290
- };
291
- function levelToValue(level, logger2) {
292
- return level === "silent" ? Infinity : logger2.levels.values[level];
293
- }
294
- const baseLogFunctionSymbol = Symbol("pino.logFuncs");
295
- const hierarchySymbol = Symbol("pino.hierarchy");
296
- const logFallbackMap = {
297
- error: "log",
298
- fatal: "error",
299
- warn: "error",
300
- info: "log",
301
- debug: "log",
302
- trace: "log"
167
+ const LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
168
+ const LEVEL_MAP = {
169
+ trace: "debug",
170
+ debug: "debug",
171
+ info: "info",
172
+ warn: "warn",
173
+ error: "error",
174
+ fatal: "error"
303
175
  };
304
- function appendChildLogger(parentLogger, childLogger) {
305
- const newEntry = {
306
- logger: childLogger,
307
- parent: parentLogger[hierarchySymbol]
308
- };
309
- childLogger[hierarchySymbol] = newEntry;
310
- }
311
- function setupBaseLogFunctions(logger2, levels, proto) {
312
- const logFunctions = {};
313
- levels.forEach((level) => {
314
- logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop;
315
- });
316
- logger2[baseLogFunctionSymbol] = logFunctions;
317
- }
318
- function shouldSerialize(serialize, serializers) {
319
- if (Array.isArray(serialize)) {
320
- const hasToFilter = serialize.filter(function(k) {
321
- return k !== "!stdSerializers.err";
322
- });
323
- return hasToFilter;
324
- } else if (serialize === true) {
325
- return Object.keys(serializers);
326
- }
327
- return false;
328
- }
329
- function pino(opts) {
330
- opts = opts || {};
331
- opts.browser = opts.browser || {};
332
- const transmit2 = opts.browser.transmit;
333
- if (transmit2 && typeof transmit2.send !== "function") {
334
- throw Error("pino: transmit option must have a send function");
335
- }
336
- const proto = opts.browser.write || _console;
337
- if (opts.browser.write) opts.browser.asObject = true;
338
- const serializers = opts.serializers || {};
339
- const serialize = shouldSerialize(opts.browser.serialize, serializers);
340
- let stdErrSerialize = opts.browser.serialize;
341
- if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
342
- const customLevels = Object.keys(opts.customLevels || {});
343
- const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels);
344
- if (typeof proto === "function") {
345
- levels.forEach(function(level2) {
346
- proto[level2] = proto;
347
- });
348
- }
349
- if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
350
- const level = opts.level || "info";
351
- const logger2 = Object.create(proto);
352
- if (!logger2.log) logger2.log = noop;
353
- setupBaseLogFunctions(logger2, levels, proto);
354
- appendChildLogger({}, logger2);
355
- Object.defineProperty(logger2, "levelVal", {
356
- get: getLevelVal
357
- });
358
- Object.defineProperty(logger2, "level", {
359
- get: getLevel,
360
- set: setLevel
361
- });
362
- const setOpts = {
363
- transmit: transmit2,
364
- serialize,
365
- asObject: opts.browser.asObject,
366
- formatters: opts.browser.formatters,
367
- levels,
368
- timestamp: getTimeFunction(opts),
369
- messageKey: opts.messageKey || "msg",
370
- onChild: opts.onChild || noop
371
- };
372
- logger2.levels = getLevels(opts);
373
- logger2.level = level;
374
- logger2.setMaxListeners = logger2.getMaxListeners = logger2.emit = logger2.addListener = logger2.on = logger2.prependListener = logger2.once = logger2.prependOnceListener = logger2.removeListener = logger2.removeAllListeners = logger2.listeners = logger2.listenerCount = logger2.eventNames = logger2.write = logger2.flush = noop;
375
- logger2.serializers = serializers;
376
- logger2._serialize = serialize;
377
- logger2._stdErrSerialize = stdErrSerialize;
378
- logger2.child = function(...args) {
379
- return child.call(this, setOpts, ...args);
380
- };
381
- if (transmit2) logger2._logEvent = createLogEventShape();
382
- function getLevelVal() {
383
- return levelToValue(this.level, this);
384
- }
385
- function getLevel() {
386
- return this._level;
387
- }
388
- function setLevel(level2) {
389
- if (level2 !== "silent" && !this.levels.values[level2]) {
390
- throw Error("unknown level " + level2);
391
- }
392
- this._level = level2;
393
- set(this, setOpts, logger2, "error");
394
- set(this, setOpts, logger2, "fatal");
395
- set(this, setOpts, logger2, "warn");
396
- set(this, setOpts, logger2, "info");
397
- set(this, setOpts, logger2, "debug");
398
- set(this, setOpts, logger2, "trace");
399
- customLevels.forEach((level3) => {
400
- set(this, setOpts, logger2, level3);
401
- });
402
- }
403
- function child(setOpts2, bindings, childOptions) {
404
- if (!bindings) {
405
- throw new Error("missing bindings for child Pino");
406
- }
407
- childOptions = childOptions || {};
408
- if (serialize && bindings.serializers) {
409
- childOptions.serializers = bindings.serializers;
410
- }
411
- const childOptionsSerializers = childOptions.serializers;
412
- if (serialize && childOptionsSerializers) {
413
- var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
414
- var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
415
- delete bindings.serializers;
416
- applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
417
- }
418
- function Child(parent) {
419
- this._childLevel = (parent._childLevel | 0) + 1;
420
- this.bindings = bindings;
421
- if (childSerializers) {
422
- this.serializers = childSerializers;
423
- this._serialize = childSerialize;
424
- }
425
- if (transmit2) {
426
- this._logEvent = createLogEventShape(
427
- [].concat(parent._logEvent.bindings, bindings)
428
- );
429
- }
430
- }
431
- Child.prototype = this;
432
- const newLogger = new Child(this);
433
- appendChildLogger(this, newLogger);
434
- newLogger.child = function(...args) {
435
- return child.call(this, setOpts2, ...args);
176
+ const enabled = typeof window !== "undefined" && !!window.localStorage.getItem("SL_DEBUG");
177
+ function createLogFn(consoleFn, prefix) {
178
+ if (!enabled)
179
+ return () => {
436
180
  };
437
- newLogger.level = childOptions.level || this.level;
438
- setOpts2.onChild(newLogger);
439
- return newLogger;
440
- }
441
- return logger2;
442
- }
443
- function getLevels(opts) {
444
- const customLevels = opts.customLevels || {};
445
- const values = Object.assign({}, pino.levels.values, customLevels);
446
- const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels));
447
- return {
448
- values,
449
- labels
450
- };
451
- }
452
- function invertObject(obj) {
453
- const inverted = {};
454
- Object.keys(obj).forEach(function(key) {
455
- inverted[obj[key]] = key;
456
- });
457
- return inverted;
458
- }
459
- pino.levels = {
460
- values: {
461
- fatal: 60,
462
- error: 50,
463
- warn: 40,
464
- info: 30,
465
- debug: 20,
466
- trace: 10
467
- },
468
- labels: {
469
- 10: "trace",
470
- 20: "debug",
471
- 30: "info",
472
- 40: "warn",
473
- 50: "error",
474
- 60: "fatal"
475
- }
476
- };
477
- pino.stdSerializers = stdSerializers;
478
- pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
479
- function getBindingChain(logger2) {
480
- const bindings = [];
481
- if (logger2.bindings) {
482
- bindings.push(logger2.bindings);
483
- }
484
- let hierarchy = logger2[hierarchySymbol];
485
- while (hierarchy.parent) {
486
- hierarchy = hierarchy.parent;
487
- if (hierarchy.logger.bindings) {
488
- bindings.push(hierarchy.logger.bindings);
489
- }
490
- }
491
- return bindings.reverse();
492
- }
493
- function set(self2, opts, rootLogger, level) {
494
- Object.defineProperty(self2, level, {
495
- value: levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level],
496
- writable: true,
497
- enumerable: true,
498
- configurable: true
499
- });
500
- if (self2[level] === noop) {
501
- if (!opts.transmit) return;
502
- const transmitLevel = opts.transmit.level || self2.level;
503
- const transmitValue = rootLogger.levels.values[transmitLevel];
504
- const methodValue = rootLogger.levels.values[level];
505
- if (methodValue < transmitValue) return;
506
- }
507
- self2[level] = createWrap(self2, opts, rootLogger, level);
508
- const bindings = getBindingChain(self2);
509
- if (bindings.length === 0) {
510
- return;
511
- }
512
- self2[level] = prependBindingsInArguments(bindings, self2[level]);
513
- }
514
- function prependBindingsInArguments(bindings, logFunc) {
515
- return function() {
516
- return logFunc.apply(this, [...bindings, ...arguments]);
517
- };
518
- }
519
- function createWrap(self2, opts, rootLogger, level) {
520
- return /* @__PURE__ */ function(write) {
521
- return function LOG() {
522
- const ts = opts.timestamp();
523
- const args = new Array(arguments.length);
524
- const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
525
- for (var i = 0; i < args.length; i++) args[i] = arguments[i];
526
- var argsIsSerialized = false;
527
- if (opts.serialize) {
528
- applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
529
- argsIsSerialized = true;
530
- }
531
- if (opts.asObject || opts.formatters) {
532
- write.call(proto, asObject(this, level, args, ts, opts));
533
- } else write.apply(proto, args);
534
- if (opts.transmit) {
535
- const transmitLevel = opts.transmit.level || self2._level;
536
- const transmitValue = rootLogger.levels.values[transmitLevel];
537
- const methodValue = rootLogger.levels.values[level];
538
- if (methodValue < transmitValue) return;
539
- transmit(this, {
540
- ts,
541
- methodLevel: level,
542
- methodValue,
543
- transmitLevel,
544
- transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level],
545
- send: opts.transmit.send,
546
- val: levelToValue(self2._level, rootLogger)
547
- }, args, argsIsSerialized);
548
- }
549
- };
550
- }(self2[baseLogFunctionSymbol][level]);
551
- }
552
- function asObject(logger2, level, args, ts, opts) {
553
- const {
554
- level: levelFormatter,
555
- log: logObjectFormatter = (obj) => obj
556
- } = opts.formatters || {};
557
- const argsCloned = args.slice();
558
- let msg = argsCloned[0];
559
- const logObject = {};
560
- if (ts) {
561
- logObject.time = ts;
562
- }
563
- if (levelFormatter) {
564
- const formattedLevel = levelFormatter(level, logger2.levels.values[level]);
565
- Object.assign(logObject, formattedLevel);
566
- } else {
567
- logObject.level = logger2.levels.values[level];
568
- }
569
- let lvl = (logger2._childLevel | 0) + 1;
570
- if (lvl < 1) lvl = 1;
571
- if (msg !== null && typeof msg === "object") {
572
- while (lvl-- && typeof argsCloned[0] === "object") {
573
- Object.assign(logObject, argsCloned.shift());
574
- }
575
- msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
576
- } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
577
- if (msg !== void 0) logObject[opts.messageKey] = msg;
578
- const formattedLogObject = logObjectFormatter(logObject);
579
- return formattedLogObject;
580
- }
581
- function applySerializers(args, serialize, serializers, stdErrSerialize) {
582
- for (const i in args) {
583
- if (stdErrSerialize && args[i] instanceof Error) {
584
- args[i] = pino.stdSerializers.err(args[i]);
585
- } else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) {
586
- for (const k in args[i]) {
587
- if (serialize.indexOf(k) > -1 && k in serializers) {
588
- args[i][k] = serializers[k](args[i][k]);
589
- }
590
- }
181
+ return (...args) => {
182
+ if (args.length === 0)
183
+ return;
184
+ if (typeof args[0] === "string") {
185
+ consoleFn(`[${prefix}]`, ...args);
186
+ } else {
187
+ const [obj, ...rest] = args;
188
+ consoleFn(`[${prefix}]`, ...rest, obj);
591
189
  }
592
- }
593
- }
594
- function transmit(logger2, opts, args, argsIsSerialized = false) {
595
- const send = opts.send;
596
- const ts = opts.ts;
597
- const methodLevel = opts.methodLevel;
598
- const methodValue = opts.methodValue;
599
- const val = opts.val;
600
- const bindings = logger2._logEvent.bindings;
601
- if (!argsIsSerialized) {
602
- applySerializers(
603
- args,
604
- logger2._serialize || Object.keys(logger2.serializers),
605
- logger2.serializers,
606
- logger2._stdErrSerialize === void 0 ? true : logger2._stdErrSerialize
607
- );
608
- }
609
- logger2._logEvent.ts = ts;
610
- logger2._logEvent.messages = args.filter(function(arg) {
611
- return bindings.indexOf(arg) === -1;
612
- });
613
- logger2._logEvent.level.label = methodLevel;
614
- logger2._logEvent.level.value = methodValue;
615
- send(methodLevel, logger2._logEvent, val);
616
- logger2._logEvent = createLogEventShape(bindings);
617
- }
618
- function createLogEventShape(bindings) {
619
- return {
620
- ts: 0,
621
- messages: [],
622
- bindings: bindings || [],
623
- level: { label: "", value: 0 }
624
190
  };
625
191
  }
626
- function asErrValue(err) {
627
- const obj = {
628
- type: err.constructor.name,
629
- msg: err.message,
630
- stack: err.stack
631
- };
632
- for (const key in err) {
633
- if (obj[key] === void 0) {
634
- obj[key] = err[key];
192
+ function createLoggerInstance(bindings) {
193
+ const prefix = bindings.name || "app";
194
+ const instance = {
195
+ level: "trace",
196
+ child(childBindings, _options) {
197
+ return createLoggerInstance({ ...bindings, ...childBindings });
635
198
  }
199
+ };
200
+ for (const level of LEVELS) {
201
+ const method = LEVEL_MAP[level];
202
+ const consoleFn = (...a) => console[method](...a);
203
+ instance[level] = createLogFn(consoleFn, prefix);
636
204
  }
637
- return obj;
638
- }
639
- function getTimeFunction(opts) {
640
- if (typeof opts.timestamp === "function") {
641
- return opts.timestamp;
642
- }
643
- if (opts.timestamp === false) {
644
- return nullTime;
645
- }
646
- return epochTime;
647
- }
648
- function mock() {
649
- return {};
650
- }
651
- function passthrough(a) {
652
- return a;
653
- }
654
- function noop() {
655
- }
656
- function nullTime() {
657
- return false;
658
- }
659
- function epochTime() {
660
- return Date.now();
661
- }
662
- function unixTime() {
663
- return Math.round(Date.now() / 1e3);
664
- }
665
- function isoTime() {
666
- return new Date(Date.now()).toISOString();
667
- }
668
- function pfGlobalThisOrFallback() {
669
- function defd(o) {
670
- return typeof o !== "undefined" && o;
671
- }
672
- try {
673
- if (typeof globalThis !== "undefined") return globalThis;
674
- Object.defineProperty(Object.prototype, "globalThis", {
675
- get: function() {
676
- delete Object.prototype.globalThis;
677
- return this.globalThis = this;
678
- },
679
- configurable: true
680
- });
681
- return globalThis;
682
- } catch (e) {
683
- return defd(self) || defd(window) || defd(this) || {};
684
- }
205
+ return instance;
685
206
  }
686
- browser.exports.default = pino;
687
- var pino_1 = browser.exports.pino = pino;
688
- const logger = pino_1({
689
- level: "trace",
690
- enabled: typeof window !== "undefined" && !!window.localStorage.getItem("SL_DEBUG"),
691
- browser: {
692
- write: (o) => {
693
- console.log(o);
694
- }
695
- }
696
- });
697
- const createLogger = (name, options) => logger.child({ name }, options);
207
+ const rootLogger = createLoggerInstance({});
208
+ const createLogger = (name, options) => rootLogger.child({ name }, options);
698
209
  createLogger("event-bus");
699
210
  function protoCamelCase(snakeCase) {
700
211
  let capNext = false;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@streamlayer/sdk-web-anonymous-auth",
3
- "version": "1.3.15",
3
+ "version": "1.3.16",
4
4
  "author": "StreamLayer, Inc (https://streamlayer.io)",
5
5
  "maintainers": [
6
6
  {
@@ -29,7 +29,7 @@
29
29
  "peerDependencies": {
30
30
  "@streamlayer/sl-eslib": "^5.228.0",
31
31
  "jose": "^5.9.3",
32
- "@streamlayer/sdk-web": "^1.17.6"
32
+ "@streamlayer/sdk-web": "^1.17.7"
33
33
  },
34
34
  "devDependencies": {
35
35
  "@nx/devkit": "20.4.2",
@@ -44,8 +44,8 @@
44
44
  "vite-plugin-node-polyfills": "^0.22.0",
45
45
  "vite-tsconfig-paths": "^5.0.1",
46
46
  "webpack": "^5.95.0",
47
- "@streamlayer/sdk-web-api": "^1.15.6",
48
- "@streamlayer/sdk-web-core": "^1.20.3",
49
- "@streamlayer/sdk-web-interfaces": "^1.9.6"
47
+ "@streamlayer/sdk-web-api": "^1.15.7",
48
+ "@streamlayer/sdk-web-core": "^1.20.4",
49
+ "@streamlayer/sdk-web-interfaces": "^1.9.7"
50
50
  }
51
51
  }