@pie-lib/delivery-events-svelte 0.1.1-next.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @pie-lib/delivery-events-svelte
+ *
+ * Shared host/session bridge utilities for Svelte delivery custom elements.
+ */
+export * from './session-bridge.js';
+export { ModelSetEvent, SessionChangedEvent } from '@pie-element/shared-player-events';

package/dist/index.js

@@ -0,0 +1,3 @@
+import { ModelSetEvent as e, SessionChangedEvent as t } from "./index2.js";
+import { forwardSessionChange as n, resolveDeliveryHost as r, writeSessionInPlace as i } from "./index3.js";
+export { e as ModelSetEvent, t as SessionChangedEvent, n as forwardSessionChange, r as resolveDeliveryHost, i as writeSessionInPlace };

package/dist/index2.js

@@ -0,0 +1,33 @@
+//#region ../../shared/player-events/dist/index.js
+var e = class e extends CustomEvent {
+	static {
+		this.TYPE = "model-set";
+	}
+	constructor(t, n, r) {
+		super(e.TYPE, {
+			bubbles: !0,
+			composed: !0,
+			detail: {
+				complete: n,
+				component: t,
+				hasModel: r
+			}
+		}), this.component = t, this.complete = n;
+	}
+}, t = class e extends CustomEvent {
+	static {
+		this.TYPE = "session-changed";
+	}
+	constructor(t, n) {
+		super(e.TYPE, {
+			bubbles: !0,
+			composed: !0,
+			detail: {
+				complete: n,
+				component: t
+			}
+		}), this.component = t, this.complete = n;
+	}
+};
+//#endregion
+export { e as ModelSetEvent, t as SessionChangedEvent };

package/dist/index3.js

@@ -0,0 +1,38 @@
+import { SessionChangedEvent as e } from "./index2.js";
+//#region src/session-bridge.ts
+var t = (e) => {
+	let t = e;
+	return t ? typeof t.onSessionChange == "function" || typeof t.onAudioStarted == "function" || typeof t.onAudioEnded == "function" : !1;
+};
+function n(e, n = {}) {
+	let r = n.hostPredicate ?? t, i = e;
+	for (; i;) {
+		if (r(i)) return i;
+		i = i.parentElement;
+	}
+	if (typeof document < "u" && n.fallbackSelector) {
+		let e = document.querySelector(n.fallbackSelector);
+		if (r(e)) return e;
+	}
+	return null;
+}
+function r(e) {
+	return !!e && typeof e == "object" && !Array.isArray(e);
+}
+function i(e, t) {
+	if (e === t) return e;
+	if (!r(e) || !r(t) || Object.isFrozen(e) || !Object.isExtensible(e)) return t;
+	try {
+		for (let n of Object.keys(e)) n in t || delete e[n];
+		Object.assign(e, t);
+	} catch {
+		return t;
+	}
+	return e;
+}
+function a({ sourceEl: t, fallbackSelector: r, component: i, complete: a, session: o }) {
+	let s = n(t, { fallbackSelector: r });
+	return s ? typeof s.onSessionChange == "function" ? (s.onSessionChange(o), s) : (s.dispatchEvent(new e(i, a)), s) : null;
+}
+//#endregion
+export { a as forwardSessionChange, n as resolveDeliveryHost, i as writeSessionInPlace };

package/dist/session-bridge.d.ts

@@ -0,0 +1,52 @@
+export type DeliveryHostElement = HTMLElement & {
+    session?: unknown;
+    onSessionChange?: (session: unknown) => void;
+    onAudioStarted?: () => void;
+    onAudioEnded?: () => void;
+};
+type HostPredicate = (node: unknown) => boolean;
+export interface ResolveDeliveryHostOptions {
+    fallbackSelector?: string;
+    hostPredicate?: HostPredicate;
+}
+/**
+ * Walk up the DOM from a source element and find the nearest delivery host wrapper.
+ * Falls back to selector lookup to support detached nested render roots.
+ */
+export declare function resolveDeliveryHost(sourceEl?: HTMLElement | null, options?: ResolveDeliveryHostOptions): DeliveryHostElement | null;
+/**
+ * Assign a delivery update into the session object the player owns, keeping the
+ * reference.
+ *
+ * A player hands the element a session object and reads the learner's response
+ * back off that same object: `pie-player` pushes its entry into the host's own
+ * `session.data` array, and `pie-item-player`'s renderer forwards the array it
+ * holds rather than `element.session`. An element that only replaces its own
+ * reference leaves the player's entry at its load-time value, so the forwarded
+ * container compares equal to the previous one and normalizes to
+ * `intent: "metadata-only"` with `session: null` - the element reports a change
+ * and the response never arrives. The React elements mutate the session they
+ * were given (`updateSessionValue`); this is that contract for the Svelte
+ * elements, which additionally hand their component a fresh reference so
+ * `$derived` reads of `props.session` still re-run.
+ *
+ * Keys absent from `next` are removed, so clearing a response clears it on the
+ * player's object too. Anything that is not a plain object on both sides is
+ * returned as the replacement it already was, and so is a frozen or sealed
+ * target: writing into one throws in strict mode, which would take the
+ * learner's update with it before the element ever stored it.
+ */
+export declare function writeSessionInPlace(target: unknown, next: unknown): unknown;
+export interface ForwardSessionChangeOptions {
+    sourceEl?: HTMLElement | null;
+    fallbackSelector?: string;
+    component: string;
+    complete: boolean;
+    session: unknown;
+}
+/**
+ * Forward a delivery session update using the host callback when available.
+ * If no callback is exposed, dispatch the canonical session-changed metadata event.
+ */
+export declare function forwardSessionChange({ sourceEl, fallbackSelector, component, complete, session, }: ForwardSessionChangeOptions): DeliveryHostElement | null;
+export {};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pie-lib/delivery-events-svelte",
+  "version": "0.1.1-next.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pie-framework/pie-elements-ng.git",
+    "directory": "packages/lib-svelte/delivery-events"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build && tsc --emitDeclarationOnly",
+    "dev": "vite build --watch"
+  },
+  "dependencies": {
+    "@pie-element/shared-player-events": "0.1.1-next.0"
+  }
+}