@lessonkit/lxpack 1.4.0 → 1.5.0

package/dist/bridge.js

@@ -1,6 +1,9 @@
 import {
+  BRANCH_TELEMETRY_EVENTS,
+  answeredTelemetryToBridgeTrackEvent,
+  branchTelemetryToBridgeTrackEvent,
   telemetryEventToLessonkit
-} from "./chunk-DYQI222N.js";
+} from "./chunk-HTZR4CF3.js";
 
 // src/bridge.ts
 import {
@@ -11,7 +14,6 @@ import {
 import {
   createLxpackBridgeHost,
   DEFAULT_BRIDGE_PASSING_SCORE,
-  getLxpackBridge,
   LXPACK_BRIDGE_VERSIONS,
   normalizePassingThreshold as normalizePassingThreshold2,
   normalizeScore as normalizeScore2,
@@ -35,7 +37,41 @@ function normalizeAssessmentPassingScore(opts) {
     maxScore: opts?.maxScore
   });
 }
-function getBridge(parentWindow) {
+function resolveParentOrigin(parentWindow) {
+  if (typeof window === "undefined") return null;
+  const parent = parentWindow ?? window.parent;
+  if (!parent || parent === window) return null;
+  try {
+    return parent.location.origin;
+  } catch {
+    const referrer = typeof document !== "undefined" ? document.referrer : "";
+    if (!referrer) return null;
+    try {
+      return new URL(referrer).origin;
+    } catch {
+      return null;
+    }
+  }
+}
+function isProductionRuntime() {
+  try {
+    if (import.meta.env?.PROD === true) return true;
+  } catch {
+  }
+  const g = globalThis;
+  return typeof g.process !== "undefined" && g.process.env?.NODE_ENV === "production";
+}
+function isParentOriginAllowed(allowedParentOrigins, parentWindow, mode) {
+  if (mode === "off") return false;
+  if (isProductionRuntime() && !allowedParentOrigins?.length) return false;
+  if (!allowedParentOrigins?.length) return true;
+  const origin = resolveParentOrigin(parentWindow);
+  if (!origin) return false;
+  return allowedParentOrigins.includes(origin);
+}
+function getBridge(parentWindow, opts) {
+  const mode = opts?.mode ?? "auto";
+  if (!isParentOriginAllowed(opts?.allowedParentOrigins, parentWindow, mode)) return null;
   const fromSdk = getLxpackBridgeFromParent(parentWindow);
   if (fromSdk) return fromSdk;
   if (typeof window === "undefined") return null;
@@ -43,21 +79,33 @@ function getBridge(parentWindow) {
   if (!parent || parent === window) return null;
   return parent.lxpackBridge?.v1 ?? parent.lxpack ?? null;
 }
+function getLxpackBridge(parentWindow, opts) {
+  return getBridge(parentWindow, opts);
+}
 function isDevEnvironment() {
+  try {
+    if (import.meta.env?.DEV === true) return true;
+    if (import.meta.env?.PROD === true) return false;
+  } catch {
+  }
   const g = globalThis;
   return typeof g.process !== "undefined" && g.process.env?.NODE_ENV !== "production";
 }
-function dispatchBridgeAction(bridge, action) {
+function handleBridgeError(err, onBridgeError) {
+  onBridgeError?.(err);
+  if (isDevEnvironment()) {
+    console.warn(
+      "[lessonkit/lxpack] lxpack bridge action failed:",
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+function dispatchBridgeAction(bridge, action, opts) {
   if (!action) return;
   try {
     dispatchBridgeActionInner(bridge, action);
   } catch (err) {
-    if (isDevEnvironment()) {
-      console.warn(
-        "[lessonkit/lxpack] lxpack bridge action failed:",
-        err instanceof Error ? err.message : err
-      );
-    }
+    handleBridgeError(err, opts?.onBridgeError);
   }
 }
 function dispatchBridgeActionInner(bridge, action) {
@@ -110,49 +158,69 @@ function forwardAssessmentCompletedToBridge(bridge, event) {
     maxScore: data.maxScore
   });
 }
-function forwardTelemetryToBridge(event, mode = "auto", parentWindow) {
+function forwardTelemetryToBridge(event, mode = "auto", parentWindow, opts) {
   if (mode === "off") return;
-  const bridge = getBridge(parentWindow);
+  const bridge = getBridge(parentWindow, {
+    allowedParentOrigins: opts?.allowedParentOrigins,
+    mode
+  });
   if (!bridge) return;
-  if (event.name === "assessment_completed") {
-    forwardAssessmentCompletedToBridge(bridge, event);
-    return;
+  try {
+    if (event.name === "assessment_completed") {
+      forwardAssessmentCompletedToBridge(bridge, event);
+      return;
+    }
+    const answeredTrack = answeredTelemetryToBridgeTrackEvent(event);
+    if (answeredTrack) {
+      bridge.track?.(answeredTrack);
+      return;
+    }
+    const branchTrack = branchTelemetryToBridgeTrackEvent(event);
+    if (branchTrack) {
+      bridge.track?.(branchTrack);
+      return;
+    }
+    const lessonkitEvent = telemetryEventToLessonkit(event);
+    if (!lessonkitEvent) return;
+    const action = mapLessonkitTelemetryToBridgeAction2(lessonkitEvent);
+    dispatchBridgeActionInner(bridge, action);
+  } catch (err) {
+    handleBridgeError(err, opts?.onBridgeError);
   }
-  const lessonkitEvent = telemetryEventToLessonkit(event);
-  if (!lessonkitEvent) return;
-  const action = mapLessonkitTelemetryToBridgeAction2(lessonkitEvent);
-  dispatchBridgeAction(bridge, action);
 }
-function createLxpackBridge() {
-  return getBridge();
+function createLxpackBridge(opts) {
+  return getBridge(void 0, opts);
 }
-function notifyLxpackLessonComplete(lessonId) {
-  const bridge = getBridge();
+function notifyLxpackLessonComplete(lessonId, opts) {
+  const bridge = getBridge(void 0, opts);
   if (!bridge?.completeLesson) return false;
   bridge.completeLesson(lessonId);
   return true;
 }
-function notifyLxpackCourseComplete() {
-  const bridge = getBridge();
+function notifyLxpackCourseComplete(opts) {
+  const bridge = getBridge(void 0, opts);
   if (!bridge?.completeCourse) return false;
   bridge.completeCourse();
   return true;
 }
-function notifyLxpackAssessment(payload) {
-  const bridge = getBridge();
+function notifyLxpackAssessment(payload, opts) {
+  const bridge = getBridge(void 0, opts);
   if (!bridge?.submitAssessment) return false;
   bridge.submitAssessment(payload);
   return true;
 }
 export {
+  BRANCH_TELEMETRY_EVENTS,
   DEFAULT_BRIDGE_PASSING_SCORE,
   LESSONKIT_TELEMETRY_EVENTS,
   LXPACK_BRIDGE_VERSIONS,
+  branchTelemetryToBridgeTrackEvent,
   createLxpackBridge,
   createLxpackBridgeHost,
   dispatchBridgeAction,
   forwardTelemetryToBridge,
   getLxpackBridge,
+  isParentOriginAllowed,
   mapLessonkitTelemetryToBridgeAction,
   mapLessonkitTelemetryToLxpack,
   normalizeAssessmentPassingScore,
@@ -162,6 +230,7 @@ export {
   notifyLxpackAssessment,
   notifyLxpackCourseComplete,
   notifyLxpackLessonComplete,
+  resolveParentOrigin,
   supportedBridgeVersions,
   telemetryEventToLessonkit
 };

package/dist/chunk-HTZR4CF3.js

@@ -0,0 +1,94 @@
+// src/telemetry.ts
+import {
+  LESSONKIT_TELEMETRY_EVENTS,
+  mapLessonkitTelemetryToLxpack
+} from "@lxpack/tracking-schema";
+var BRANCH_TELEMETRY_EVENTS = ["branch_node_viewed", "branch_selected"];
+var ASSESSMENT_TELEMETRY_EVENTS = ["assessment_answered"];
+var SUPPORTED = /* @__PURE__ */ new Set([
+  ...LESSONKIT_TELEMETRY_EVENTS,
+  ...BRANCH_TELEMETRY_EVENTS,
+  ...ASSESSMENT_TELEMETRY_EVENTS
+]);
+function isQuizAnsweredData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string" && data.checkId.length > 0;
+}
+function isQuizCompletedData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string" && data.checkId.length > 0;
+}
+function isAssessmentAnsweredData(data) {
+  return typeof data === "object" && data !== null && typeof data.checkId === "string" && data.checkId.length > 0;
+}
+function isInteractionData(data) {
+  return typeof data === "object" && data !== null;
+}
+function isBranchNodeViewedData(data) {
+  return typeof data === "object" && data !== null && typeof data.blockId === "string" && typeof data.nodeId === "string";
+}
+function isBranchSelectedData(data) {
+  return typeof data === "object" && data !== null && typeof data.blockId === "string" && typeof data.fromNodeId === "string" && typeof data.toNodeId === "string";
+}
+function telemetryEventToLessonkit(event) {
+  if (!SUPPORTED.has(event.name)) {
+    return null;
+  }
+  const mapped = {
+    name: event.name,
+    lessonId: event.lessonId
+  };
+  if (event.name === "quiz_completed" || event.name === "quiz_answered" || event.name === "assessment_answered") {
+    const data = event.data;
+    if (!isQuizAnsweredData(data) && !isQuizCompletedData(data) && !isAssessmentAnsweredData(data)) {
+      return null;
+    }
+    mapped.assessmentId = data.checkId;
+    if ("score" in data) {
+      mapped.score = data.score;
+      mapped.maxScore = data.maxScore;
+      mapped.passingScore = data.passingScore;
+    }
+    mapped.data = data;
+  } else if (mapped.name === "interaction" && event.data && isInteractionData(event.data)) {
+    mapped.data = event.data;
+  } else if (event.name === "branch_node_viewed" && isBranchNodeViewedData(event.data)) {
+    mapped.data = event.data;
+  } else if (event.name === "branch_selected" && isBranchSelectedData(event.data)) {
+    mapped.data = event.data;
+  }
+  return mapped;
+}
+function answeredTelemetryToBridgeTrackEvent(event) {
+  if (event.name !== "quiz_answered" && event.name !== "assessment_answered") {
+    return null;
+  }
+  const lessonkitEvent = telemetryEventToLessonkit(event);
+  if (!lessonkitEvent?.assessmentId) return null;
+  return mapLessonkitTelemetryToLxpack({
+    ...lessonkitEvent,
+    name: "quiz_answered"
+  });
+}
+function branchTelemetryToBridgeTrackEvent(event) {
+  if (event.name === "branch_node_viewed" && isBranchNodeViewedData(event.data)) {
+    return {
+      type: "interaction",
+      id: "branch_node_viewed",
+      data: { ...event.data, lessonkitEvent: event.name }
+    };
+  }
+  if (event.name === "branch_selected" && isBranchSelectedData(event.data)) {
+    return {
+      type: "interaction",
+      id: "branch_selected",
+      data: { ...event.data, lessonkitEvent: event.name }
+    };
+  }
+  return null;
+}
+
+export {
+  BRANCH_TELEMETRY_EVENTS,
+  telemetryEventToLessonkit,
+  answeredTelemetryToBridgeTrackEvent,
+  branchTelemetryToBridgeTrackEvent
+};