@pie-players/pie-players-shared 0.3.73 → 0.3.75

package/dist/pie/player-initializer.js

@@ -1,122 +0,0 @@
-/**
- * Shared PIE player initialization logic
- * Used by preloaded static player runtimes
- */
-/**
- * Initialize PIE player with item data
- * Shared initialization for preloaded/static player entrypoints.
- */
-export async function initializePiePlayer(itemData, config, elements) {
-    const { playerEl } = elements;
-    if (!itemData.item?.config || !playerEl) {
-        throw new Error("Missing item config or player element");
-    }
-    // Ensure pie-player is loaded
-    await ensurePiePlayerLoaded();
-    const defaultEnv = config.env || { mode: "evaluate", role: "instructor" };
-    // Configure player element
-    playerEl.config = itemData.item.config;
-    playerEl.env = defaultEnv;
-    const shouldShowCorrect = !!(config.addCorrectResponse ||
-        (defaultEnv.mode === "evaluate" && defaultEnv.role === "instructor"));
-    playerEl.addCorrectResponse = shouldShowCorrect;
-    // Forward additional properties
-    playerEl.session = {
-        id: "",
-        data: Array.isArray(config.session) ? config.session : [],
-    };
-    if (config.externalStyleUrls) {
-        playerEl.externalStyleUrls = config.externalStyleUrls;
-    }
-    if (config.customClassName) {
-        playerEl.customClassName = config.customClassName;
-    }
-    if (config.containerClass) {
-        playerEl.containerClass = config.containerClass;
-    }
-    if (config.passageContainerClass) {
-        playerEl.passageContainerClass = config.passageContainerClass;
-    }
-}
-/**
- * Extract passage markup from item data
- */
-export function extractPassageMarkup(itemData) {
-    return itemData.passage?.config?.markup || null;
-}
-/**
- * Ensure pie-player web component is loaded
- */
-export async function ensurePiePlayerLoaded() {
-    if (customElements.get("pie-player"))
-        return;
-    const url = "https://cdn.jsdelivr.net/npm/@pie-players/pie-player-components@latest/dist/pie-player-components/pie-player-components.esm.js";
-    await new Promise((resolve, reject) => {
-        const existing = document.querySelector("script[data-pie-player]");
-        if (existing) {
-            existing.addEventListener("load", () => resolve());
-            existing.addEventListener("error", () => reject(new Error("failed to load pie-player")));
-            return;
-        }
-        const s = document.createElement("script");
-        s.type = "module";
-        s.dataset.piePlayer = "true";
-        s.src = url;
-        s.addEventListener("load", () => resolve());
-        s.addEventListener("error", () => reject(new Error("failed to load pie-player")));
-        document.head.appendChild(s);
-    });
-    await customElements.whenDefined("pie-player");
-}
-/**
- * Build event listeners map for PIE elements
- */
-export function buildEventListenersMap(config, onSessionChanged) {
-    if (!config?.elements)
-        return undefined;
-    const listeners = {};
-    Object.keys(config.elements).forEach((elName) => {
-        listeners[elName] = {
-            "session-changed": (e) => onSessionChanged(e.detail),
-        };
-    });
-    return listeners;
-}
-/**
- * Build URL parameters for API request
- * Shared by preloaded/static player entrypoints.
- */
-export function buildApiParams(env, addCorrectResponse) {
-    const params = new URLSearchParams();
-    if (env && typeof env === "object") {
-        if (env.mode)
-            params.set("mode", String(env.mode));
-        if (env.role)
-            params.set("role", String(env.role));
-    }
-    if (addCorrectResponse)
-        params.set("addCorrectResponse", "true");
-    return params;
-}
-/**
- * Fetch item data from API
- * Shared by preloaded/static player entrypoints.
- */
-export async function fetchItemData(apiBaseUrl, itemId, token, endpoint, env, addCorrectResponse, signal) {
-    if (typeof window === "undefined" || typeof document === "undefined") {
-        throw new Error("PIE initialization must run in browser");
-    }
-    const params = buildApiParams(env, addCorrectResponse);
-    const apiUrl = `${apiBaseUrl}/api/item/${itemId}/${endpoint}${params.toString() ? `?${params.toString()}` : ""}`;
-    const response = await fetch(apiUrl, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: "application/json",
-        },
-        signal,
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch item data: ${response.statusText}`);
-    }
-    return await response.json();
-}

package/dist/pie/stage-tracker.d.ts

@@ -1,50 +0,0 @@
-import { type Stage, type StageChangeDetail, type StageSourceCe, type StageStatus } from "./stages.js";
-/**
- * Stage tracker primitive (M6).
- *
- * One tracker per CE instance per cohort. `enter(stage, status?)` is the
- * only mutation; `reset()` rolls the cohort over (e.g. when
- * `(sectionId, attemptId)` changes).
- *
- * The tracker enforces the locked invariants from
- * `m6_ready_vocab_canonical_followup.plan.md` §3.1–§3.6:
- * - Monotonic ordering across `STAGES`. Backward transitions inside one
- *   cohort are rejected (dev) / warned-once (prod) so subscribers never
- *   see a stage regress without an intervening `reset()`.
- * - Per-CE applicability. The post-retro canonical list applies to
- *   every CE shape; the `applicableStages` indirection is kept so a
- *   future shape-specific stage can opt out without rewriting callers.
- *   Non-applicable stages auto-emit `status: "skipped"` when an
- *   applicable later stage is entered, so iteration order stays stable
- *   across CE shapes.
- * - One source for every emit. The injected `emit(detail)` function
- *   drives DOM events, engine subscribers, and coordinator subscribers
- *   from the same call site so no surface drifts.
- *
- * Failure semantics intentionally piggyback on the M3 framework-error
- * contract: `enter(stage, "failed")` records the position; the
- * framework error records the cause.
- */
-export type CreateStageTrackerOptions = {
-    sourceCe: string;
-    sourceCeShape: StageSourceCe;
-    runtimeId: string;
-    sectionId?: string;
-    attemptId?: string;
-    emit: (detail: StageChangeDetail) => void;
-    now?: () => string;
-    onUnexpectedTransition?: (info: {
-        from: Stage | null;
-        to: Stage;
-        reason: "backward" | "duplicate";
-    }) => void;
-};
-export type StageTracker = {
-    enter: (stage: Stage, status?: StageStatus) => void;
-    reset: (next?: {
-        sectionId?: string;
-        attemptId?: string;
-    }) => void;
-    getCurrent: () => Stage | null;
-};
-export declare function createStageTracker(opts: CreateStageTrackerOptions): StageTracker;

package/dist/pie/stage-tracker.js

@@ -1,105 +0,0 @@
-import { STAGES, applicableStages, stageOrdinal, } from "./stages.js";
-let unexpectedTransitionWarned = false;
-function defaultUnexpectedTransitionLogger(info) {
-    if (unexpectedTransitionWarned)
-        return;
-    unexpectedTransitionWarned = true;
-    if (typeof console !== "undefined" && console.warn) {
-        console.warn(`[pie-stage-tracker] Unexpected ${info.reason} stage transition ` +
-            `from \`${info.from ?? "<none>"}\` to \`${info.to}\`. ` +
-            `Stage transitions are expected to be monotonic within a cohort; ` +
-            `call \`reset()\` when \`(sectionId, attemptId)\` changes.`);
-    }
-}
-export function createStageTracker(opts) {
-    const applicable = applicableStages(opts.sourceCeShape);
-    const applicableSet = new Set(applicable);
-    const now = opts.now ?? (() => new Date().toISOString());
-    const onUnexpected = opts.onUnexpectedTransition ?? defaultUnexpectedTransitionLogger;
-    let current = null;
-    let sectionId = opts.sectionId;
-    let attemptId = opts.attemptId;
-    const emitted = new Set();
-    function emitDetail(stage, status) {
-        opts.emit({
-            stage,
-            status,
-            runtimeId: opts.runtimeId,
-            sectionId,
-            attemptId,
-            timestamp: now(),
-            sourceCe: opts.sourceCe,
-        });
-    }
-    function fillSkippedBefore(stage) {
-        const targetIdx = stageOrdinal(stage);
-        const startIdx = current === null ? 0 : stageOrdinal(current) + 1;
-        for (let idx = startIdx; idx < targetIdx; idx += 1) {
-            const skipCandidate = STAGES[idx];
-            if (applicableSet.has(skipCandidate))
-                continue;
-            if (emitted.has(skipCandidate))
-                continue;
-            emitted.add(skipCandidate);
-            emitDetail(skipCandidate, "skipped");
-        }
-    }
-    function enter(stage, status = "entered") {
-        const nextOrdinal = stageOrdinal(stage);
-        const currentOrdinal = current === null ? -1 : stageOrdinal(current);
-        if (status === "entered") {
-            if (emitted.has(stage)) {
-                onUnexpected({ from: current, to: stage, reason: "duplicate" });
-                return;
-            }
-            if (nextOrdinal < currentOrdinal) {
-                onUnexpected({ from: current, to: stage, reason: "backward" });
-                return;
-            }
-            if (!applicableSet.has(stage)) {
-                // A non-applicable stage entered with `entered` is a programming
-                // error: the tracker auto-skips it when a later stage enters.
-                // Treat it as a `skipped` emission and continue.
-                if (emitted.has(stage))
-                    return;
-                emitted.add(stage);
-                emitDetail(stage, "skipped");
-                return;
-            }
-            fillSkippedBefore(stage);
-            emitted.add(stage);
-            current = stage;
-            emitDetail(stage, "entered");
-            return;
-        }
-        // `status === "failed"` records position; do not gate on monotonic
-        // ordering — failure can happen during any transition. Mark the stage
-        // as emitted so a subsequent `entered` for the same stage warns as a
-        // duplicate; downstream recovery should call `reset()` first.
-        if (status === "failed") {
-            fillSkippedBefore(stage);
-            emitted.add(stage);
-            current = stage;
-            emitDetail(stage, "failed");
-            return;
-        }
-        // `status === "skipped"` is reserved for the auto-fill path; explicit
-        // callers shouldn't pass it. Accept it idempotently for robustness.
-        if (emitted.has(stage))
-            return;
-        emitted.add(stage);
-        emitDetail(stage, "skipped");
-    }
-    function reset(next) {
-        current = null;
-        emitted.clear();
-        if (next) {
-            sectionId = next.sectionId;
-            attemptId = next.attemptId;
-        }
-    }
-    function getCurrent() {
-        return current;
-    }
-    return { enter, reset, getCurrent };
-}

package/dist/security/wrap-model-rich-content.d.ts

@@ -1 +0,0 @@
-export declare function wrapModelRichContent<T>(model: T): T;

package/dist/security/wrap-model-rich-content.js

@@ -1,40 +0,0 @@
-import { wrapOverwideImages } from "./wrap-overwide-images.js";
-import { wrapOverwideTables } from "./wrap-overwide-tables.js";
-const RICH_CONTENT_TAG_REGEX = /<(?:img|table)\b/i;
-const SKIPPED_KEYS = new Set(["accessibilityCatalogs"]);
-function maybeWrapRichContent(value) {
-    if (!RICH_CONTENT_TAG_REGEX.test(value))
-        return value;
-    return wrapOverwideTables(wrapOverwideImages(value));
-}
-function wrapValue(value, parentKey) {
-    if (parentKey && SKIPPED_KEYS.has(parentKey))
-        return value;
-    if (typeof value === "string")
-        return maybeWrapRichContent(value);
-    if (!value || typeof value !== "object")
-        return value;
-    if (Array.isArray(value)) {
-        let changed = false;
-        const next = value.map((entry) => {
-            const wrapped = wrapValue(entry);
-            if (wrapped !== entry)
-                changed = true;
-            return wrapped;
-        });
-        return changed ? next : value;
-    }
-    const record = value;
-    let changed = false;
-    const next = {};
-    for (const [key, entry] of Object.entries(record)) {
-        const wrapped = wrapValue(entry, key);
-        if (wrapped !== entry)
-            changed = true;
-        next[key] = wrapped;
-    }
-    return changed ? next : value;
-}
-export function wrapModelRichContent(model) {
-    return wrapValue(model);
-}

package/dist/server/npm-auth-env.d.ts

@@ -1,13 +0,0 @@
-/**
- * Write a temp `.npmrc` carrying a scoped `_authToken` and return an env
- * object pointing `NPM_CONFIG_USERCONFIG` at it, so a publish subprocess
- * authenticates without a separate `npm login`. The token comes from
- * `NPM_TOKEN`/`NODE_AUTH_TOKEN` in `baseEnv` first, falling back to parsing
- * an `.env`-style file at `envPath` for either key.
- *
- * Call `cleanup()` once the subprocess using `env` has exited.
- */
-export declare const createNpmAuthEnvironment: (envPath?: string, baseEnv?: NodeJS.ProcessEnv) => {
-    env: NodeJS.ProcessEnv;
-    cleanup: () => void;
-};

package/dist/server/npm-auth-env.js

@@ -1,64 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-if (typeof window !== "undefined") {
-    throw new Error("[npm-auth-env] @pie-players/pie-players-shared/server/npm-auth-env is server-only and cannot be imported in browser code");
-}
-const REGISTRY = "https://registry.npmjs.org/";
-const parseDotEnvToken = (envPath, key) => {
-    try {
-        const content = readFileSync(envPath, "utf8");
-        const pattern = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=\\s*(.*)\\s*$`, "m");
-        const match = content.match(pattern);
-        if (!match?.[1])
-            return "";
-        const rawValue = match[1].trim();
-        const isWrappedInQuotes = (rawValue.startsWith('"') && rawValue.endsWith('"')) ||
-            (rawValue.startsWith("'") && rawValue.endsWith("'"));
-        return (isWrappedInQuotes ? rawValue.slice(1, -1) : rawValue).trim();
-    }
-    catch {
-        return "";
-    }
-};
-const resolveToken = (envPath, baseEnv) => {
-    const envToken = String(baseEnv.NPM_TOKEN || baseEnv.NODE_AUTH_TOKEN || "").trim();
-    if (envToken)
-        return envToken;
-    if (!envPath)
-        return "";
-    return (parseDotEnvToken(envPath, "NPM_TOKEN") ||
-        parseDotEnvToken(envPath, "NODE_AUTH_TOKEN"));
-};
-/**
- * Write a temp `.npmrc` carrying a scoped `_authToken` and return an env
- * object pointing `NPM_CONFIG_USERCONFIG` at it, so a publish subprocess
- * authenticates without a separate `npm login`. The token comes from
- * `NPM_TOKEN`/`NODE_AUTH_TOKEN` in `baseEnv` first, falling back to parsing
- * an `.env`-style file at `envPath` for either key.
- *
- * Call `cleanup()` once the subprocess using `env` has exited.
- */
-export const createNpmAuthEnvironment = (envPath, baseEnv = process.env) => {
-    const token = resolveToken(envPath, baseEnv);
-    if (!token) {
-        return {
-            env: baseEnv,
-            cleanup: () => { },
-        };
-    }
-    const tempDir = mkdtempSync(join(tmpdir(), "pie-npm-auth-"));
-    const npmrcPath = join(tempDir, ".npmrc");
-    writeFileSync(npmrcPath, `registry=${REGISTRY}\n//registry.npmjs.org/:_authToken=${token}\n`, "utf8");
-    return {
-        env: {
-            ...baseEnv,
-            NPM_CONFIG_USERCONFIG: npmrcPath,
-            NODE_AUTH_TOKEN: String(baseEnv.NODE_AUTH_TOKEN || "").trim() || token,
-            NPM_TOKEN: String(baseEnv.NPM_TOKEN || "").trim() || token,
-        },
-        cleanup: () => {
-            rmSync(tempDir, { recursive: true, force: true });
-        },
-    };
-};

package/dist/server/npm-registry.d.ts

@@ -1,7 +0,0 @@
-type NpmFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-/**
- * Server-only helper for npm package version lookups.
- * Do not import this module from browser-executed code.
- */
-export declare const getNpmPackageVersions: (element: string, fetch: NpmFetch, filter?: (v: string) => boolean, limit?: number, searchTerm?: string) => Promise<string[]>;
-export {};

package/dist/server/npm-registry.js

@@ -1,59 +0,0 @@
-import semver from "semver";
-const NPM_REGISTRY_URL = "https://registry.npmjs.org";
-if (typeof window !== "undefined") {
-    throw new Error("[npm-registry] @pie-players/pie-players-shared/server/npm-registry is server-only and cannot be imported in browser code");
-}
-const DEFAULT_FILTER = (v) => v.indexOf("print") === -1 &&
-    v.indexOf("ps") === -1 &&
-    v.indexOf("strikethrough") === -1 &&
-    v.indexOf("alpha") === -1 &&
-    v.indexOf("bm") === -1;
-/**
- * Server-only helper for npm package version lookups.
- * Do not import this module from browser-executed code.
- */
-export const getNpmPackageVersions = async (element, fetch, filter = DEFAULT_FILTER, limit, searchTerm = "") => {
-    if (typeof window !== "undefined") {
-        throw new Error("[npm-registry] server-only module imported in browser context");
-    }
-    try {
-        const response = await fetch(`${NPM_REGISTRY_URL}/${element}`);
-        if (!response.ok) {
-            console.warn(`[npm-registry] npm status ${response.status} for package ${element}`);
-            return searchTerm ? [] : ["latest"];
-        }
-        const json = await response.json();
-        const versions = json?.versions;
-        if (!versions || typeof versions !== "object") {
-            console.warn(`[npm-registry] response for ${element} missing 'versions' property`);
-            return searchTerm ? [] : ["latest"];
-        }
-        let sorted = Object.keys(versions)
-            .filter(filter)
-            .filter((v) => !versions[v]?.deprecated)
-            .filter((v) => !/^11\.0\.\d+-esm\.\d+/.test(v))
-            .filter((v) => !searchTerm || v.toLowerCase().includes(searchTerm.toLowerCase()))
-            .sort((a, b) => {
-            const verA = semver.valid(semver.clean(a));
-            const verB = semver.valid(semver.clean(b));
-            if (!verA && !verB)
-                return 0;
-            if (!verA)
-                return 1;
-            if (!verB)
-                return -1;
-            return semver.rcompare(verA, verB);
-        });
-        if (typeof limit === "number" && limit > 0) {
-            sorted = sorted.slice(0, limit);
-        }
-        if (!searchTerm) {
-            sorted.unshift("latest");
-        }
-        return sorted;
-    }
-    catch (error) {
-        console.warn(`[npm-registry] failed package lookup for ${element}:`, error);
-        return searchTerm ? [] : ["latest"];
-    }
-};

package/dist/ui/debug-panel-persistence.d.ts

@@ -1,17 +0,0 @@
-type DebugPanelStorageKeyArgs = {
-    scope: string;
-    panelId: string;
-    aspect?: string;
-};
-export declare function createDebugPanelStorageKey(args: DebugPanelStorageKeyArgs): string;
-export declare function readDebugPanelState<T>(key: string): T | null;
-export declare function writeDebugPanelState<T>(key: string, value: T): void;
-export declare function clearDebugPanelState(key: string): void;
-export type DebugPanelLayoutStateV1 = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    minimized: boolean;
-};
-export {};

package/dist/ui/debug-panel-persistence.js

@@ -1,37 +0,0 @@
-import { safeLocalStorageGet, safeLocalStorageSet } from "./safe-storage.js";
-const DEBUG_PANEL_STORAGE_PREFIX = "pie:debug-panels:v1";
-export function createDebugPanelStorageKey(args) {
-    const scope = String(args.scope || "default").trim() || "default";
-    const panelId = String(args.panelId || "panel").trim() || "panel";
-    const aspect = String(args.aspect || "state").trim() || "state";
-    return `${DEBUG_PANEL_STORAGE_PREFIX}:${scope}:${panelId}:${aspect}`;
-}
-export function readDebugPanelState(key) {
-    const raw = safeLocalStorageGet(key);
-    if (!raw)
-        return null;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function writeDebugPanelState(key, value) {
-    try {
-        safeLocalStorageSet(key, JSON.stringify(value));
-    }
-    catch {
-        // ignore serialization/storage failures
-    }
-}
-export function clearDebugPanelState(key) {
-    try {
-        if (typeof localStorage === "undefined")
-            return;
-        localStorage.removeItem(key);
-    }
-    catch {
-        // ignore
-    }
-}