@pie-players/pie-players-shared 0.2.0

package/dist/loader-config.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared loader configuration for PIE custom elements.
+ *
+ * Mirrors the `LoaderConfig` used by PIEOneer's custom element tags.
+ */
+import type { InstrumentationProvider } from "./instrumentation/types";
+export type LoaderConfig = {
+    /**
+     * Enable tracking page actions/events.
+     *
+     * When true, instrumentation events will be sent to the instrumentation provider.
+     */
+    trackPageActions?: boolean;
+    /**
+     * Instrumentation provider for tracking events and errors.
+     *
+     * Optional. If not provided, defaults to NewRelicInstrumentationProvider.
+     * The provider handles instrumentation gracefully - if New Relic (or the configured
+     * backend) is not available, it will simply not track events (no errors thrown).
+     *
+     * @example Using New Relic (default - no configuration needed)
+     * ```typescript
+     * // Just enable tracking - will use New Relic if window.newrelic is available
+     * const loaderConfig = {
+     *   trackPageActions: true
+     * };
+     * ```
+     *
+     * @example Using DataDog
+     * ```typescript
+     * import { DataDogInstrumentationProvider } from '@pie-players/pie-players-shared';
+     *
+     * const provider = new DataDogInstrumentationProvider();
+     * await provider.initialize({
+     *   providerSettings: {
+     *     applicationId: 'abc123',
+     *     clientToken: 'pub_xyz'
+     *   }
+     * });
+     *
+     * const loaderConfig = {
+     *   trackPageActions: true,
+     *   instrumentationProvider: provider
+     * };
+     * ```
+     *
+     * @example Using Console provider (for development/debugging)
+     * ```typescript
+     * import { ConsoleInstrumentationProvider } from '@pie-players/pie-players-shared';
+     *
+     * const provider = new ConsoleInstrumentationProvider({ useColors: true });
+     * await provider.initialize({ debug: true });
+     *
+     * const loaderConfig = {
+     *   trackPageActions: true,
+     *   instrumentationProvider: provider
+     * };
+     * ```
+     */
+    instrumentationProvider?: InstrumentationProvider;
+    /**
+     * Maximum number of retry attempts for failed resources (images/audio/video).
+     */
+    maxResourceRetries?: number;
+    /**
+     * Initial delay in ms before first resource retry attempt (exponential backoff).
+     */
+    resourceRetryDelay?: number;
+};
+export declare const DEFAULT_LOADER_CONFIG: {
+    readonly trackPageActions: false;
+    readonly instrumentationProvider: undefined;
+    readonly maxResourceRetries: 3;
+    readonly resourceRetryDelay: 500;
+};
+//# sourceMappingURL=loader-config.d.ts.map

package/dist/loader-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-config.d.ts","sourceRoot":"","sources":["../src/loader-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG;IAC1B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,uBAAuB,CAAC,EAAE,uBAAuB,CAAC;IAElD;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;CAKxB,CAAC"}

package/dist/loader-config.js

@@ -0,0 +1,12 @@
+/**
+ * Shared loader configuration for PIE custom elements.
+ *
+ * Mirrors the `LoaderConfig` used by PIEOneer's custom element tags.
+ */
+export const DEFAULT_LOADER_CONFIG = {
+    trackPageActions: false,
+    instrumentationProvider: undefined,
+    maxResourceRetries: 3,
+    resourceRetryDelay: 500,
+};
+//# sourceMappingURL=loader-config.js.map

package/dist/loader-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-config.js","sourceRoot":"","sources":["../src/loader-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAuEH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACpC,gBAAgB,EAAE,KAAK;IACvB,uBAAuB,EAAE,SAAS;IAClC,kBAAkB,EAAE,CAAC;IACrB,kBAAkB,EAAE,GAAG;CACd,CAAC"}

package/dist/loaders/ElementLoader.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Element Loader - Core types and utilities for loading PIE elements
+ *
+ * This module provides element aggregation and loading abstractions for PIE players.
+ * It enables loading multiple PIE elements in a single operation, eliminating duplicate
+ * bundle requests when multiple items use the same elements.
+ */
+import type { BundleType } from "../pie/types";
+import type { ItemEntity } from "../types";
+/**
+ * Map of element tag names to their package versions
+ * Example: { "pie-multiple-choice": "@pie-element/multiple-choice@11.0.1" }
+ */
+export type ElementMap = {
+    [tagName: string]: string;
+};
+/**
+ * Options for loading PIE elements
+ */
+export interface LoadOptions {
+    /** Bundle type to load (player or clientPlayer) */
+    bundleType?: BundleType;
+    /** Whether to load controllers (for client-side processing) */
+    needsControllers?: boolean;
+    /** View mode (ESM only) - delivery, author, or print */
+    view?: "delivery" | "author" | "print";
+}
+/**
+ * Common interface for element loaders (IIFE and ESM)
+ */
+export interface ElementLoaderInterface {
+    /**
+     * Load elements directly from an element map
+     * @param elements - Map of element tag names to package versions
+     * @param options - Loading options
+     */
+    loadElements(elements: ElementMap, options?: LoadOptions): Promise<void>;
+    /**
+     * Extract and load elements from items
+     * Automatically aggregates unique elements from all items
+     * @param items - Array of items to extract elements from
+     * @param options - Loading options
+     */
+    loadFromItems(items: ItemEntity[], options?: LoadOptions): Promise<void>;
+}
+/**
+ * Aggregate unique elements from multiple items
+ *
+ * Extracts elements from all item configs and deduplicates them.
+ * Throws an error if items require different versions of the same element.
+ *
+ * @param items - Array of items to aggregate elements from
+ * @returns Map of unique element tag names to package versions
+ * @throws Error if element version conflicts are detected
+ *
+ * @example
+ * ```typescript
+ * const items = [
+ *   { config: { elements: { "pie-mc": "@pie-element/mc@11.0.1" } } },
+ *   { config: { elements: { "pie-mc": "@pie-element/mc@11.0.1" } } },
+ *   { config: { elements: { "pie-hotspot": "@pie-element/hotspot@9.0.0" } } }
+ * ];
+ *
+ * const elements = aggregateElements(items);
+ * // Result: {
+ * //   "pie-mc": "@pie-element/mc@11.0.1",
+ * //   "pie-hotspot": "@pie-element/hotspot@9.0.0"
+ * // }
+ * ```
+ */
+export declare function aggregateElements(items: ItemEntity[]): ElementMap;
+//# sourceMappingURL=ElementLoader.d.ts.map

package/dist/loaders/ElementLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementLoader.d.ts","sourceRoot":"","sources":["../../src/loaders/ElementLoader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,mDAAmD;IACnD,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,wDAAwD;IACxD,IAAI,CAAC,EAAE,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzE;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,CAsBjE"}

package/dist/loaders/ElementLoader.js

@@ -0,0 +1,52 @@
+/**
+ * Element Loader - Core types and utilities for loading PIE elements
+ *
+ * This module provides element aggregation and loading abstractions for PIE players.
+ * It enables loading multiple PIE elements in a single operation, eliminating duplicate
+ * bundle requests when multiple items use the same elements.
+ */
+/**
+ * Aggregate unique elements from multiple items
+ *
+ * Extracts elements from all item configs and deduplicates them.
+ * Throws an error if items require different versions of the same element.
+ *
+ * @param items - Array of items to aggregate elements from
+ * @returns Map of unique element tag names to package versions
+ * @throws Error if element version conflicts are detected
+ *
+ * @example
+ * ```typescript
+ * const items = [
+ *   { config: { elements: { "pie-mc": "@pie-element/mc@11.0.1" } } },
+ *   { config: { elements: { "pie-mc": "@pie-element/mc@11.0.1" } } },
+ *   { config: { elements: { "pie-hotspot": "@pie-element/hotspot@9.0.0" } } }
+ * ];
+ *
+ * const elements = aggregateElements(items);
+ * // Result: {
+ * //   "pie-mc": "@pie-element/mc@11.0.1",
+ * //   "pie-hotspot": "@pie-element/hotspot@9.0.0"
+ * // }
+ * ```
+ */
+export function aggregateElements(items) {
+    const elementMap = {};
+    items.forEach((item) => {
+        const itemElements = item.config?.elements || {};
+        Object.entries(itemElements).forEach(([tag, pkg]) => {
+            if (!elementMap[tag]) {
+                // First time seeing this element
+                elementMap[tag] = pkg;
+            }
+            else if (elementMap[tag] !== pkg) {
+                // Version conflict detected
+                throw new Error(`Element version conflict: ${tag} requires both ${elementMap[tag]} and ${pkg}. ` +
+                    `All items in a section must use the same version of each element.`);
+            }
+            // else: Same version, no-op
+        });
+    });
+    return elementMap;
+}
+//# sourceMappingURL=ElementLoader.js.map

package/dist/loaders/ElementLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementLoader.js","sourceRoot":"","sources":["../../src/loaders/ElementLoader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA6CH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAmB;IACpD,MAAM,UAAU,GAA2B,EAAE,CAAC;IAE9C,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACtB,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,QAAQ,IAAI,EAAE,CAAC;QAEjD,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;YACnD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACtB,iCAAiC;gBACjC,UAAU,CAAC,GAAG,CAAC,GAAG,GAAa,CAAC;YACjC,CAAC;iBAAM,IAAI,UAAU,CAAC,GAAG,CAAC,KAAK,GAAG,EAAE,CAAC;gBACpC,4BAA4B;gBAC5B,MAAM,IAAI,KAAK,CACd,6BAA6B,GAAG,kBAAkB,UAAU,CAAC,GAAG,CAAC,QAAQ,GAAG,IAAI;oBAC/E,mEAAmE,CACpE,CAAC;YACH,CAAC;YACD,4BAA4B;QAC7B,CAAC,CAAC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,UAAU,CAAC;AACnB,CAAC"}

package/dist/loaders/EsmElementLoader.d.ts

@@ -0,0 +1,67 @@
+/**
+ * ESM Element Loader
+ *
+ * Wraps EsmPieLoader to provide element-level loading abstraction.
+ * Aggregates elements from multiple items and loads them once using ESM modules.
+ */
+import type { ItemEntity } from "../types";
+import { type ElementLoaderInterface, type ElementMap, type LoadOptions } from "./ElementLoader";
+/**
+ * Configuration for ESM element loader
+ */
+export interface EsmElementLoaderConfig {
+    /** Base URL for ESM CDN (e.g., "https://esm.sh") */
+    esmCdnUrl: string;
+    /** Optional function to check if debug mode is enabled */
+    debugEnabled?: () => boolean;
+}
+/**
+ * Element loader for ESM (ES Modules) bundles
+ *
+ * This loader wraps EsmPieLoader and provides element aggregation capabilities.
+ * It eliminates duplicate bundle loads when multiple items use the same PIE elements.
+ * ESM is the modern, preferred loading mechanism with better browser support and features.
+ *
+ * @example
+ * ```typescript
+ * const loader = new EsmElementLoader({
+ *   esmCdnUrl: 'https://esm.sh'
+ * });
+ *
+ * // Load elements from multiple items at once
+ * await loader.loadFromItems(section.items, {
+ *   view: 'delivery',
+ *   needsControllers: true
+ * });
+ *
+ * // Or load specific elements directly
+ * await loader.loadElements({
+ *   'pie-multiple-choice': '@pie-element/multiple-choice@11.0.1',
+ *   'pie-hotspot': '@pie-element/hotspot@9.0.0'
+ * }, {
+ *   view: 'author' // Load author view for editing
+ * });
+ * ```
+ */
+export declare class EsmElementLoader implements ElementLoaderInterface {
+    private loader;
+    constructor(config: EsmElementLoaderConfig);
+    /**
+     * Load elements directly from an element map
+     *
+     * @param elements - Map of element tag names to package versions
+     * @param options - Loading options
+     */
+    loadElements(elements: ElementMap, options?: LoadOptions): Promise<void>;
+    /**
+     * Extract and load elements from items
+     *
+     * Automatically aggregates unique elements from all items and loads them once.
+     *
+     * @param items - Array of items to extract elements from
+     * @param options - Loading options
+     * @throws Error if element version conflicts are detected
+     */
+    loadFromItems(items: ItemEntity[], options?: LoadOptions): Promise<void>;
+}
+//# sourceMappingURL=EsmElementLoader.d.ts.map

package/dist/loaders/EsmElementLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EsmElementLoader.d.ts","sourceRoot":"","sources":["../../src/loaders/EsmElementLoader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAEN,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAElB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,gBAAiB,YAAW,sBAAsB;IAC9D,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,sBAAsB;IAO1C;;;;;OAKG;IACG,YAAY,CACjB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC;IAOhB;;;;;;;;OAQG;IACG,aAAa,CAClB,KAAK,EAAE,UAAU,EAAE,EACnB,OAAO,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC;CAIhB"}

package/dist/loaders/EsmElementLoader.js

@@ -0,0 +1,71 @@
+/**
+ * ESM Element Loader
+ *
+ * Wraps EsmPieLoader to provide element-level loading abstraction.
+ * Aggregates elements from multiple items and loads them once using ESM modules.
+ */
+import { EsmPieLoader } from "../pie/esm-loader";
+import { aggregateElements, } from "./ElementLoader";
+/**
+ * Element loader for ESM (ES Modules) bundles
+ *
+ * This loader wraps EsmPieLoader and provides element aggregation capabilities.
+ * It eliminates duplicate bundle loads when multiple items use the same PIE elements.
+ * ESM is the modern, preferred loading mechanism with better browser support and features.
+ *
+ * @example
+ * ```typescript
+ * const loader = new EsmElementLoader({
+ *   esmCdnUrl: 'https://esm.sh'
+ * });
+ *
+ * // Load elements from multiple items at once
+ * await loader.loadFromItems(section.items, {
+ *   view: 'delivery',
+ *   needsControllers: true
+ * });
+ *
+ * // Or load specific elements directly
+ * await loader.loadElements({
+ *   'pie-multiple-choice': '@pie-element/multiple-choice@11.0.1',
+ *   'pie-hotspot': '@pie-element/hotspot@9.0.0'
+ * }, {
+ *   view: 'author' // Load author view for editing
+ * });
+ * ```
+ */
+export class EsmElementLoader {
+    loader;
+    constructor(config) {
+        this.loader = new EsmPieLoader({
+            cdnBaseUrl: config.esmCdnUrl,
+            debugEnabled: config.debugEnabled,
+        });
+    }
+    /**
+     * Load elements directly from an element map
+     *
+     * @param elements - Map of element tag names to package versions
+     * @param options - Loading options
+     */
+    async loadElements(elements, options) {
+        await this.loader.load({ elements }, document, {
+            view: options?.view || "delivery",
+            loadControllers: options?.needsControllers ?? true,
+        });
+    }
+    /**
+     * Extract and load elements from items
+     *
+     * Automatically aggregates unique elements from all items and loads them once.
+     *
+     * @param items - Array of items to extract elements from
+     * @param options - Loading options
+     * @throws Error if element version conflicts are detected
+     */
+    async loadFromItems(items, options) {
+        const elements = aggregateElements(items);
+        await this.loadElements(elements, options);
+    }
+}
+//# sourceMappingURL=EsmElementLoader.js.map

package/dist/loaders/EsmElementLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EsmElementLoader.js","sourceRoot":"","sources":["../../src/loaders/EsmElementLoader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EACN,iBAAiB,GAIjB,MAAM,iBAAiB,CAAC;AAazB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,gBAAgB;IACpB,MAAM,CAAe;IAE7B,YAAY,MAA8B;QACzC,IAAI,CAAC,MAAM,GAAG,IAAI,YAAY,CAAC;YAC9B,UAAU,EAAE,MAAM,CAAC,SAAS;YAC5B,YAAY,EAAE,MAAM,CAAC,YAAY;SACjC,CAAC,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CACjB,QAAoB,EACpB,OAAqB;QAErB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE;YAC9C,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,UAAU;YACjC,eAAe,EAAE,OAAO,EAAE,gBAAgB,IAAI,IAAI;SAClD,CAAC,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,aAAa,CAClB,KAAmB,EACnB,OAAqB;QAErB,MAAM,QAAQ,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;CACD"}

package/dist/loaders/IifeElementLoader.d.ts

@@ -0,0 +1,61 @@
+/**
+ * IIFE Element Loader
+ *
+ * Wraps IifePieLoader to provide element-level loading abstraction.
+ * Aggregates elements from multiple items and loads them once using IIFE bundles.
+ */
+import type { ItemEntity } from "../types";
+import { type ElementLoaderInterface, type ElementMap, type LoadOptions } from "./ElementLoader";
+/**
+ * Configuration for IIFE element loader
+ */
+export interface IifeElementLoaderConfig {
+    /** Base URL for bundle service (e.g., "https://bundles.pie.org") */
+    bundleHost: string;
+    /** Optional function to check if debug mode is enabled */
+    debugEnabled?: () => boolean;
+}
+/**
+ * Element loader for IIFE (Immediately Invoked Function Expression) bundles
+ *
+ * This loader wraps IifePieLoader and provides element aggregation capabilities.
+ * It eliminates duplicate bundle loads when multiple items use the same PIE elements.
+ *
+ * @example
+ * ```typescript
+ * const loader = new IifeElementLoader({
+ *   bundleHost: 'https://bundles.pie.org'
+ * });
+ *
+ * // Load elements from multiple items at once
+ * await loader.loadFromItems(section.items);
+ *
+ * // Or load specific elements directly
+ * await loader.loadElements({
+ *   'pie-multiple-choice': '@pie-element/multiple-choice@11.0.1',
+ *   'pie-hotspot': '@pie-element/hotspot@9.0.0'
+ * });
+ * ```
+ */
+export declare class IifeElementLoader implements ElementLoaderInterface {
+    private loader;
+    constructor(config: IifeElementLoaderConfig);
+    /**
+     * Load elements directly from an element map
+     *
+     * @param elements - Map of element tag names to package versions
+     * @param options - Loading options
+     */
+    loadElements(elements: ElementMap, options?: LoadOptions): Promise<void>;
+    /**
+     * Extract and load elements from items
+     *
+     * Automatically aggregates unique elements from all items and loads them once.
+     *
+     * @param items - Array of items to extract elements from
+     * @param options - Loading options
+     * @throws Error if element version conflicts are detected
+     */
+    loadFromItems(items: ItemEntity[], options?: LoadOptions): Promise<void>;
+}
+//# sourceMappingURL=IifeElementLoader.d.ts.map

package/dist/loaders/IifeElementLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IifeElementLoader.d.ts","sourceRoot":"","sources":["../../src/loaders/IifeElementLoader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAEN,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAC;IAEnB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,iBAAkB,YAAW,sBAAsB;IAC/D,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,uBAAuB;IAO3C;;;;;OAKG;IACG,YAAY,CACjB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC;IAShB;;;;;;;;OAQG;IACG,aAAa,CAClB,KAAK,EAAE,UAAU,EAAE,EACnB,OAAO,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC;CAIhB"}

package/dist/loaders/IifeElementLoader.js

@@ -0,0 +1,63 @@
+/**
+ * IIFE Element Loader
+ *
+ * Wraps IifePieLoader to provide element-level loading abstraction.
+ * Aggregates elements from multiple items and loads them once using IIFE bundles.
+ */
+import { IifePieLoader } from "../pie/iife-loader";
+import { BundleType } from "../pie/types";
+import { aggregateElements, } from "./ElementLoader";
+/**
+ * Element loader for IIFE (Immediately Invoked Function Expression) bundles
+ *
+ * This loader wraps IifePieLoader and provides element aggregation capabilities.
+ * It eliminates duplicate bundle loads when multiple items use the same PIE elements.
+ *
+ * @example
+ * ```typescript
+ * const loader = new IifeElementLoader({
+ *   bundleHost: 'https://bundles.pie.org'
+ * });
+ *
+ * // Load elements from multiple items at once
+ * await loader.loadFromItems(section.items);
+ *
+ * // Or load specific elements directly
+ * await loader.loadElements({
+ *   'pie-multiple-choice': '@pie-element/multiple-choice@11.0.1',
+ *   'pie-hotspot': '@pie-element/hotspot@9.0.0'
+ * });
+ * ```
+ */
+export class IifeElementLoader {
+    loader;
+    constructor(config) {
+        this.loader = new IifePieLoader({
+            bundleHost: config.bundleHost,
+            debugEnabled: config.debugEnabled,
+        });
+    }
+    /**
+     * Load elements directly from an element map
+     *
+     * @param elements - Map of element tag names to package versions
+     * @param options - Loading options
+     */
+    async loadElements(elements, options) {
+        await this.loader.load({ elements }, document, options?.bundleType || BundleType.clientPlayer, options?.needsControllers ?? true);
+    }
+    /**
+     * Extract and load elements from items
+     *
+     * Automatically aggregates unique elements from all items and loads them once.
+     *
+     * @param items - Array of items to extract elements from
+     * @param options - Loading options
+     * @throws Error if element version conflicts are detected
+     */
+    async loadFromItems(items, options) {
+        const elements = aggregateElements(items);
+        await this.loadElements(elements, options);
+    }
+}
+//# sourceMappingURL=IifeElementLoader.js.map

package/dist/loaders/IifeElementLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IifeElementLoader.js","sourceRoot":"","sources":["../../src/loaders/IifeElementLoader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EACN,iBAAiB,GAIjB,MAAM,iBAAiB,CAAC;AAazB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,iBAAiB;IACrB,MAAM,CAAgB;IAE9B,YAAY,MAA+B;QAC1C,IAAI,CAAC,MAAM,GAAG,IAAI,aAAa,CAAC;YAC/B,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,YAAY,EAAE,MAAM,CAAC,YAAY;SACjC,CAAC,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CACjB,QAAoB,EACpB,OAAqB;QAErB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CACrB,EAAE,QAAQ,EAAE,EACZ,QAAQ,EACR,OAAO,EAAE,UAAU,IAAI,UAAU,CAAC,YAAY,EAC9C,OAAO,EAAE,gBAAgB,IAAI,IAAI,CACjC,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,aAAa,CAClB,KAAmB,EACnB,OAAqB;QAErB,MAAM,QAAQ,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;CACD"}

package/dist/loaders/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * PIE Element Loaders
+ *
+ * Element-level loading abstractions for PIE players.
+ * Provides both IIFE and ESM loaders with element aggregation capabilities.
+ *
+ * @example
+ * ```typescript
+ * // ESM (modern, preferred)
+ * import { EsmElementLoader } from '@pie-players/pie-players-shared/loaders';
+ *
+ * const loader = new EsmElementLoader({ esmCdnUrl: 'https://esm.sh' });
+ * await loader.loadFromItems(section.items);
+ *
+ * // IIFE (legacy compatibility)
+ * import { IifeElementLoader } from '@pie-players/pie-players-shared/loaders';
+ *
+ * const loader = new IifeElementLoader({ bundleHost: 'https://bundles.pie.org' });
+ * await loader.loadFromItems(section.items);
+ * ```
+ */
+export type { ElementLoaderInterface, ElementMap, LoadOptions, } from "./ElementLoader";
+export { aggregateElements } from "./ElementLoader";
+export type { EsmElementLoaderConfig } from "./EsmElementLoader";
+export { EsmElementLoader } from "./EsmElementLoader";
+export type { IifeElementLoaderConfig } from "./IifeElementLoader";
+export { IifeElementLoader } from "./IifeElementLoader";
+//# sourceMappingURL=index.d.ts.map

package/dist/loaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/loaders/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACX,sBAAsB,EACtB,UAAU,EACV,WAAW,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/loaders/index.js

@@ -0,0 +1,25 @@
+/**
+ * PIE Element Loaders
+ *
+ * Element-level loading abstractions for PIE players.
+ * Provides both IIFE and ESM loaders with element aggregation capabilities.
+ *
+ * @example
+ * ```typescript
+ * // ESM (modern, preferred)
+ * import { EsmElementLoader } from '@pie-players/pie-players-shared/loaders';
+ *
+ * const loader = new EsmElementLoader({ esmCdnUrl: 'https://esm.sh' });
+ * await loader.loadFromItems(section.items);
+ *
+ * // IIFE (legacy compatibility)
+ * import { IifeElementLoader } from '@pie-players/pie-players-shared/loaders';
+ *
+ * const loader = new IifeElementLoader({ bundleHost: 'https://bundles.pie.org' });
+ * await loader.loadFromItems(section.items);
+ * ```
+ */
+export { aggregateElements } from "./ElementLoader";
+export { EsmElementLoader } from "./EsmElementLoader";
+export { IifeElementLoader } from "./IifeElementLoader";
+//# sourceMappingURL=index.js.map

package/dist/loaders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/loaders/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/object/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A problem using the spread operator merging objects is that undefined properties may override
+ * defined properties, which is often NOT what you want (e.g. when providing default values). This
+ * function merges objects, but ignores properties that are null or undefined.
+ * @param objects The objects to merge.
+ */
+export declare const mergeObjectsIgnoringNullUndefined: <T extends object>(...objects: T[]) => T;
+/**
+ * Deep clone an object.
+ */
+export declare const cloneDeep: <T>(value: T) => T;
+//# sourceMappingURL=index.d.ts.map

package/dist/object/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,GAAI,CAAC,SAAS,MAAM,EACjE,GAAG,SAAS,CAAC,EAAE,KACb,CAaF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CAiBvC,CAAC"}

package/dist/object/index.js

@@ -0,0 +1,40 @@
+/**
+ * A problem using the spread operator merging objects is that undefined properties may override
+ * defined properties, which is often NOT what you want (e.g. when providing default values). This
+ * function merges objects, but ignores properties that are null or undefined.
+ * @param objects The objects to merge.
+ */
+export const mergeObjectsIgnoringNullUndefined = (...objects) => {
+    return objects.reduce((acc, obj) => {
+        for (const key in obj) {
+            if (Object.hasOwn(obj, key) &&
+                obj[key] !== null &&
+                obj[key] !== undefined) {
+                acc[key] = obj[key];
+            }
+        }
+        return acc;
+    }, {});
+};
+/**
+ * Deep clone an object.
+ */
+export const cloneDeep = (value) => {
+    if (value === null || typeof value !== "object") {
+        // Primitive value (or null), just return it
+        return value;
+    }
+    if (Array.isArray(value)) {
+        // Array: clone each element recursively
+        return value.map(cloneDeep);
+    }
+    // Object: create a new object and clone its properties
+    const copy = {};
+    for (const key in value) {
+        if (Object.hasOwn(value, key)) {
+            copy[key] = cloneDeep(value[key]);
+        }
+    }
+    return copy;
+};
+//# sourceMappingURL=index.js.map

package/dist/object/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAChD,GAAG,OAAY,EACX,EAAE;IACN,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QAClC,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;YACvB,IACC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC;gBACtB,GAAW,CAAC,GAAG,CAAC,KAAK,IAAI;gBACzB,GAAW,CAAC,GAAG,CAAC,KAAK,SAAS,EAC9B,CAAC;gBACD,GAAW,CAAC,GAAG,CAAC,GAAI,GAAW,CAAC,GAAG,CAAC,CAAC;YACvC,CAAC;QACF,CAAC;QACD,OAAO,GAAG,CAAC;IACZ,CAAC,EAAE,EAAO,CAAC,CAAC;AACb,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAI,KAAQ,EAAK,EAAE;IAC3C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACjD,4CAA4C;QAC5C,OAAO,KAAK,CAAC;IACd,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,wCAAwC;QACxC,OAAO,KAAK,CAAC,GAAG,CAAC,SAAS,CAAM,CAAC;IAClC,CAAC;IACD,uDAAuD;IACvD,MAAM,IAAI,GAAG,EAAO,CAAC;IACrB,KAAK,MAAM,GAAG,IAAI,KAAY,EAAE,CAAC;QAChC,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YAC9B,IAAY,CAAC,GAAG,CAAC,GAAG,SAAS,CAAE,KAAa,CAAC,GAAG,CAAC,CAAC,CAAC;QACrD,CAAC;IACF,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC,CAAC"}