@twick/2d 0.14.19 → 0.14.21

package/lib/components/Media.js

@@ -0,0 +1,493 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Media_1;
+import { DependencyContext, PlaybackState, clamp, isReactive, useLogger, useThread, } from '@twick/core';
+import { computed, initial, nodeName, signal } from '../decorators';
+import { Rect } from './Rect';
+const reactivePlaybackRate = `
+The \`playbackRate\` of a \`Video\` cannot be reactive.
+
+Make sure to use a concrete value and not a function:
+
+\`\`\`ts wrong
+video.playbackRate(() => 7);
+\`\`\`
+
+\`\`\`ts correct
+video.playbackRate(7);
+\`\`\`
+
+If you're using a signal, extract its value before passing it to the property:
+
+\`\`\`ts wrong
+video.playbackRate(mySignal);
+\`\`\`
+
+\`\`\`ts correct
+video.playbackRate(mySignal());
+\`\`\`
+`;
+let Media = Media_1 = class Media extends Rect {
+    constructor(props) {
+        super(props);
+        this.lastTime = -1;
+        this.isSchedulingPlay = false;
+        if (!this.awaitCanPlay()) {
+            this.scheduleSeek(this.time());
+        }
+        if (props.play) {
+            this.play();
+        }
+        this.volume = props.volume ?? 1;
+        // Only set volume immediately if media is ready
+        if (!this.awaitCanPlay()) {
+            this.setVolume(this.volume);
+        }
+    }
+    isPlaying() {
+        return this.playing();
+    }
+    getCurrentTime() {
+        return this.clampTime(this.time());
+    }
+    getDuration() {
+        try {
+            const mElement = this.mediaElement();
+            const isVideo = (mElement instanceof HTMLVideoElement);
+            const isAudio = (mElement instanceof HTMLAudioElement);
+            return (this.isIOS() && (isVideo || isAudio)) ? 2 /** dummy duration for iOS */ : mElement.duration;
+        }
+        catch (error) {
+            // If media element is not ready yet, return a default duration
+            return 0;
+        }
+    }
+    getVolume() {
+        return this.volume;
+    }
+    getUrl() {
+        try {
+            return this.mediaElement().src;
+        }
+        catch (error) {
+            // If media element is not ready yet, return the src signal value
+            return this.src();
+        }
+    }
+    dispose() {
+        // Set playing state to false without trying to access media element
+        this.playing(false);
+        this.time.save();
+        this.remove();
+        super.dispose();
+    }
+    completion() {
+        return this.clampTime(this.time()) / this.getDuration();
+    }
+    setCurrentTime(value) {
+        try {
+            const media = this.mediaElement();
+            if (media.readyState < 2)
+                return;
+            media.currentTime = value;
+            this.lastTime = value;
+            if (media.seeking) {
+                DependencyContext.collectPromise(new Promise(resolve => {
+                    const listener = () => {
+                        resolve();
+                        media.removeEventListener('seeked', listener);
+                    };
+                    media.addEventListener('seeked', listener);
+                }));
+            }
+        }
+        catch (error) {
+            // If media element is not ready yet, just update the lastTime
+            this.lastTime = value;
+        }
+    }
+    setVolume(volume) {
+        if (volume < 0) {
+            console.warn(`volumes cannot be negative - the value will be clamped to 0.`);
+        }
+        // Store the volume value
+        this.volume = volume;
+        try {
+            const media = this.mediaElement();
+            media.volume = Math.min(Math.max(volume, 0), 1);
+            if (volume > 1) {
+                if (this.allowVolumeAmplificationInPreview()) {
+                    this.amplify(media, volume);
+                    return;
+                }
+                console.warn(`you have set the volume of node ${this.key} to ${volume} - your video will be exported with the correct volume, but the browser does not support volumes higher than 1 by default. To enable volume amplification in the preview, set the "allowVolumeAmplificationInPreview" of your <Video/> or <Audio/> tag to true. Note that amplification for previews will not work if you use autoplay within the player due to browser autoplay policies: https://developer.chrome.com/blog/autoplay/#webaudio.`);
+            }
+        }
+        catch (error) {
+            // If media element is not ready yet, just store the volume
+            // It will be applied when the media becomes available via collectAsyncResources
+        }
+    }
+    amplify(node, volume) {
+        const key = `${this.src()}/${this.key}`;
+        if (Media_1.amplificationPool[key]) {
+            Media_1.amplificationPool[key].gainNode.gain.value = volume;
+            return;
+        }
+        const audioContext = new AudioContext();
+        const sourceNode = audioContext.createMediaElementSource(node);
+        const gainNode = audioContext.createGain();
+        gainNode.gain.value = volume;
+        sourceNode.connect(gainNode);
+        gainNode.connect(audioContext.destination);
+        Media_1.amplificationPool[key] = { audioContext, sourceNode, gainNode };
+        if (typeof window === 'undefined' || audioContext.state !== 'suspended') {
+            return;
+        }
+        // Start audio context after user interation, neccessary due to browser autoplay policies
+        const handleInteraction = () => {
+            Media_1.amplificationPool[key].audioContext.resume();
+            window.removeEventListener('click', handleInteraction);
+        };
+        window.addEventListener('click', handleInteraction);
+    }
+    setPlaybackRate(playbackRate) {
+        let value;
+        if (isReactive(playbackRate)) {
+            value = playbackRate();
+            useLogger().warn({
+                message: 'Invalid value set as the playback rate',
+                remarks: reactivePlaybackRate,
+                inspect: this.key,
+                stack: new Error().stack,
+            });
+        }
+        else {
+            value = playbackRate;
+        }
+        this.playbackRate.context.setter(value);
+        if (this.playing()) {
+            if (value === 0) {
+                this.pause();
+            }
+            else {
+                const time = useThread().time;
+                const start = time();
+                const offset = this.time();
+                this.time(() => this.clampTime(offset + (time() - start) * value));
+            }
+        }
+    }
+    scheduleSeek(time) {
+        // Defer the media element access to avoid immediate async property access
+        setTimeout(() => {
+            try {
+                const media = this.mediaElement();
+                // Use the existing waitForCanPlay method which handles readiness properly
+                this.waitForCanPlay(media, () => {
+                    // Wait until the media is ready to seek again as
+                    // setting the time before the video doesn't work reliably.
+                    media.currentTime = time;
+                });
+            }
+            catch (error) {
+                // If media element is not ready yet, retry after a longer delay
+                setTimeout(() => this.scheduleSeek(time), 50);
+            }
+        }, 0);
+    }
+    /**
+     * Waits for the canplay event to be fired before calling onCanPlay.
+     *
+     * If the media is already ready to play, onCanPlay is called immediately.
+     * @param onCanPlay - The function to call when the media is ready to play.
+     * @returns
+     */
+    waitForCanPlay(media, onCanPlay) {
+        // Be more strict - require readyState >= 3 (HAVE_FUTURE_DATA) for better reliability
+        if (media.readyState >= 3) {
+            onCanPlay();
+            return;
+        }
+        const onCanPlayWrapper = () => {
+            onCanPlay();
+            media.removeEventListener('canplay', onCanPlayWrapper);
+            media.removeEventListener('canplaythrough', onCanPlayWrapper);
+        };
+        const onError = () => {
+            const reason = this.getErrorReason(media.error?.code);
+            const srcValue = this.src();
+            console.log(`ERROR: Error loading video: src="${srcValue}", ${reason}`);
+            console.log(`Media element src: "${media.src}"`);
+            media.removeEventListener('error', onError);
+            media.removeEventListener('canplay', onCanPlayWrapper);
+            media.removeEventListener('canplaythrough', onCanPlayWrapper);
+        };
+        // Listen for both canplay and canplaythrough events
+        media.addEventListener('canplay', onCanPlayWrapper);
+        media.addEventListener('canplaythrough', onCanPlayWrapper);
+        media.addEventListener('error', onError);
+    }
+    /**
+     * Returns true if we should wait for the media to be ready to play.
+     */
+    waitForCanPlayNecessary(media) {
+        if (media.readyState >= 2) {
+            return false;
+        }
+        return (this.awaitCanPlay() ||
+            this.view().playbackState() === PlaybackState.Rendering);
+    }
+    play() {
+        console.log('=== Media.play() called ===');
+        // Set the playing state first
+        this.playing(true);
+        // Schedule the actual play operation for when media is ready
+        this.schedulePlay();
+    }
+    schedulePlay() {
+        // Prevent recursive calls
+        if (this.isSchedulingPlay) {
+            return;
+        }
+        this.isSchedulingPlay = true;
+        // Check if thread context is available before accessing it
+        let timeFunction = null;
+        try {
+            const time = useThread().time;
+            timeFunction = time;
+        }
+        catch (error) {
+            // Reset flag and use simple play without thread time
+            this.isSchedulingPlay = false;
+            this.simplePlay();
+            return;
+        }
+        // We need to wait for the media to be ready before we can play it
+        // Use a setTimeout to defer the operation and avoid immediate async property access
+        setTimeout(() => {
+            // Check if we're still supposed to be playing (avoid race conditions)
+            const isPlaying = this.playing();
+            if (!isPlaying) {
+                this.isSchedulingPlay = false;
+                return;
+            }
+            // Add another timeout to further defer media element access
+            setTimeout(() => {
+                try {
+                    const media = this.mediaElement();
+                    // Always use waitForCanPlay to ensure media is ready
+                    this.waitForCanPlay(media, () => {
+                        // Double-check we're still playing before calling actuallyPlay
+                        if (this.playing() && timeFunction) {
+                            this.actuallyPlay(media, timeFunction);
+                        }
+                        // Reset the flag when done
+                        this.isSchedulingPlay = false;
+                    });
+                }
+                catch (error) {
+                    // Reset flag before retry
+                    this.isSchedulingPlay = false;
+                    // If media is not ready yet, retry after a longer delay
+                    setTimeout(() => this.schedulePlay(), 100);
+                }
+            }, 10);
+        }, 0);
+    }
+    simplePlay() {
+        setTimeout(() => {
+            try {
+                const media = this.mediaElement();
+                // Guard against undefined src
+                if (!media.src || media.src.includes('undefined')) {
+                    return;
+                }
+                if (media.paused && this.playing()) {
+                    media.playbackRate = this.playbackRate();
+                    const playPromise = media.play();
+                    if (playPromise !== undefined) {
+                        playPromise.then(() => {
+                            console.log('Simple play started successfully');
+                        }).catch(error => {
+                            if (error.name !== 'AbortError') {
+                                console.warn('Error in simple play:', error);
+                            }
+                            this.playing(false);
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Stop retries for errors
+                return;
+            }
+        }, 10);
+    }
+    actuallyPlay(media, timeFunction) {
+        console.log('=== actuallyPlay called ===');
+        console.log('Media element:', media);
+        console.log('Media src:', media.src);
+        console.log('Media paused:', media.paused);
+        console.log('Media readyState:', media.readyState);
+        // Make sure we're still supposed to be playing
+        if (!this.playing()) {
+            console.log('Playing state is false, aborting actuallyPlay');
+            return;
+        }
+        // Set playback rate on media element
+        media.playbackRate = this.playbackRate();
+        // Ensure the media is ready to play
+        if (media.paused) {
+            console.log('Media is paused, calling play()');
+            // Start playing the media element
+            const playPromise = media.play();
+            if (playPromise !== undefined) {
+                playPromise.then(() => {
+                    console.log('Media play() promise resolved - should be playing now');
+                    console.log('Post-play media paused:', media.paused);
+                    console.log('Post-play media currentTime:', media.currentTime);
+                }).catch(error => {
+                    // Don't warn about AbortError - it's normal when play() is interrupted by pause()
+                    if (error.name !== 'AbortError') {
+                        console.warn('Error playing media:', error);
+                    }
+                    this.playing(false);
+                });
+            }
+        }
+        else {
+            console.log('Media is already playing');
+        }
+        // Set up time synchronization
+        const start = timeFunction();
+        const offset = media.currentTime;
+        // Update time signal
+        this.time(() => {
+            const newTime = this.clampTime(offset + (timeFunction() - start) * this.playbackRate());
+            return newTime;
+        });
+    }
+    pause() {
+        // Set the playing state first
+        this.playing(false);
+        this.time.save();
+        // Try to pause the media element if it's available
+        // Use setTimeout to defer access and avoid async property issues
+        setTimeout(() => {
+            try {
+                const media = this.mediaElement();
+                media.pause();
+            }
+            catch (error) {
+                // If media element is not ready yet, just update the state
+                // The media won't be playing anyway if it's not ready
+            }
+        }, 0);
+    }
+    clampTime(time) {
+        const duration = this.getDuration();
+        if (this.loop()) {
+            time %= duration;
+        }
+        return clamp(0, duration, time);
+    }
+    collectAsyncResources() {
+        super.collectAsyncResources();
+        this.seekedMedia();
+        // Ensure volume is set when media becomes available
+        this.setVolume(this.volume);
+    }
+    autoPlayBasedOnTwick() {
+        // Auto-start/stop playback based on Twick's playback state
+        const playbackState = this.view().playbackState();
+        // console.log('autoPlayBasedOnTwick called:', {
+        //   playbackState,
+        //   currentlyPlaying: this.playing(),
+        //   shouldAutoPlay: (playbackState === PlaybackState.Playing || playbackState === PlaybackState.Presenting) && !this.playing(),
+        //   shouldAutoPause: playbackState === PlaybackState.Paused && this.playing()
+        // });
+        if ((playbackState === PlaybackState.Playing || playbackState === PlaybackState.Presenting) && !this.playing()) {
+            console.log('Auto-starting media playback via play() method');
+            this.play(); // Call the full play() method instead of just setting playing(true)
+        }
+        else if (playbackState === PlaybackState.Paused && this.playing()) {
+            console.log('Auto-pausing media playback via pause() method');
+            this.pause(); // Call the full pause() method
+        }
+    }
+    getErrorReason(errCode) {
+        let reason;
+        switch (errCode) {
+            case 1:
+                reason = 'MEDIA_ERR_ABORTED';
+                break;
+            case 2:
+                reason = 'MEDIA_ERR_NETWORK. This might be a 404 error.';
+                break;
+            case 3:
+                reason =
+                    'MEDIA_ERR_DECODE. This might be an issue with your video file.';
+                break;
+            case 4:
+                reason =
+                    'MEDIA_ERR_SRC_NOT_SUPPORTED. If you are sure that the path to the video is correct, this might be a CORS error.';
+                break;
+            default:
+                reason = 'UNKNOWN';
+        }
+        return reason;
+    }
+    // Helper method to check if running on iOS
+    isIOS() {
+        if (typeof navigator === 'undefined')
+            return false;
+        const isIos = /iPad|iPhone|iPod/.test(navigator.userAgent) ||
+            (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
+        return isIos;
+    }
+};
+Media.amplificationPool = {};
+__decorate([
+    initial(''),
+    signal()
+], Media.prototype, "src", void 0);
+__decorate([
+    initial(false),
+    signal()
+], Media.prototype, "loop", void 0);
+__decorate([
+    initial(1),
+    signal()
+], Media.prototype, "playbackRate", void 0);
+__decorate([
+    initial(0),
+    signal()
+], Media.prototype, "time", void 0);
+__decorate([
+    initial(false),
+    signal()
+], Media.prototype, "playing", void 0);
+__decorate([
+    initial(true),
+    signal()
+], Media.prototype, "awaitCanPlay", void 0);
+__decorate([
+    initial(false),
+    signal()
+], Media.prototype, "allowVolumeAmplificationInPreview", void 0);
+__decorate([
+    computed()
+], Media.prototype, "completion", null);
+__decorate([
+    computed()
+], Media.prototype, "amplify", null);
+Media = Media_1 = __decorate([
+    nodeName('Media')
+], Media);
+export { Media };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Media.js","sourceRoot":"","sources":["../../src/lib/components/Media.ts"],"names":[],"mappings":"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"}