@widgetic/embed-sdk 0.0.0-stage → 2.0.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +567 -2
- package/dist/browser/chunks/ABTestManager.js +1 -0
- package/dist/browser/chunks/advanced.js +1 -0
- package/dist/browser/chunks/api.js +1 -0
- package/dist/browser/chunks/core.js +1 -0
- package/dist/browser/chunks/display.js +1 -0
- package/dist/browser/chunks/media.js +1 -0
- package/dist/browser/chunks/messaging.js +1 -0
- package/dist/browser/chunks/performance.js +1 -0
- package/dist/browser/chunks/renderers.js +1 -0
- package/dist/browser/chunks/scanner.js +1 -0
- package/dist/browser/chunks/security.js +1 -0
- package/dist/browser/chunks/vendor.js +1 -0
- package/dist/browser/embed-bootstrap.js +1 -0
- package/dist/browser/embed-sdk.js +1 -0
- package/dist/esm/chunks/ABTestManager.js +1 -0
- package/dist/esm/chunks/advanced.js +1 -0
- package/dist/esm/chunks/api.js +1 -0
- package/dist/esm/chunks/core.js +1 -0
- package/dist/esm/chunks/display.js +1 -0
- package/dist/esm/chunks/media.js +1 -0
- package/dist/esm/chunks/messaging.js +1 -0
- package/dist/esm/chunks/performance.js +1 -0
- package/dist/esm/chunks/renderers.js +1 -0
- package/dist/esm/chunks/scanner.js +1 -0
- package/dist/esm/chunks/security.js +1 -0
- package/dist/esm/chunks/vendor.js +1 -0
- package/dist/esm/embed-bootstrap.js +1 -0
- package/dist/esm/embed-sdk.js +1 -0
- package/dist/esm/types/abTesting/ABTestElement.d.ts +120 -0
- package/dist/esm/types/abTesting/ABTestManager.d.ts +177 -0
- package/dist/esm/types/api/batch-client.d.ts +163 -0
- package/dist/esm/types/api/layers.d.ts +119 -0
- package/dist/esm/types/core/advanced-security-manager.d.ts +330 -0
- package/dist/esm/types/core/analytics-tracker.d.ts +224 -0
- package/dist/esm/types/core/auth-detector.d.ts +65 -0
- package/dist/esm/types/core/auth-manager.d.ts +90 -0
- package/dist/esm/types/core/autoscale-manager.d.ts +91 -0
- package/dist/esm/types/core/breakpoints.d.ts +48 -0
- package/dist/esm/types/core/config.d.ts +152 -0
- package/dist/esm/types/core/constants.d.ts +75 -0
- package/dist/esm/types/core/content-position-manager.d.ts +228 -0
- package/dist/esm/types/core/custom-element.d.ts +152 -0
- package/dist/esm/types/core/display-manager.d.ts +109 -0
- package/dist/esm/types/core/editor-overlay.d.ts +113 -0
- package/dist/esm/types/core/embed-sdk.d.ts +310 -0
- package/dist/esm/types/core/exit-intent-trigger.d.ts +114 -0
- package/dist/esm/types/core/lazy-loader.d.ts +111 -0
- package/dist/esm/types/core/media-manager.d.ts +364 -0
- package/dist/esm/types/core/messaging.d.ts +251 -0
- package/dist/esm/types/core/overlay-manager.d.ts +119 -0
- package/dist/esm/types/core/performance-monitor.d.ts +152 -0
- package/dist/esm/types/core/privacy-compliance.d.ts +236 -0
- package/dist/esm/types/core/realtime-manager.d.ts +279 -0
- package/dist/esm/types/core/resize-handler.d.ts +81 -0
- package/dist/esm/types/core/resource-optimizer.d.ts +133 -0
- package/dist/esm/types/core/responsive-manager.d.ts +49 -0
- package/dist/esm/types/core/scroll-trigger.d.ts +105 -0
- package/dist/esm/types/core/security-manager.d.ts +150 -0
- package/dist/esm/types/core/text-field-manager.d.ts +204 -0
- package/dist/esm/types/core/token-provider.d.ts +75 -0
- package/dist/esm/types/core/trigger-defaults.d.ts +36 -0
- package/dist/esm/types/core/trigger-manager.d.ts +248 -0
- package/dist/esm/types/core/types.d.ts +473 -0
- package/dist/esm/types/core/ui-sdk-loader.d.ts +90 -0
- package/dist/esm/types/core/widget-manager.d.ts +285 -0
- package/dist/esm/types/core/widget-metadata.d.ts +107 -0
- package/dist/esm/types/embed-sdk.d.ts +31 -0
- package/dist/esm/types/loaders/module-loader.d.ts +147 -0
- package/dist/esm/types/renderers/custom-element-renderer.d.ts +78 -0
- package/dist/esm/types/renderers/iframe-renderer.d.ts +185 -0
- package/dist/esm/types/renderers/widget-renderer.d.ts +173 -0
- package/dist/esm/types/sdk/embed-bootstrap.d.ts +84 -0
- package/dist/esm/types/sdk/embed-sdk.d.ts +31 -0
- package/dist/esm/types/translations/TranslationElement.d.ts +93 -0
- package/dist/esm/types/utils/browser.d.ts +29 -0
- package/dist/esm/types/utils/caseConversion.d.ts +2 -0
- package/dist/esm/types/utils/css-debug.d.ts +105 -0
- package/dist/esm/types/utils/device-detector.d.ts +100 -0
- package/dist/esm/types/utils/event-emitter.d.ts +14 -0
- package/dist/esm/types/utils/hydrate-published-host.d.ts +17 -0
- package/dist/esm/types/utils/logger.d.ts +31 -0
- package/dist/esm/types/utils/parser.d.ts +39 -0
- package/dist/esm/types/utils/portal.d.ts +74 -0
- package/dist/esm/types/utils/public-embed-lookup.d.ts +68 -0
- package/dist/esm/types/utils/published-host-display.d.ts +61 -0
- package/dist/umd/embed-bootstrap.js +1 -0
- package/dist/umd/embed-sdk.js +1 -0
- package/package.json +154 -4
|
@@ -0,0 +1,114 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Exit Intent Trigger
|
|
3
|
+
* Handles desktop (mouse) and mobile (gesture) exit intent detection
|
|
4
|
+
* Desktop: cursor leaving viewport, Mobile: back button, scroll up, tab switch
|
|
5
|
+
*/
|
|
6
|
+
import type { ExitIntentConfig } from "./types.js";
|
|
7
|
+
export interface ExitIntentTriggerOptions {
|
|
8
|
+
widgetId: string;
|
|
9
|
+
config: ExitIntentConfig;
|
|
10
|
+
}
|
|
11
|
+
/**
|
|
12
|
+
* Manages exit intent triggers for widget display
|
|
13
|
+
*/
|
|
14
|
+
export declare class ExitIntentTrigger {
|
|
15
|
+
private widgetId;
|
|
16
|
+
private config;
|
|
17
|
+
private mouseLeaveListener;
|
|
18
|
+
private lastMouseY;
|
|
19
|
+
private isTriggered;
|
|
20
|
+
private scrollUpListener;
|
|
21
|
+
private visibilityChangeListener;
|
|
22
|
+
private backButtonListener;
|
|
23
|
+
private touchStartListener;
|
|
24
|
+
private touchEndListener;
|
|
25
|
+
private lastScrollY;
|
|
26
|
+
private scrollUpDistance;
|
|
27
|
+
private touchStartY;
|
|
28
|
+
private touchStartTime;
|
|
29
|
+
private isScrollingUp;
|
|
30
|
+
private debounceTimer;
|
|
31
|
+
private isDestroyed;
|
|
32
|
+
private stats;
|
|
33
|
+
constructor(options: ExitIntentTriggerOptions);
|
|
34
|
+
/**
|
|
35
|
+
* Get default exit intent configuration
|
|
36
|
+
*/
|
|
37
|
+
private getDefaultConfig;
|
|
38
|
+
/**
|
|
39
|
+
* Initialize exit intent triggers
|
|
40
|
+
*/
|
|
41
|
+
private initialize;
|
|
42
|
+
/**
|
|
43
|
+
* Detect if device is desktop
|
|
44
|
+
*/
|
|
45
|
+
private isDesktop;
|
|
46
|
+
/**
|
|
47
|
+
* Detect if device is mobile
|
|
48
|
+
*/
|
|
49
|
+
private isMobile;
|
|
50
|
+
/**
|
|
51
|
+
* Initialize desktop exit intent triggers
|
|
52
|
+
*/
|
|
53
|
+
private initializeDesktopTriggers;
|
|
54
|
+
/**
|
|
55
|
+
* Initialize mobile exit intent triggers
|
|
56
|
+
*/
|
|
57
|
+
private initializeMobileTriggers;
|
|
58
|
+
/**
|
|
59
|
+
* Handle desktop mouse leave events
|
|
60
|
+
*/
|
|
61
|
+
private handleMouseLeave;
|
|
62
|
+
/**
|
|
63
|
+
* Handle mobile back button
|
|
64
|
+
*/
|
|
65
|
+
private handleBackButton;
|
|
66
|
+
/**
|
|
67
|
+
* Handle mobile scroll up detection
|
|
68
|
+
*/
|
|
69
|
+
private handleScrollUp;
|
|
70
|
+
/**
|
|
71
|
+
* Handle touch start for gesture detection
|
|
72
|
+
*/
|
|
73
|
+
private handleTouchStart;
|
|
74
|
+
/**
|
|
75
|
+
* Handle touch end for swipe detection
|
|
76
|
+
*/
|
|
77
|
+
private handleTouchEnd;
|
|
78
|
+
/**
|
|
79
|
+
* Handle tab visibility changes
|
|
80
|
+
*/
|
|
81
|
+
private handleVisibilityChange;
|
|
82
|
+
/**
|
|
83
|
+
* Dispatch trigger activated event
|
|
84
|
+
*/
|
|
85
|
+
private triggerActivated;
|
|
86
|
+
/**
|
|
87
|
+
* Debounce utility for performance optimization
|
|
88
|
+
*/
|
|
89
|
+
private debounce;
|
|
90
|
+
/**
|
|
91
|
+
* Update exit intent configuration
|
|
92
|
+
*/
|
|
93
|
+
updateConfig(newConfig: Partial<ExitIntentConfig>): void;
|
|
94
|
+
/**
|
|
95
|
+
* Reset trigger state
|
|
96
|
+
*/
|
|
97
|
+
reset(): void;
|
|
98
|
+
/**
|
|
99
|
+
* Get current trigger stats
|
|
100
|
+
*/
|
|
101
|
+
getStats(): any;
|
|
102
|
+
/**
|
|
103
|
+
* Check if trigger is currently active
|
|
104
|
+
*/
|
|
105
|
+
isActive(): boolean;
|
|
106
|
+
/**
|
|
107
|
+
* Manually trigger activation (for testing)
|
|
108
|
+
*/
|
|
109
|
+
forceActivate(source?: 'desktop' | 'mobile'): void;
|
|
110
|
+
/**
|
|
111
|
+
* Destroy exit intent trigger and clean up
|
|
112
|
+
*/
|
|
113
|
+
destroy(): void;
|
|
114
|
+
}
|
|
@@ -0,0 +1,111 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Lazy Loader - Viewport-based widget loading with Intersection Observer
|
|
3
|
+
*
|
|
4
|
+
* Features:
|
|
5
|
+
* - Intersection Observer-based viewport detection
|
|
6
|
+
* - Configurable loading thresholds and margins
|
|
7
|
+
* - Progressive enhancement with fallbacks
|
|
8
|
+
* - Performance monitoring integration
|
|
9
|
+
* - Resource preloading and prefetching
|
|
10
|
+
* - Memory management and cleanup
|
|
11
|
+
*/
|
|
12
|
+
export interface LazyLoadConfig {
|
|
13
|
+
enabled: boolean;
|
|
14
|
+
rootMargin: string;
|
|
15
|
+
threshold: number | number[];
|
|
16
|
+
enablePreloading: boolean;
|
|
17
|
+
preloadDistance: string;
|
|
18
|
+
retryAttempts: number;
|
|
19
|
+
retryDelay: number;
|
|
20
|
+
enablePrefetch: boolean;
|
|
21
|
+
prefetchDelay: number;
|
|
22
|
+
enableProgressiveLoading: boolean;
|
|
23
|
+
maxConcurrentLoads: number;
|
|
24
|
+
enableResourceHints: boolean;
|
|
25
|
+
}
|
|
26
|
+
export interface LazyLoadItem {
|
|
27
|
+
element: HTMLElement;
|
|
28
|
+
compositionId: string;
|
|
29
|
+
config: any;
|
|
30
|
+
loadFunction: () => Promise<void>;
|
|
31
|
+
priority: number;
|
|
32
|
+
retryCount: number;
|
|
33
|
+
isLoading: boolean;
|
|
34
|
+
isLoaded: boolean;
|
|
35
|
+
isPreloaded: boolean;
|
|
36
|
+
viewportEntryTime?: number;
|
|
37
|
+
resourceUrls?: string[];
|
|
38
|
+
}
|
|
39
|
+
export interface LazyLoadMetrics {
|
|
40
|
+
totalItems: number;
|
|
41
|
+
loadedItems: number;
|
|
42
|
+
failedItems: number;
|
|
43
|
+
averageLoadTime: number;
|
|
44
|
+
viewportUtilization: number;
|
|
45
|
+
preloadSuccess: number;
|
|
46
|
+
}
|
|
47
|
+
export declare class LazyLoader {
|
|
48
|
+
private config;
|
|
49
|
+
private items;
|
|
50
|
+
private observer;
|
|
51
|
+
private preloadObserver;
|
|
52
|
+
private loadingQueue;
|
|
53
|
+
private activeLoads;
|
|
54
|
+
private performanceMonitor;
|
|
55
|
+
private retryTimeouts;
|
|
56
|
+
constructor(config?: Partial<LazyLoadConfig>);
|
|
57
|
+
private init;
|
|
58
|
+
private setupIntersectionObserver;
|
|
59
|
+
private setupPreloadObserver;
|
|
60
|
+
private handleIntersection;
|
|
61
|
+
private handlePreloadIntersection;
|
|
62
|
+
/**
|
|
63
|
+
* Register an element for lazy loading
|
|
64
|
+
*/
|
|
65
|
+
register(element: HTMLElement, compositionId: string, loadFunction: () => Promise<void>, options?: {
|
|
66
|
+
config?: any;
|
|
67
|
+
priority?: number;
|
|
68
|
+
resourceUrls?: string[];
|
|
69
|
+
}): void;
|
|
70
|
+
/**
|
|
71
|
+
* Unregister an element from lazy loading
|
|
72
|
+
*/
|
|
73
|
+
unregister(key: string): void;
|
|
74
|
+
private queueLoad;
|
|
75
|
+
private processLoadingQueue;
|
|
76
|
+
private loadItem;
|
|
77
|
+
private preloadResources;
|
|
78
|
+
private preloadResource;
|
|
79
|
+
private addResourceHints;
|
|
80
|
+
private estimateBundleSize;
|
|
81
|
+
private fallbackToImmediateLoading;
|
|
82
|
+
/**
|
|
83
|
+
* Force load a specific widget
|
|
84
|
+
*/
|
|
85
|
+
forceLoad(compositionId: string): Promise<void>;
|
|
86
|
+
/**
|
|
87
|
+
* Load all visible widgets immediately
|
|
88
|
+
*/
|
|
89
|
+
loadVisible(): Promise<void[]>;
|
|
90
|
+
private isElementVisible;
|
|
91
|
+
/**
|
|
92
|
+
* Get lazy loading metrics
|
|
93
|
+
*/
|
|
94
|
+
getMetrics(): LazyLoadMetrics;
|
|
95
|
+
/**
|
|
96
|
+
* Update configuration
|
|
97
|
+
*/
|
|
98
|
+
updateConfig(config: Partial<LazyLoadConfig>): void;
|
|
99
|
+
/**
|
|
100
|
+
* Clean up and stop lazy loading
|
|
101
|
+
*/
|
|
102
|
+
destroy(): void;
|
|
103
|
+
}
|
|
104
|
+
/**
|
|
105
|
+
* Get or create global lazy loader
|
|
106
|
+
*/
|
|
107
|
+
export declare function getLazyLoader(config?: Partial<LazyLoadConfig>): LazyLoader;
|
|
108
|
+
/**
|
|
109
|
+
* Initialize lazy loading with configuration
|
|
110
|
+
*/
|
|
111
|
+
export declare function initializeLazyLoading(config?: Partial<LazyLoadConfig>): LazyLoader;
|
|
@@ -0,0 +1,364 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Media Manager - Centralized media playback coordination
|
|
3
|
+
* Prevents overlapping audio/video across widgets with automatic pausing
|
|
4
|
+
* Enhanced with detailed state persistence and resumption capabilities
|
|
5
|
+
*/
|
|
6
|
+
export interface MediaState {
|
|
7
|
+
/** Widget composition ID */
|
|
8
|
+
compositionId: string;
|
|
9
|
+
/** Type of media being played */
|
|
10
|
+
mediaType: 'audio' | 'video' | 'both';
|
|
11
|
+
/** Media playback state */
|
|
12
|
+
state: 'playing' | 'paused' | 'stopped';
|
|
13
|
+
/** Priority level (higher = more important) */
|
|
14
|
+
priority: number;
|
|
15
|
+
/** Timestamp when playback started */
|
|
16
|
+
startedAt: number;
|
|
17
|
+
/** Duration if known */
|
|
18
|
+
duration?: number;
|
|
19
|
+
/** Current position if known */
|
|
20
|
+
position?: number;
|
|
21
|
+
/** Media title/name if available */
|
|
22
|
+
title?: string;
|
|
23
|
+
/** Volume level (0-1) */
|
|
24
|
+
volume?: number;
|
|
25
|
+
/** Playlist/track information */
|
|
26
|
+
playlist?: {
|
|
27
|
+
/** Current track index */
|
|
28
|
+
currentTrack: number;
|
|
29
|
+
/** Total tracks in playlist */
|
|
30
|
+
totalTracks: number;
|
|
31
|
+
/** Current track ID/identifier */
|
|
32
|
+
trackId?: string;
|
|
33
|
+
/** Current track title */
|
|
34
|
+
trackTitle?: string;
|
|
35
|
+
/** Playlist ID if applicable */
|
|
36
|
+
playlistId?: string;
|
|
37
|
+
/** Playlist title */
|
|
38
|
+
playlistTitle?: string;
|
|
39
|
+
};
|
|
40
|
+
/** Whether this widget should auto-resume on page load */
|
|
41
|
+
autoResume?: boolean;
|
|
42
|
+
/** Last interaction timestamp (for auto-resume logic) */
|
|
43
|
+
lastInteraction?: number;
|
|
44
|
+
}
|
|
45
|
+
export interface MediaConfig {
|
|
46
|
+
/** Whether this widget should auto-pause others when playing */
|
|
47
|
+
autoPause?: boolean;
|
|
48
|
+
/** Type of media this widget can play */
|
|
49
|
+
mediaType?: 'audio' | 'video' | 'both';
|
|
50
|
+
/** Priority level for conflict resolution (0-10, default: 5) */
|
|
51
|
+
priority?: number;
|
|
52
|
+
/** Whether to persist playback state in localStorage */
|
|
53
|
+
persistState?: boolean;
|
|
54
|
+
/** Whether to allow simultaneous playback with specific media types */
|
|
55
|
+
allowSimultaneous?: ('audio' | 'video')[];
|
|
56
|
+
/** Whether to auto-resume playback after page refresh */
|
|
57
|
+
autoResume?: boolean;
|
|
58
|
+
/** Maximum time since last interaction to allow auto-resume (ms, default: 30 minutes) */
|
|
59
|
+
autoResumeTimeout?: number;
|
|
60
|
+
/** Whether to use global volume synchronization across all widgets */
|
|
61
|
+
globalVolume?: boolean;
|
|
62
|
+
}
|
|
63
|
+
export interface GlobalVolumeState {
|
|
64
|
+
/** Current global volume level (0-1) */
|
|
65
|
+
volume: number;
|
|
66
|
+
/** Whether global volume is muted */
|
|
67
|
+
muted: boolean;
|
|
68
|
+
/** Timestamp of last volume change */
|
|
69
|
+
lastUpdated: number;
|
|
70
|
+
/** ID of widget that last changed the volume */
|
|
71
|
+
lastChangedBy?: string;
|
|
72
|
+
}
|
|
73
|
+
export interface MediaEvent {
|
|
74
|
+
/** Event type */
|
|
75
|
+
type: 'play' | 'pause' | 'stop' | 'ended' | 'seeking' | 'volumechange' | 'trackchange' | 'playlistchange';
|
|
76
|
+
/** Widget composition ID */
|
|
77
|
+
compositionId: string;
|
|
78
|
+
/** Media configuration */
|
|
79
|
+
config: MediaConfig;
|
|
80
|
+
/** Additional event data */
|
|
81
|
+
data?: {
|
|
82
|
+
position?: number;
|
|
83
|
+
duration?: number;
|
|
84
|
+
volume?: number;
|
|
85
|
+
title?: string;
|
|
86
|
+
mediaType?: 'audio' | 'video' | 'both';
|
|
87
|
+
/** Playlist/track information */
|
|
88
|
+
playlist?: {
|
|
89
|
+
currentTrack?: number;
|
|
90
|
+
totalTracks?: number;
|
|
91
|
+
trackId?: string;
|
|
92
|
+
trackTitle?: string;
|
|
93
|
+
playlistId?: string;
|
|
94
|
+
playlistTitle?: string;
|
|
95
|
+
};
|
|
96
|
+
};
|
|
97
|
+
}
|
|
98
|
+
export interface ResumeOptions {
|
|
99
|
+
/** Whether to auto-resume widgets that were playing */
|
|
100
|
+
autoResumePlayback?: boolean;
|
|
101
|
+
/** Maximum age of state to consider for auto-resume (ms, default: 30 minutes) */
|
|
102
|
+
maxStateAge?: number;
|
|
103
|
+
/** Specific widget to resume (if not provided, resumes all eligible) */
|
|
104
|
+
compositionId?: string;
|
|
105
|
+
/** Whether to respect auto-resume timeouts */
|
|
106
|
+
respectTimeouts?: boolean;
|
|
107
|
+
}
|
|
108
|
+
export declare class MediaManager {
|
|
109
|
+
private static instance;
|
|
110
|
+
private playingWidgets;
|
|
111
|
+
private widgetConfigs;
|
|
112
|
+
private readonly storageKey;
|
|
113
|
+
private readonly globalVolumeKey;
|
|
114
|
+
private readonly storageVersion;
|
|
115
|
+
private eventListeners;
|
|
116
|
+
private autoResumeEnabled;
|
|
117
|
+
private readonly defaultAutoResumeTimeout;
|
|
118
|
+
private globalVolumeEnabled;
|
|
119
|
+
private globalVolumeState;
|
|
120
|
+
static getInstance(): MediaManager;
|
|
121
|
+
constructor();
|
|
122
|
+
/**
|
|
123
|
+
* Register a widget for media management
|
|
124
|
+
*/
|
|
125
|
+
registerWidget(compositionId: string, config?: MediaConfig): void;
|
|
126
|
+
/**
|
|
127
|
+
* Unregister a widget from media management
|
|
128
|
+
*/
|
|
129
|
+
unregisterWidget(compositionId: string): void;
|
|
130
|
+
/**
|
|
131
|
+
* Handle media events from widgets
|
|
132
|
+
*/
|
|
133
|
+
handleMediaEvent(event: MediaEvent): void;
|
|
134
|
+
/**
|
|
135
|
+
* Handle play event - pause conflicting widgets
|
|
136
|
+
*/
|
|
137
|
+
private handlePlayEvent;
|
|
138
|
+
/**
|
|
139
|
+
* Handle pause event
|
|
140
|
+
*/
|
|
141
|
+
private handlePauseEvent;
|
|
142
|
+
/**
|
|
143
|
+
* Handle stop/ended event
|
|
144
|
+
*/
|
|
145
|
+
private handleStopEvent;
|
|
146
|
+
/**
|
|
147
|
+
* Handle seeking event
|
|
148
|
+
*/
|
|
149
|
+
private handleSeekingEvent;
|
|
150
|
+
/**
|
|
151
|
+
* Handle volume change event
|
|
152
|
+
*/
|
|
153
|
+
private handleVolumeEvent;
|
|
154
|
+
/**
|
|
155
|
+
* Handle track change event (for playlists)
|
|
156
|
+
*/
|
|
157
|
+
private handleTrackChangeEvent;
|
|
158
|
+
/**
|
|
159
|
+
* Handle playlist change event
|
|
160
|
+
*/
|
|
161
|
+
private handlePlaylistChangeEvent;
|
|
162
|
+
/**
|
|
163
|
+
* Pause widgets that conflict with the new playing widget
|
|
164
|
+
*/
|
|
165
|
+
private pauseConflictingWidgets;
|
|
166
|
+
/**
|
|
167
|
+
* Check if simultaneous playback is allowed between media types
|
|
168
|
+
*/
|
|
169
|
+
private isSimultaneousAllowed;
|
|
170
|
+
/**
|
|
171
|
+
* Send pause command to a specific widget
|
|
172
|
+
*/
|
|
173
|
+
private sendPauseCommand;
|
|
174
|
+
/**
|
|
175
|
+
* Get currently playing widgets
|
|
176
|
+
*/
|
|
177
|
+
getPlayingWidgets(): MediaState[];
|
|
178
|
+
/**
|
|
179
|
+
* Get all widgets with media state
|
|
180
|
+
*/
|
|
181
|
+
getAllMediaWidgets(): MediaState[];
|
|
182
|
+
/**
|
|
183
|
+
* Pause all currently playing widgets
|
|
184
|
+
*/
|
|
185
|
+
pauseAll(): void;
|
|
186
|
+
/**
|
|
187
|
+
* Resume the most recently played widget
|
|
188
|
+
*/
|
|
189
|
+
resumeLastPlayed(): void;
|
|
190
|
+
/**
|
|
191
|
+
* Send resume command to a specific widget
|
|
192
|
+
*/
|
|
193
|
+
private sendResumeCommand;
|
|
194
|
+
/**
|
|
195
|
+
* Add event listener for a specific widget
|
|
196
|
+
*/
|
|
197
|
+
addEventListener(compositionId: string, listener: (event: MediaEvent) => void): () => void;
|
|
198
|
+
/**
|
|
199
|
+
* Emit event to widget-specific listeners
|
|
200
|
+
*/
|
|
201
|
+
private emitToListeners;
|
|
202
|
+
/**
|
|
203
|
+
* Dispatch global event
|
|
204
|
+
*/
|
|
205
|
+
private dispatchGlobalEvent;
|
|
206
|
+
/**
|
|
207
|
+
* Load persisted state from localStorage
|
|
208
|
+
*/
|
|
209
|
+
private loadPersistedState;
|
|
210
|
+
/**
|
|
211
|
+
* Persist current state to localStorage with enhanced information
|
|
212
|
+
*/
|
|
213
|
+
private persistState;
|
|
214
|
+
/**
|
|
215
|
+
* Set up page visibility change handler
|
|
216
|
+
*/
|
|
217
|
+
private setupVisibilityHandler;
|
|
218
|
+
/**
|
|
219
|
+
* Set up page unload handler
|
|
220
|
+
*/
|
|
221
|
+
private setupUnloadHandler;
|
|
222
|
+
/**
|
|
223
|
+
* Clear all persisted state including global volume
|
|
224
|
+
*/
|
|
225
|
+
clearPersistedState(includeGlobalVolume?: boolean): void;
|
|
226
|
+
/**
|
|
227
|
+
* Get enhanced media statistics with persistence info
|
|
228
|
+
*/
|
|
229
|
+
getStats(): {
|
|
230
|
+
totalWidgets: number;
|
|
231
|
+
playingWidgets: number;
|
|
232
|
+
pausedWidgets: number;
|
|
233
|
+
registeredWidgets: number;
|
|
234
|
+
widgetsWithPlaylists: number;
|
|
235
|
+
globalVolumeWidgets: number;
|
|
236
|
+
autoResumeEnabled: boolean;
|
|
237
|
+
globalVolumeEnabled: boolean;
|
|
238
|
+
globalVolume: {
|
|
239
|
+
volume: number;
|
|
240
|
+
muted: boolean;
|
|
241
|
+
lastUpdated: number;
|
|
242
|
+
lastChangedBy: string;
|
|
243
|
+
};
|
|
244
|
+
storageVersion: string;
|
|
245
|
+
currentlyPlaying: {
|
|
246
|
+
compositionId: string;
|
|
247
|
+
mediaType: "audio" | "video" | "both";
|
|
248
|
+
priority: number;
|
|
249
|
+
duration: number;
|
|
250
|
+
position: number;
|
|
251
|
+
volume: number;
|
|
252
|
+
playlist: {
|
|
253
|
+
currentTrack: number;
|
|
254
|
+
totalTracks: number;
|
|
255
|
+
trackTitle: string;
|
|
256
|
+
};
|
|
257
|
+
}[];
|
|
258
|
+
allWidgets: {
|
|
259
|
+
compositionId: string;
|
|
260
|
+
state: "playing" | "paused" | "stopped";
|
|
261
|
+
mediaType: "audio" | "video" | "both";
|
|
262
|
+
priority: number;
|
|
263
|
+
position: number;
|
|
264
|
+
volume: number;
|
|
265
|
+
lastInteraction: number;
|
|
266
|
+
playlist: {
|
|
267
|
+
/** Current track index */
|
|
268
|
+
currentTrack: number;
|
|
269
|
+
/** Total tracks in playlist */
|
|
270
|
+
totalTracks: number;
|
|
271
|
+
/** Current track ID/identifier */
|
|
272
|
+
trackId?: string;
|
|
273
|
+
/** Current track title */
|
|
274
|
+
trackTitle?: string;
|
|
275
|
+
/** Playlist ID if applicable */
|
|
276
|
+
playlistId?: string;
|
|
277
|
+
/** Playlist title */
|
|
278
|
+
playlistTitle?: string;
|
|
279
|
+
};
|
|
280
|
+
autoResume: boolean;
|
|
281
|
+
globalVolume: boolean;
|
|
282
|
+
}[];
|
|
283
|
+
};
|
|
284
|
+
/**
|
|
285
|
+
* Cleanup all media management
|
|
286
|
+
*/
|
|
287
|
+
destroy(): void;
|
|
288
|
+
/**
|
|
289
|
+
* Auto-resume widgets that were playing before page refresh
|
|
290
|
+
*/
|
|
291
|
+
private autoResumeWidgets;
|
|
292
|
+
/**
|
|
293
|
+
* Resume a specific widget to its previous state
|
|
294
|
+
*/
|
|
295
|
+
resumeWidget(compositionId: string): boolean;
|
|
296
|
+
/**
|
|
297
|
+
* Send restore state command to a widget
|
|
298
|
+
*/
|
|
299
|
+
private sendRestoreStateCommand;
|
|
300
|
+
/**
|
|
301
|
+
* Send play command with optional position
|
|
302
|
+
*/
|
|
303
|
+
private sendPlayCommand;
|
|
304
|
+
/**
|
|
305
|
+
* Get persisted state for a specific widget
|
|
306
|
+
*/
|
|
307
|
+
getPersistedState(compositionId: string): MediaState | null;
|
|
308
|
+
/**
|
|
309
|
+
* Update widget state (for external state synchronization)
|
|
310
|
+
*/
|
|
311
|
+
updateWidgetState(compositionId: string, stateUpdate: Partial<MediaState>): void;
|
|
312
|
+
/**
|
|
313
|
+
* Enable or disable auto-resume functionality
|
|
314
|
+
*/
|
|
315
|
+
setAutoResumeEnabled(enabled: boolean): void;
|
|
316
|
+
/**
|
|
317
|
+
* Manually trigger auto-resume for eligible widgets
|
|
318
|
+
*/
|
|
319
|
+
triggerAutoResume(options?: ResumeOptions): void;
|
|
320
|
+
/**
|
|
321
|
+
* Load global volume state from localStorage
|
|
322
|
+
*/
|
|
323
|
+
private loadGlobalVolumeState;
|
|
324
|
+
/**
|
|
325
|
+
* Persist global volume state to localStorage
|
|
326
|
+
*/
|
|
327
|
+
private persistGlobalVolumeState;
|
|
328
|
+
/**
|
|
329
|
+
* Sync global volume to all widgets that have global volume enabled
|
|
330
|
+
*/
|
|
331
|
+
private syncGlobalVolumeToWidgets;
|
|
332
|
+
/**
|
|
333
|
+
* Send volume command to a specific widget
|
|
334
|
+
*/
|
|
335
|
+
private sendVolumeCommand;
|
|
336
|
+
/**
|
|
337
|
+
* Get global volume state
|
|
338
|
+
*/
|
|
339
|
+
getGlobalVolumeState(): GlobalVolumeState;
|
|
340
|
+
/**
|
|
341
|
+
* Set global volume (affects all widgets with global volume enabled)
|
|
342
|
+
*/
|
|
343
|
+
setGlobalVolume(volume: number, compositionId?: string): void;
|
|
344
|
+
/**
|
|
345
|
+
* Toggle global mute state
|
|
346
|
+
*/
|
|
347
|
+
toggleGlobalMute(compositionId?: string): boolean;
|
|
348
|
+
/**
|
|
349
|
+
* Enable or disable global volume synchronization
|
|
350
|
+
*/
|
|
351
|
+
setGlobalVolumeEnabled(enabled: boolean): void;
|
|
352
|
+
/**
|
|
353
|
+
* Check if global volume is enabled
|
|
354
|
+
*/
|
|
355
|
+
isGlobalVolumeEnabled(): boolean;
|
|
356
|
+
}
|
|
357
|
+
/**
|
|
358
|
+
* Get global media manager instance
|
|
359
|
+
*/
|
|
360
|
+
export declare function getMediaManager(): MediaManager;
|
|
361
|
+
/**
|
|
362
|
+
* Reset media manager (for testing)
|
|
363
|
+
*/
|
|
364
|
+
export declare function resetMediaManager(): void;
|