@safaricom-mxl/web-sdk 0.0.11 → 0.0.13

package/dist/utils/performanceObserver/performanceObserver.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils/performanceObserver/performanceObserver.ts
+function isEntryTypeSupported(type) {
+	return typeof PerformanceObserver !== "undefined" && (PerformanceObserver.supportedEntryTypes?.includes(type) ?? false);
+}
+/**
+* Creates a PerformanceObserver for the specified entry type if supported, and starts observing.
+* Returns the observer instance, or null if the entry type is not supported or if an error occurs.
+*
+* Each entry is passed individually to `processEntry`. Errors thrown by `processEntry` are caught
+* and logged via `diag` (if provided) so that one bad entry does not block the rest.
+*
+* Note: The observer is created with the "buffered" option set to true, so it will receive entries
+* that were recorded before the observer was created.
+* buffered: true is not supported when observing multiple entry types, so if you need to observe
+* multiple types, you should create separate observers for each type with buffered: true.
+* See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe#entrytypes
+*/
+function createPerformanceObserver(type, processEntry, options) {
+	const { diag, ...observeOptions } = options ?? {};
+	if (!isEntryTypeSupported(type)) {
+		diag?.debug(`${type} not supported, skipping observer`);
+		return null;
+	}
+	try {
+		const observer = new PerformanceObserver((list) => {
+			for (const entry of list.getEntries()) try {
+				processEntry(entry);
+			} catch (e) {
+				diag?.error(`error processing ${type} entry`, e);
+			}
+		});
+		observer.observe({
+			type,
+			buffered: true,
+			...observeOptions
+		});
+		return observer;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+exports.createPerformanceObserver = createPerformanceObserver;
+exports.isEntryTypeSupported = isEntryTypeSupported;
+
+//# sourceMappingURL=performanceObserver.cjs.map

package/dist/utils/performanceObserver/performanceObserver.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceObserver.cjs","names":[],"sources":["../../../src/utils/performanceObserver/performanceObserver.ts"],"sourcesContent":["import type { DiagLogger } from '@opentelemetry/api';\n\nexport function isEntryTypeSupported(type: string): boolean {\n  return (\n    typeof PerformanceObserver !== 'undefined' &&\n    (PerformanceObserver.supportedEntryTypes?.includes(type) ?? false)\n  );\n}\n\n/**\n * Creates a PerformanceObserver for the specified entry type if supported, and starts observing.\n * Returns the observer instance, or null if the entry type is not supported or if an error occurs.\n *\n * Each entry is passed individually to `processEntry`. Errors thrown by `processEntry` are caught\n * and logged via `diag` (if provided) so that one bad entry does not block the rest.\n *\n * Note: The observer is created with the \"buffered\" option set to true, so it will receive entries\n * that were recorded before the observer was created.\n * buffered: true is not supported when observing multiple entry types, so if you need to observe\n * multiple types, you should create separate observers for each type with buffered: true.\n * See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe#entrytypes\n */\nexport function createPerformanceObserver<T extends PerformanceEntry>(\n  type: string,\n  processEntry: (entry: T) => void,\n  options?: PerformanceObserverInit & { diag?: DiagLogger },\n): PerformanceObserver | null {\n  const { diag, ...observeOptions } = options ?? {};\n\n  if (!isEntryTypeSupported(type)) {\n    diag?.debug(`${type} not supported, skipping observer`);\n    return null;\n  }\n\n  try {\n    const observer = new PerformanceObserver((list) => {\n      for (const entry of list.getEntries() as T[]) {\n        try {\n          processEntry(entry);\n        } catch (e) {\n          diag?.error(`error processing ${type} entry`, e);\n        }\n      }\n    });\n    observer.observe({ type, buffered: true, ...observeOptions });\n    return observer;\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;AAEA,SAAgB,qBAAqB,MAAuB;AAC1D,QACE,OAAO,wBAAwB,gBAC9B,oBAAoB,qBAAqB,SAAS,KAAK,IAAI;;;;;;;;;;;;;;;AAiBhE,SAAgB,0BACd,MACA,cACA,SAC4B;CAC5B,MAAM,EAAE,MAAM,GAAG,mBAAmB,WAAW,EAAE;AAEjD,KAAI,CAAC,qBAAqB,KAAK,EAAE;AAC/B,QAAM,MAAM,GAAG,KAAK,mCAAmC;AACvD,SAAO;;AAGT,KAAI;EACF,MAAM,WAAW,IAAI,qBAAqB,SAAS;AACjD,QAAK,MAAM,SAAS,KAAK,YAAY,CACnC,KAAI;AACF,iBAAa,MAAM;YACZ,GAAG;AACV,UAAM,MAAM,oBAAoB,KAAK,SAAS,EAAE;;IAGpD;AACF,WAAS,QAAQ;GAAE;GAAM,UAAU;GAAM,GAAG;GAAgB,CAAC;AAC7D,SAAO;SACD;AACN,SAAO"}

package/dist/utils/performanceObserver/performanceObserver.d.cts

@@ -0,0 +1,23 @@
+import { DiagLogger } from "@opentelemetry/api";
+
+//#region src/utils/performanceObserver/performanceObserver.d.ts
+declare function isEntryTypeSupported(type: string): boolean;
+/**
+ * Creates a PerformanceObserver for the specified entry type if supported, and starts observing.
+ * Returns the observer instance, or null if the entry type is not supported or if an error occurs.
+ *
+ * Each entry is passed individually to `processEntry`. Errors thrown by `processEntry` are caught
+ * and logged via `diag` (if provided) so that one bad entry does not block the rest.
+ *
+ * Note: The observer is created with the "buffered" option set to true, so it will receive entries
+ * that were recorded before the observer was created.
+ * buffered: true is not supported when observing multiple entry types, so if you need to observe
+ * multiple types, you should create separate observers for each type with buffered: true.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe#entrytypes
+ */
+declare function createPerformanceObserver<T extends PerformanceEntry>(type: string, processEntry: (entry: T) => void, options?: PerformanceObserverInit & {
+  diag?: DiagLogger;
+}): PerformanceObserver | null;
+//#endregion
+export { createPerformanceObserver, isEntryTypeSupported };
+//# sourceMappingURL=performanceObserver.d.cts.map

package/dist/utils/performanceObserver/performanceObserver.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceObserver.d.cts","names":[],"sources":["../../../src/utils/performanceObserver/performanceObserver.ts"],"mappings":";;;iBAEgB,oBAAA,CAAqB,IAAA;;AAArC;;;;;AAoBA;;;;;;;iBAAgB,yBAAA,WAAoC,gBAAA,CAAA,CAClD,IAAA,UACA,YAAA,GAAe,KAAA,EAAO,CAAA,WACtB,OAAA,GAAU,uBAAA;EAA4B,IAAA,GAAO,UAAA;AAAA,IAC5C,mBAAA"}

package/dist/utils/performanceObserver/performanceObserver.d.ts

@@ -0,0 +1,23 @@
+import { DiagLogger } from "@opentelemetry/api";
+
+//#region src/utils/performanceObserver/performanceObserver.d.ts
+declare function isEntryTypeSupported(type: string): boolean;
+/**
+ * Creates a PerformanceObserver for the specified entry type if supported, and starts observing.
+ * Returns the observer instance, or null if the entry type is not supported or if an error occurs.
+ *
+ * Each entry is passed individually to `processEntry`. Errors thrown by `processEntry` are caught
+ * and logged via `diag` (if provided) so that one bad entry does not block the rest.
+ *
+ * Note: The observer is created with the "buffered" option set to true, so it will receive entries
+ * that were recorded before the observer was created.
+ * buffered: true is not supported when observing multiple entry types, so if you need to observe
+ * multiple types, you should create separate observers for each type with buffered: true.
+ * See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe#entrytypes
+ */
+declare function createPerformanceObserver<T extends PerformanceEntry>(type: string, processEntry: (entry: T) => void, options?: PerformanceObserverInit & {
+  diag?: DiagLogger;
+}): PerformanceObserver | null;
+//#endregion
+export { createPerformanceObserver, isEntryTypeSupported };
+//# sourceMappingURL=performanceObserver.d.ts.map

package/dist/utils/performanceObserver/performanceObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceObserver.d.ts","names":[],"sources":["../../../src/utils/performanceObserver/performanceObserver.ts"],"mappings":";;;iBAEgB,oBAAA,CAAqB,IAAA;;AAArC;;;;;AAoBA;;;;;;;iBAAgB,yBAAA,WAAoC,gBAAA,CAAA,CAClD,IAAA,UACA,YAAA,GAAe,KAAA,EAAO,CAAA,WACtB,OAAA,GAAU,uBAAA;EAA4B,IAAA,GAAO,UAAA;AAAA,IAC5C,mBAAA"}

package/dist/utils/performanceObserver/performanceObserver.js

@@ -0,0 +1,45 @@
+//#region src/utils/performanceObserver/performanceObserver.ts
+function isEntryTypeSupported(type) {
+	return typeof PerformanceObserver !== "undefined" && (PerformanceObserver.supportedEntryTypes?.includes(type) ?? false);
+}
+/**
+* Creates a PerformanceObserver for the specified entry type if supported, and starts observing.
+* Returns the observer instance, or null if the entry type is not supported or if an error occurs.
+*
+* Each entry is passed individually to `processEntry`. Errors thrown by `processEntry` are caught
+* and logged via `diag` (if provided) so that one bad entry does not block the rest.
+*
+* Note: The observer is created with the "buffered" option set to true, so it will receive entries
+* that were recorded before the observer was created.
+* buffered: true is not supported when observing multiple entry types, so if you need to observe
+* multiple types, you should create separate observers for each type with buffered: true.
+* See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe#entrytypes
+*/
+function createPerformanceObserver(type, processEntry, options) {
+	const { diag, ...observeOptions } = options ?? {};
+	if (!isEntryTypeSupported(type)) {
+		diag?.debug(`${type} not supported, skipping observer`);
+		return null;
+	}
+	try {
+		const observer = new PerformanceObserver((list) => {
+			for (const entry of list.getEntries()) try {
+				processEntry(entry);
+			} catch (e) {
+				diag?.error(`error processing ${type} entry`, e);
+			}
+		});
+		observer.observe({
+			type,
+			buffered: true,
+			...observeOptions
+		});
+		return observer;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { createPerformanceObserver, isEntryTypeSupported };
+
+//# sourceMappingURL=performanceObserver.js.map

package/dist/utils/performanceObserver/performanceObserver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceObserver.js","names":[],"sources":["../../../src/utils/performanceObserver/performanceObserver.ts"],"sourcesContent":["import type { DiagLogger } from '@opentelemetry/api';\n\nexport function isEntryTypeSupported(type: string): boolean {\n  return (\n    typeof PerformanceObserver !== 'undefined' &&\n    (PerformanceObserver.supportedEntryTypes?.includes(type) ?? false)\n  );\n}\n\n/**\n * Creates a PerformanceObserver for the specified entry type if supported, and starts observing.\n * Returns the observer instance, or null if the entry type is not supported or if an error occurs.\n *\n * Each entry is passed individually to `processEntry`. Errors thrown by `processEntry` are caught\n * and logged via `diag` (if provided) so that one bad entry does not block the rest.\n *\n * Note: The observer is created with the \"buffered\" option set to true, so it will receive entries\n * that were recorded before the observer was created.\n * buffered: true is not supported when observing multiple entry types, so if you need to observe\n * multiple types, you should create separate observers for each type with buffered: true.\n * See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/observe#entrytypes\n */\nexport function createPerformanceObserver<T extends PerformanceEntry>(\n  type: string,\n  processEntry: (entry: T) => void,\n  options?: PerformanceObserverInit & { diag?: DiagLogger },\n): PerformanceObserver | null {\n  const { diag, ...observeOptions } = options ?? {};\n\n  if (!isEntryTypeSupported(type)) {\n    diag?.debug(`${type} not supported, skipping observer`);\n    return null;\n  }\n\n  try {\n    const observer = new PerformanceObserver((list) => {\n      for (const entry of list.getEntries() as T[]) {\n        try {\n          processEntry(entry);\n        } catch (e) {\n          diag?.error(`error processing ${type} entry`, e);\n        }\n      }\n    });\n    observer.observe({ type, buffered: true, ...observeOptions });\n    return observer;\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";AAEA,SAAgB,qBAAqB,MAAuB;AAC1D,QACE,OAAO,wBAAwB,gBAC9B,oBAAoB,qBAAqB,SAAS,KAAK,IAAI;;;;;;;;;;;;;;;AAiBhE,SAAgB,0BACd,MACA,cACA,SAC4B;CAC5B,MAAM,EAAE,MAAM,GAAG,mBAAmB,WAAW,EAAE;AAEjD,KAAI,CAAC,qBAAqB,KAAK,EAAE;AAC/B,QAAM,MAAM,GAAG,KAAK,mCAAmC;AACvD,SAAO;;AAGT,KAAI;EACF,MAAM,WAAW,IAAI,qBAAqB,SAAS;AACjD,QAAK,MAAM,SAAS,KAAK,YAAY,CACnC,KAAI;AACF,iBAAa,MAAM;YACZ,GAAG;AACV,UAAM,MAAM,oBAAoB,KAAK,SAAS,EAAE;;IAGpD;AACF,WAAS,QAAQ;GAAE;GAAM,UAAU;GAAM,GAAG;GAAgB,CAAC;AAC7D,SAAO;SACD;AACN,SAAO"}

package/dist/utils/throttle.cjs

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/throttle.ts
 /** throttle wraps a function so it can only be called once, and then a time window must pass before it can be called again
 * any subsequent calls before the time window has passed will be ignored.
@@ -18,7 +17,7 @@ const throttle = (func, timeout = 1e3) => {
 		isWaiting = true;
 	};
 };
-
 //#endregion
 exports.throttle = throttle;
+
 //# sourceMappingURL=throttle.cjs.map

package/dist/utils/throttle.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"throttle.cjs","names":[],"sources":["../../src/utils/throttle.ts"],"sourcesContent":["/** throttle wraps a function so it can only be called once, and then a time window must pass before it can be called again\n * any subsequent calls before the time window has passed will be ignored.\n *\n * NOTE: if the wrapped function makes use of \"this\", it must be properly bind from the caller, as this wrapper will not bind it.\n * For this, we suggest you always pass functions declared as fat arrow functions, as they have their \"this\" lexically defined.\n * */\nexport const throttle = <F extends (...args: Parameters<F>) => ReturnType<F>>(\n  func: F,\n  timeout = 1000,\n) => {\n  let isWaiting = false;\n  return (...args: Parameters<F>) => {\n    if (isWaiting) {\n      return;\n    }\n    func(...args);\n    setTimeout(() => {\n      isWaiting = false;\n    }, timeout);\n    isWaiting = true;\n  };\n};\n"],"mappings":";;;;;;;;;AAMA,MAAa,YACX,MACA,UAAU,QACP;CACH,IAAI,YAAY;AAChB,SAAQ,GAAG,SAAwB;AACjC,MAAI,UACF;AAEF,OAAK,GAAG,KAAK;AACb,mBAAiB;AACf,eAAY;KACX,QAAQ;AACX,cAAY"}
+{"version":3,"file":"throttle.cjs","names":[],"sources":["../../src/utils/throttle.ts"],"sourcesContent":["/** throttle wraps a function so it can only be called once, and then a time window must pass before it can be called again\n * any subsequent calls before the time window has passed will be ignored.\n *\n * NOTE: if the wrapped function makes use of \"this\", it must be properly bind from the caller, as this wrapper will not bind it.\n * For this, we suggest you always pass functions declared as fat arrow functions, as they have their \"this\" lexically defined.\n * */\nexport const throttle = <F extends (...args: Parameters<F>) => ReturnType<F>>(\n  func: F,\n  timeout = 1000,\n) => {\n  let isWaiting = false;\n  return (...args: Parameters<F>) => {\n    if (isWaiting) {\n      return;\n    }\n    func(...args);\n    setTimeout(() => {\n      isWaiting = false;\n    }, timeout);\n    isWaiting = true;\n  };\n};\n"],"mappings":";;;;;;;;AAMA,MAAa,YACX,MACA,UAAU,QACP;CACH,IAAI,YAAY;AAChB,SAAQ,GAAG,SAAwB;AACjC,MAAI,UACF;AAEF,OAAK,GAAG,KAAK;AACb,mBAAiB;AACf,eAAY;KACX,QAAQ;AACX,cAAY"}

package/dist/utils/throttle.js

@@ -16,7 +16,7 @@ const throttle = (func, timeout = 1e3) => {
 		isWaiting = true;
 	};
 };
-
 //#endregion
 export { throttle };
+
 //# sourceMappingURL=throttle.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safaricom-mxl/web-sdk",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "MXL Web SDK",
   "type": "module",
   "imports": {
@@ -25,8 +25,8 @@
     "test:manual": "npm run test -- --manual",
     "test:coverage": "npm run test -- --config=web-test-runner.coverage.config.js",
     "test:multiBrowsers": "npm run test -- --config=web-test-runner.multi-browser.config.js",
-    "check": "tsc",
-    "check:dist": "eslint --max-warnings 0 --config eslint.dist.config.ts dist/",
+    "check": "tsc && eslint --max-warnings 0",
+    "check:dist": "eslint --max-warnings 0 --config eslint.dist.config.ts",
     "validate": "tsx scripts/validate.ts",
     "docs": "npx typedoc --readme none && touch docs/.nojekyll"
   },
@@ -79,17 +79,19 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/api-logs": "^0.214.0",
-    "@opentelemetry/core": "^2.6.1",
-    "@opentelemetry/instrumentation": "^0.214.0",
-    "@opentelemetry/instrumentation-fetch": "^0.214.0",
-    "@opentelemetry/instrumentation-xml-http-request": "^0.214.0",
-    "@opentelemetry/otlp-exporter-base": "^0.214.0",
-    "@opentelemetry/resources": "^2.6.1",
-    "@opentelemetry/sdk-logs": "^0.214.0",
-    "@opentelemetry/sdk-trace-web": "^2.6.1",
+    "@opentelemetry/api-logs": "^0.217.0",
+    "@opentelemetry/core": "^2.7.1",
+    "@opentelemetry/instrumentation": "^0.217.0",
+    "@opentelemetry/instrumentation-fetch": "^0.217.0",
+    "@opentelemetry/instrumentation-xml-http-request": "^0.217.0",
+    "@opentelemetry/otlp-exporter-base": "^0.217.0",
+    "@opentelemetry/otlp-transformer": "^0.217.0",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.217.0",
+    "@opentelemetry/sdk-trace-web": "^2.7.1",
     "@opentelemetry/semantic-conventions": "^1.40.0",
-    "@opentelemetry/web-common": "^0.214.0",
+    "@opentelemetry/web-common": "^0.217.0",
+    "@safaricom-mxl/session-recorder": "0.0.12",
     "hoist-non-react-statics": "^3.3.2",
     "web-vitals": "^5.2.0"
   },