@remotion/promo-pages 4.0.486 → 4.0.487
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/dist/Homepage.css +1 -1
- package/dist/Homepage.js +903 -2076
- package/dist/design.js +153 -76
- package/dist/experts.js +153 -76
- package/dist/homepage/Pricing.js +176 -83
- package/dist/prompts/PromptsGallery.js +153 -76
- package/dist/prompts/PromptsShow.js +153 -76
- package/dist/prompts/PromptsSubmit.js +153 -76
- package/dist/tailwind.css +21 -3
- package/dist/team.js +153 -76
- package/dist/template-modal-content.css +1 -1
- package/dist/template-modal-content.js +153 -76
- package/dist/templates.js +153 -76
- package/package.json +17 -17
- package/public/img/editing-safari.mp4 +0 -0
- package/public/img/editing-vp9-chrome.webm +0 -0
- package/public/img/homepage-assets-master.mp4 +0 -0
- package/public/img/homepage-assets-master.webm +0 -0
- package/public/img/what-is-remotion.mp4 +0 -0
- package/public/img/what-is-remotion.webm +0 -0
|
@@ -22899,7 +22899,7 @@ var getComponentsToAddStacksTo = () => componentsToAddStacksTo;
|
|
|
22899
22899
|
var addSequenceStackTraces = (component) => {
|
|
22900
22900
|
componentsToAddStacksTo.push(component);
|
|
22901
22901
|
};
|
|
22902
|
-
var VERSION = "4.0.
|
|
22902
|
+
var VERSION = "4.0.487";
|
|
22903
22903
|
var checkMultipleRemotionVersions = () => {
|
|
22904
22904
|
if (typeof globalThis === "undefined") {
|
|
22905
22905
|
return;
|
|
@@ -28769,7 +28769,8 @@ var useBufferManager = (logLevel, mountTime) => {
|
|
|
28769
28769
|
if (rendering) {
|
|
28770
28770
|
return;
|
|
28771
28771
|
}
|
|
28772
|
-
if (blocks.length > 0) {
|
|
28772
|
+
if (blocks.length > 0 && !buffering.current) {
|
|
28773
|
+
buffering.current = true;
|
|
28773
28774
|
onBufferingCallbacks.forEach((c2) => c2());
|
|
28774
28775
|
playbackLogging({
|
|
28775
28776
|
logLevel,
|
|
@@ -28784,7 +28785,8 @@ var useBufferManager = (logLevel, mountTime) => {
|
|
|
28784
28785
|
if (rendering) {
|
|
28785
28786
|
return;
|
|
28786
28787
|
}
|
|
28787
|
-
if (blocks.length === 0) {
|
|
28788
|
+
if (blocks.length === 0 && buffering.current) {
|
|
28789
|
+
buffering.current = false;
|
|
28788
28790
|
onResumeCallbacks.forEach((c2) => c2());
|
|
28789
28791
|
playbackLogging({
|
|
28790
28792
|
logLevel,
|
|
@@ -28817,15 +28819,11 @@ var useIsPlayerBuffering = (bufferManager) => {
|
|
|
28817
28819
|
const onResume = () => {
|
|
28818
28820
|
setIsBuffering(false);
|
|
28819
28821
|
};
|
|
28820
|
-
bufferManager.listenForBuffering(onBuffer);
|
|
28821
|
-
bufferManager.listenForResume(onResume);
|
|
28822
|
+
const buffer = bufferManager.listenForBuffering(onBuffer);
|
|
28823
|
+
const resume = bufferManager.listenForResume(onResume);
|
|
28822
28824
|
return () => {
|
|
28823
|
-
|
|
28824
|
-
|
|
28825
|
-
});
|
|
28826
|
-
bufferManager.listenForResume(() => {
|
|
28827
|
-
return;
|
|
28828
|
-
});
|
|
28825
|
+
buffer.remove();
|
|
28826
|
+
resume.remove();
|
|
28829
28827
|
};
|
|
28830
28828
|
}, [bufferManager]);
|
|
28831
28829
|
return isBuffering;
|
|
@@ -28949,6 +28947,72 @@ var useBufferUntilFirstFrame = ({
|
|
|
28949
28947
|
};
|
|
28950
28948
|
}, [bufferUntilFirstFrame]);
|
|
28951
28949
|
};
|
|
28950
|
+
var getMediaSyncAction = (input) => {
|
|
28951
|
+
const {
|
|
28952
|
+
duration,
|
|
28953
|
+
currentTime,
|
|
28954
|
+
paused,
|
|
28955
|
+
ended,
|
|
28956
|
+
desiredUnclampedTime,
|
|
28957
|
+
mediaTagTime,
|
|
28958
|
+
mediaTagLastUpdate,
|
|
28959
|
+
rvcTime,
|
|
28960
|
+
rvcLastUpdate,
|
|
28961
|
+
isVariableFpsVideo,
|
|
28962
|
+
acceptableTimeShift,
|
|
28963
|
+
lastSeekDueToShift,
|
|
28964
|
+
playing,
|
|
28965
|
+
playbackRate,
|
|
28966
|
+
mediaTagBufferingOrStalled,
|
|
28967
|
+
playerBuffering,
|
|
28968
|
+
absoluteFrame,
|
|
28969
|
+
onlyWarnForMediaSeekingError,
|
|
28970
|
+
isPremounting,
|
|
28971
|
+
isPostmounting,
|
|
28972
|
+
pauseWhenBuffering
|
|
28973
|
+
} = input;
|
|
28974
|
+
const shouldBeTime = !Number.isNaN(duration) && Number.isFinite(duration) ? Math.min(duration, desiredUnclampedTime) : desiredUnclampedTime;
|
|
28975
|
+
const timeShiftMediaTag = Math.abs(shouldBeTime - mediaTagTime);
|
|
28976
|
+
const timeShiftRvcTag = rvcTime ? Math.abs(shouldBeTime - rvcTime) : null;
|
|
28977
|
+
const mostRecentTimeshift = rvcLastUpdate && rvcTime > mediaTagLastUpdate ? timeShiftRvcTag : timeShiftMediaTag;
|
|
28978
|
+
const timeShift = timeShiftRvcTag && !isVariableFpsVideo ? mostRecentTimeshift : timeShiftMediaTag;
|
|
28979
|
+
if (timeShift > acceptableTimeShift && lastSeekDueToShift !== shouldBeTime) {
|
|
28980
|
+
return {
|
|
28981
|
+
type: "seek-due-to-shift",
|
|
28982
|
+
shouldBeTime,
|
|
28983
|
+
why: `because time shift is too big. shouldBeTime = ${shouldBeTime}, isTime = ${mediaTagTime}, requestVideoCallbackTime = ${rvcTime}, timeShift = ${timeShift}${isVariableFpsVideo ? ", isVariableFpsVideo = true" : ""}, isPremounting = ${isPremounting}, isPostmounting = ${isPostmounting}, pauseWhenBuffering = ${pauseWhenBuffering}`,
|
|
28984
|
+
bufferUntilFirstFrame: playing && playbackRate > 0,
|
|
28985
|
+
playReason: playing && paused ? "player is playing but media tag is paused, and just seeked" : null,
|
|
28986
|
+
warnAboutNonSeekable: !onlyWarnForMediaSeekingError
|
|
28987
|
+
};
|
|
28988
|
+
}
|
|
28989
|
+
const seekThreshold = playing ? 0.15 : 0.01;
|
|
28990
|
+
const makesSenseToSeek = Math.abs(currentTime - shouldBeTime) > seekThreshold;
|
|
28991
|
+
const isSomethingElseBuffering = playerBuffering && !mediaTagBufferingOrStalled;
|
|
28992
|
+
if (!playing || isSomethingElseBuffering) {
|
|
28993
|
+
return {
|
|
28994
|
+
type: "seek-if-not-playing",
|
|
28995
|
+
shouldBeTime,
|
|
28996
|
+
why: makesSenseToSeek ? `not playing or something else is buffering. time offset is over seek threshold (${seekThreshold})` : null
|
|
28997
|
+
};
|
|
28998
|
+
}
|
|
28999
|
+
if (!playing || playerBuffering) {
|
|
29000
|
+
return { type: "none" };
|
|
29001
|
+
}
|
|
29002
|
+
const pausedCondition = paused && !ended;
|
|
29003
|
+
const firstFrameCondition = absoluteFrame === 0;
|
|
29004
|
+
if (pausedCondition || firstFrameCondition) {
|
|
29005
|
+
const reason = pausedCondition ? "media tag is paused" : "absolute frame is 0";
|
|
29006
|
+
return {
|
|
29007
|
+
type: "play-and-seek",
|
|
29008
|
+
shouldBeTime,
|
|
29009
|
+
why: makesSenseToSeek ? `is over timeshift threshold (threshold = ${seekThreshold}) and ${reason}` : null,
|
|
29010
|
+
playReason: `player is playing and ${reason}`,
|
|
29011
|
+
bufferUntilFirstFrame: !isVariableFpsVideo && playbackRate > 0
|
|
29012
|
+
};
|
|
29013
|
+
}
|
|
29014
|
+
return { type: "none" };
|
|
29015
|
+
};
|
|
28952
29016
|
var useCurrentTimeOfMediaTagWithUpdateTimeStamp = (mediaRef) => {
|
|
28953
29017
|
const lastUpdate = React21.useRef({
|
|
28954
29018
|
time: mediaRef.current?.currentTime ?? 0,
|
|
@@ -29368,89 +29432,93 @@ var useMediaPlayback = ({
|
|
|
29368
29432
|
if (!src) {
|
|
29369
29433
|
throw new Error(`No 'src' attribute was passed to the ${tagName} element.`);
|
|
29370
29434
|
}
|
|
29371
|
-
const {
|
|
29372
|
-
const
|
|
29373
|
-
|
|
29374
|
-
|
|
29375
|
-
|
|
29376
|
-
|
|
29377
|
-
|
|
29378
|
-
|
|
29379
|
-
|
|
29380
|
-
|
|
29435
|
+
const { current } = mediaRef;
|
|
29436
|
+
const action = getMediaSyncAction({
|
|
29437
|
+
duration: current.duration,
|
|
29438
|
+
currentTime: current.currentTime,
|
|
29439
|
+
paused: current.paused,
|
|
29440
|
+
ended: current.ended,
|
|
29441
|
+
desiredUnclampedTime,
|
|
29442
|
+
mediaTagTime: mediaTagCurrentTime.current.time,
|
|
29443
|
+
mediaTagLastUpdate: mediaTagCurrentTime.current.lastUpdate,
|
|
29444
|
+
rvcTime: rvcCurrentTime.current?.time ?? null,
|
|
29445
|
+
rvcLastUpdate: rvcCurrentTime.current?.lastUpdate ?? null,
|
|
29446
|
+
isVariableFpsVideo: Boolean(isVariableFpsVideoMap.current[src]),
|
|
29447
|
+
acceptableTimeShift: acceptableTimeShiftButLessThanDuration,
|
|
29448
|
+
lastSeekDueToShift: lastSeekDueToShift.current,
|
|
29449
|
+
playing,
|
|
29450
|
+
playbackRate,
|
|
29451
|
+
mediaTagBufferingOrStalled: isMediaTagBuffering || isBuffering(),
|
|
29452
|
+
playerBuffering: buffering.buffering.current,
|
|
29453
|
+
absoluteFrame,
|
|
29454
|
+
onlyWarnForMediaSeekingError,
|
|
29455
|
+
isPremounting,
|
|
29456
|
+
isPostmounting,
|
|
29457
|
+
pauseWhenBuffering
|
|
29458
|
+
});
|
|
29459
|
+
if (action.type === "none") {
|
|
29460
|
+
return;
|
|
29461
|
+
}
|
|
29462
|
+
if (action.type === "seek-due-to-shift") {
|
|
29381
29463
|
lastSeek.current = seek({
|
|
29382
|
-
mediaRef:
|
|
29383
|
-
time: shouldBeTime,
|
|
29464
|
+
mediaRef: current,
|
|
29465
|
+
time: action.shouldBeTime,
|
|
29384
29466
|
logLevel,
|
|
29385
|
-
why:
|
|
29467
|
+
why: action.why,
|
|
29386
29468
|
mountTime
|
|
29387
29469
|
});
|
|
29388
29470
|
lastSeekDueToShift.current = lastSeek.current;
|
|
29389
|
-
if (
|
|
29390
|
-
|
|
29391
|
-
bufferUntilFirstFrame(shouldBeTime);
|
|
29392
|
-
}
|
|
29393
|
-
if (mediaRef.current.paused) {
|
|
29394
|
-
playAndHandleNotAllowedError({
|
|
29395
|
-
mediaRef,
|
|
29396
|
-
mediaType,
|
|
29397
|
-
onAutoPlayError,
|
|
29398
|
-
logLevel,
|
|
29399
|
-
mountTime,
|
|
29400
|
-
reason: "player is playing but media tag is paused, and just seeked",
|
|
29401
|
-
isPlayer: env.isPlayer
|
|
29402
|
-
});
|
|
29403
|
-
}
|
|
29404
|
-
}
|
|
29405
|
-
if (!onlyWarnForMediaSeekingError) {
|
|
29406
|
-
warnAboutNonSeekableMedia(mediaRef.current, onlyWarnForMediaSeekingError ? "console-warning" : "console-error");
|
|
29471
|
+
if (action.bufferUntilFirstFrame) {
|
|
29472
|
+
bufferUntilFirstFrame(action.shouldBeTime);
|
|
29407
29473
|
}
|
|
29408
|
-
|
|
29409
|
-
|
|
29410
|
-
|
|
29411
|
-
|
|
29412
|
-
|
|
29413
|
-
const isSomethingElseBuffering = buffering.buffering.current && !isMediaTagBufferingOrStalled;
|
|
29414
|
-
if (!playing || isSomethingElseBuffering) {
|
|
29415
|
-
if (makesSenseToSeek) {
|
|
29416
|
-
lastSeek.current = seek({
|
|
29417
|
-
mediaRef: mediaRef.current,
|
|
29418
|
-
time: shouldBeTime,
|
|
29474
|
+
if (action.playReason !== null) {
|
|
29475
|
+
playAndHandleNotAllowedError({
|
|
29476
|
+
mediaRef,
|
|
29477
|
+
mediaType,
|
|
29478
|
+
onAutoPlayError,
|
|
29419
29479
|
logLevel,
|
|
29420
|
-
|
|
29421
|
-
|
|
29480
|
+
mountTime,
|
|
29481
|
+
reason: action.playReason,
|
|
29482
|
+
isPlayer: env.isPlayer
|
|
29422
29483
|
});
|
|
29423
29484
|
}
|
|
29485
|
+
if (action.warnAboutNonSeekable) {
|
|
29486
|
+
warnAboutNonSeekableMedia(current, "console-error");
|
|
29487
|
+
}
|
|
29424
29488
|
return;
|
|
29425
29489
|
}
|
|
29426
|
-
if (
|
|
29427
|
-
|
|
29428
|
-
}
|
|
29429
|
-
const pausedCondition = mediaRef.current.paused && !mediaRef.current.ended;
|
|
29430
|
-
const firstFrameCondition = absoluteFrame === 0;
|
|
29431
|
-
if (pausedCondition || firstFrameCondition) {
|
|
29432
|
-
const reason = pausedCondition ? "media tag is paused" : "absolute frame is 0";
|
|
29433
|
-
if (makesSenseToSeek) {
|
|
29490
|
+
if (action.type === "seek-if-not-playing") {
|
|
29491
|
+
if (action.why !== null) {
|
|
29434
29492
|
lastSeek.current = seek({
|
|
29435
|
-
mediaRef:
|
|
29436
|
-
time: shouldBeTime,
|
|
29493
|
+
mediaRef: current,
|
|
29494
|
+
time: action.shouldBeTime,
|
|
29437
29495
|
logLevel,
|
|
29438
|
-
why:
|
|
29496
|
+
why: action.why,
|
|
29439
29497
|
mountTime
|
|
29440
29498
|
});
|
|
29441
29499
|
}
|
|
29442
|
-
|
|
29443
|
-
|
|
29444
|
-
|
|
29445
|
-
|
|
29500
|
+
return;
|
|
29501
|
+
}
|
|
29502
|
+
if (action.why !== null) {
|
|
29503
|
+
lastSeek.current = seek({
|
|
29504
|
+
mediaRef: current,
|
|
29505
|
+
time: action.shouldBeTime,
|
|
29446
29506
|
logLevel,
|
|
29447
|
-
|
|
29448
|
-
|
|
29449
|
-
isPlayer: env.isPlayer
|
|
29507
|
+
why: action.why,
|
|
29508
|
+
mountTime
|
|
29450
29509
|
});
|
|
29451
|
-
|
|
29452
|
-
|
|
29453
|
-
|
|
29510
|
+
}
|
|
29511
|
+
playAndHandleNotAllowedError({
|
|
29512
|
+
mediaRef,
|
|
29513
|
+
mediaType,
|
|
29514
|
+
onAutoPlayError,
|
|
29515
|
+
logLevel,
|
|
29516
|
+
mountTime,
|
|
29517
|
+
reason: action.playReason,
|
|
29518
|
+
isPlayer: env.isPlayer
|
|
29519
|
+
});
|
|
29520
|
+
if (action.bufferUntilFirstFrame) {
|
|
29521
|
+
bufferUntilFirstFrame(action.shouldBeTime);
|
|
29454
29522
|
}
|
|
29455
29523
|
}, [
|
|
29456
29524
|
absoluteFrame,
|
|
@@ -32974,6 +33042,15 @@ var staticFile = (path) => {
|
|
|
32974
33042
|
}
|
|
32975
33043
|
return preparsed;
|
|
32976
33044
|
};
|
|
33045
|
+
var Still = (props2) => {
|
|
33046
|
+
const newProps = {
|
|
33047
|
+
...props2,
|
|
33048
|
+
durationInFrames: 1,
|
|
33049
|
+
fps: 1
|
|
33050
|
+
};
|
|
33051
|
+
return React42.createElement(Composition, newProps);
|
|
33052
|
+
};
|
|
33053
|
+
addSequenceStackTraces(Still);
|
|
32977
33054
|
var roundTo6Commas = (num) => {
|
|
32978
33055
|
return Math.round(num * 1e5) / 1e5;
|
|
32979
33056
|
};
|
|
@@ -5565,7 +5565,7 @@ var getComponentsToAddStacksTo = () => componentsToAddStacksTo;
|
|
|
5565
5565
|
var addSequenceStackTraces = (component) => {
|
|
5566
5566
|
componentsToAddStacksTo.push(component);
|
|
5567
5567
|
};
|
|
5568
|
-
var VERSION = "4.0.
|
|
5568
|
+
var VERSION = "4.0.487";
|
|
5569
5569
|
var checkMultipleRemotionVersions = () => {
|
|
5570
5570
|
if (typeof globalThis === "undefined") {
|
|
5571
5571
|
return;
|
|
@@ -11435,7 +11435,8 @@ var useBufferManager = (logLevel, mountTime) => {
|
|
|
11435
11435
|
if (rendering) {
|
|
11436
11436
|
return;
|
|
11437
11437
|
}
|
|
11438
|
-
if (blocks.length > 0) {
|
|
11438
|
+
if (blocks.length > 0 && !buffering.current) {
|
|
11439
|
+
buffering.current = true;
|
|
11439
11440
|
onBufferingCallbacks.forEach((c2) => c2());
|
|
11440
11441
|
playbackLogging({
|
|
11441
11442
|
logLevel,
|
|
@@ -11450,7 +11451,8 @@ var useBufferManager = (logLevel, mountTime) => {
|
|
|
11450
11451
|
if (rendering) {
|
|
11451
11452
|
return;
|
|
11452
11453
|
}
|
|
11453
|
-
if (blocks.length === 0) {
|
|
11454
|
+
if (blocks.length === 0 && buffering.current) {
|
|
11455
|
+
buffering.current = false;
|
|
11454
11456
|
onResumeCallbacks.forEach((c2) => c2());
|
|
11455
11457
|
playbackLogging({
|
|
11456
11458
|
logLevel,
|
|
@@ -11483,15 +11485,11 @@ var useIsPlayerBuffering = (bufferManager) => {
|
|
|
11483
11485
|
const onResume = () => {
|
|
11484
11486
|
setIsBuffering(false);
|
|
11485
11487
|
};
|
|
11486
|
-
bufferManager.listenForBuffering(onBuffer);
|
|
11487
|
-
bufferManager.listenForResume(onResume);
|
|
11488
|
+
const buffer = bufferManager.listenForBuffering(onBuffer);
|
|
11489
|
+
const resume = bufferManager.listenForResume(onResume);
|
|
11488
11490
|
return () => {
|
|
11489
|
-
|
|
11490
|
-
|
|
11491
|
-
});
|
|
11492
|
-
bufferManager.listenForResume(() => {
|
|
11493
|
-
return;
|
|
11494
|
-
});
|
|
11491
|
+
buffer.remove();
|
|
11492
|
+
resume.remove();
|
|
11495
11493
|
};
|
|
11496
11494
|
}, [bufferManager]);
|
|
11497
11495
|
return isBuffering;
|
|
@@ -11615,6 +11613,72 @@ var useBufferUntilFirstFrame = ({
|
|
|
11615
11613
|
};
|
|
11616
11614
|
}, [bufferUntilFirstFrame]);
|
|
11617
11615
|
};
|
|
11616
|
+
var getMediaSyncAction = (input) => {
|
|
11617
|
+
const {
|
|
11618
|
+
duration,
|
|
11619
|
+
currentTime,
|
|
11620
|
+
paused,
|
|
11621
|
+
ended,
|
|
11622
|
+
desiredUnclampedTime,
|
|
11623
|
+
mediaTagTime,
|
|
11624
|
+
mediaTagLastUpdate,
|
|
11625
|
+
rvcTime,
|
|
11626
|
+
rvcLastUpdate,
|
|
11627
|
+
isVariableFpsVideo,
|
|
11628
|
+
acceptableTimeShift,
|
|
11629
|
+
lastSeekDueToShift,
|
|
11630
|
+
playing,
|
|
11631
|
+
playbackRate,
|
|
11632
|
+
mediaTagBufferingOrStalled,
|
|
11633
|
+
playerBuffering,
|
|
11634
|
+
absoluteFrame,
|
|
11635
|
+
onlyWarnForMediaSeekingError,
|
|
11636
|
+
isPremounting,
|
|
11637
|
+
isPostmounting,
|
|
11638
|
+
pauseWhenBuffering
|
|
11639
|
+
} = input;
|
|
11640
|
+
const shouldBeTime = !Number.isNaN(duration) && Number.isFinite(duration) ? Math.min(duration, desiredUnclampedTime) : desiredUnclampedTime;
|
|
11641
|
+
const timeShiftMediaTag = Math.abs(shouldBeTime - mediaTagTime);
|
|
11642
|
+
const timeShiftRvcTag = rvcTime ? Math.abs(shouldBeTime - rvcTime) : null;
|
|
11643
|
+
const mostRecentTimeshift = rvcLastUpdate && rvcTime > mediaTagLastUpdate ? timeShiftRvcTag : timeShiftMediaTag;
|
|
11644
|
+
const timeShift = timeShiftRvcTag && !isVariableFpsVideo ? mostRecentTimeshift : timeShiftMediaTag;
|
|
11645
|
+
if (timeShift > acceptableTimeShift && lastSeekDueToShift !== shouldBeTime) {
|
|
11646
|
+
return {
|
|
11647
|
+
type: "seek-due-to-shift",
|
|
11648
|
+
shouldBeTime,
|
|
11649
|
+
why: `because time shift is too big. shouldBeTime = ${shouldBeTime}, isTime = ${mediaTagTime}, requestVideoCallbackTime = ${rvcTime}, timeShift = ${timeShift}${isVariableFpsVideo ? ", isVariableFpsVideo = true" : ""}, isPremounting = ${isPremounting}, isPostmounting = ${isPostmounting}, pauseWhenBuffering = ${pauseWhenBuffering}`,
|
|
11650
|
+
bufferUntilFirstFrame: playing && playbackRate > 0,
|
|
11651
|
+
playReason: playing && paused ? "player is playing but media tag is paused, and just seeked" : null,
|
|
11652
|
+
warnAboutNonSeekable: !onlyWarnForMediaSeekingError
|
|
11653
|
+
};
|
|
11654
|
+
}
|
|
11655
|
+
const seekThreshold = playing ? 0.15 : 0.01;
|
|
11656
|
+
const makesSenseToSeek = Math.abs(currentTime - shouldBeTime) > seekThreshold;
|
|
11657
|
+
const isSomethingElseBuffering = playerBuffering && !mediaTagBufferingOrStalled;
|
|
11658
|
+
if (!playing || isSomethingElseBuffering) {
|
|
11659
|
+
return {
|
|
11660
|
+
type: "seek-if-not-playing",
|
|
11661
|
+
shouldBeTime,
|
|
11662
|
+
why: makesSenseToSeek ? `not playing or something else is buffering. time offset is over seek threshold (${seekThreshold})` : null
|
|
11663
|
+
};
|
|
11664
|
+
}
|
|
11665
|
+
if (!playing || playerBuffering) {
|
|
11666
|
+
return { type: "none" };
|
|
11667
|
+
}
|
|
11668
|
+
const pausedCondition = paused && !ended;
|
|
11669
|
+
const firstFrameCondition = absoluteFrame === 0;
|
|
11670
|
+
if (pausedCondition || firstFrameCondition) {
|
|
11671
|
+
const reason = pausedCondition ? "media tag is paused" : "absolute frame is 0";
|
|
11672
|
+
return {
|
|
11673
|
+
type: "play-and-seek",
|
|
11674
|
+
shouldBeTime,
|
|
11675
|
+
why: makesSenseToSeek ? `is over timeshift threshold (threshold = ${seekThreshold}) and ${reason}` : null,
|
|
11676
|
+
playReason: `player is playing and ${reason}`,
|
|
11677
|
+
bufferUntilFirstFrame: !isVariableFpsVideo && playbackRate > 0
|
|
11678
|
+
};
|
|
11679
|
+
}
|
|
11680
|
+
return { type: "none" };
|
|
11681
|
+
};
|
|
11618
11682
|
var useCurrentTimeOfMediaTagWithUpdateTimeStamp = (mediaRef) => {
|
|
11619
11683
|
const lastUpdate = React21.useRef({
|
|
11620
11684
|
time: mediaRef.current?.currentTime ?? 0,
|
|
@@ -12034,89 +12098,93 @@ var useMediaPlayback = ({
|
|
|
12034
12098
|
if (!src) {
|
|
12035
12099
|
throw new Error(`No 'src' attribute was passed to the ${tagName} element.`);
|
|
12036
12100
|
}
|
|
12037
|
-
const {
|
|
12038
|
-
const
|
|
12039
|
-
|
|
12040
|
-
|
|
12041
|
-
|
|
12042
|
-
|
|
12043
|
-
|
|
12044
|
-
|
|
12045
|
-
|
|
12046
|
-
|
|
12101
|
+
const { current } = mediaRef;
|
|
12102
|
+
const action = getMediaSyncAction({
|
|
12103
|
+
duration: current.duration,
|
|
12104
|
+
currentTime: current.currentTime,
|
|
12105
|
+
paused: current.paused,
|
|
12106
|
+
ended: current.ended,
|
|
12107
|
+
desiredUnclampedTime,
|
|
12108
|
+
mediaTagTime: mediaTagCurrentTime.current.time,
|
|
12109
|
+
mediaTagLastUpdate: mediaTagCurrentTime.current.lastUpdate,
|
|
12110
|
+
rvcTime: rvcCurrentTime.current?.time ?? null,
|
|
12111
|
+
rvcLastUpdate: rvcCurrentTime.current?.lastUpdate ?? null,
|
|
12112
|
+
isVariableFpsVideo: Boolean(isVariableFpsVideoMap.current[src]),
|
|
12113
|
+
acceptableTimeShift: acceptableTimeShiftButLessThanDuration,
|
|
12114
|
+
lastSeekDueToShift: lastSeekDueToShift.current,
|
|
12115
|
+
playing,
|
|
12116
|
+
playbackRate,
|
|
12117
|
+
mediaTagBufferingOrStalled: isMediaTagBuffering || isBuffering(),
|
|
12118
|
+
playerBuffering: buffering.buffering.current,
|
|
12119
|
+
absoluteFrame,
|
|
12120
|
+
onlyWarnForMediaSeekingError,
|
|
12121
|
+
isPremounting,
|
|
12122
|
+
isPostmounting,
|
|
12123
|
+
pauseWhenBuffering
|
|
12124
|
+
});
|
|
12125
|
+
if (action.type === "none") {
|
|
12126
|
+
return;
|
|
12127
|
+
}
|
|
12128
|
+
if (action.type === "seek-due-to-shift") {
|
|
12047
12129
|
lastSeek.current = seek({
|
|
12048
|
-
mediaRef:
|
|
12049
|
-
time: shouldBeTime,
|
|
12130
|
+
mediaRef: current,
|
|
12131
|
+
time: action.shouldBeTime,
|
|
12050
12132
|
logLevel,
|
|
12051
|
-
why:
|
|
12133
|
+
why: action.why,
|
|
12052
12134
|
mountTime
|
|
12053
12135
|
});
|
|
12054
12136
|
lastSeekDueToShift.current = lastSeek.current;
|
|
12055
|
-
if (
|
|
12056
|
-
|
|
12057
|
-
bufferUntilFirstFrame(shouldBeTime);
|
|
12058
|
-
}
|
|
12059
|
-
if (mediaRef.current.paused) {
|
|
12060
|
-
playAndHandleNotAllowedError({
|
|
12061
|
-
mediaRef,
|
|
12062
|
-
mediaType,
|
|
12063
|
-
onAutoPlayError,
|
|
12064
|
-
logLevel,
|
|
12065
|
-
mountTime,
|
|
12066
|
-
reason: "player is playing but media tag is paused, and just seeked",
|
|
12067
|
-
isPlayer: env.isPlayer
|
|
12068
|
-
});
|
|
12069
|
-
}
|
|
12137
|
+
if (action.bufferUntilFirstFrame) {
|
|
12138
|
+
bufferUntilFirstFrame(action.shouldBeTime);
|
|
12070
12139
|
}
|
|
12071
|
-
if (
|
|
12072
|
-
|
|
12073
|
-
|
|
12074
|
-
|
|
12075
|
-
|
|
12076
|
-
const seekThreshold = playing ? 0.15 : 0.01;
|
|
12077
|
-
const makesSenseToSeek = Math.abs(mediaRef.current.currentTime - shouldBeTime) > seekThreshold;
|
|
12078
|
-
const isMediaTagBufferingOrStalled = isMediaTagBuffering || isBuffering();
|
|
12079
|
-
const isSomethingElseBuffering = buffering.buffering.current && !isMediaTagBufferingOrStalled;
|
|
12080
|
-
if (!playing || isSomethingElseBuffering) {
|
|
12081
|
-
if (makesSenseToSeek) {
|
|
12082
|
-
lastSeek.current = seek({
|
|
12083
|
-
mediaRef: mediaRef.current,
|
|
12084
|
-
time: shouldBeTime,
|
|
12140
|
+
if (action.playReason !== null) {
|
|
12141
|
+
playAndHandleNotAllowedError({
|
|
12142
|
+
mediaRef,
|
|
12143
|
+
mediaType,
|
|
12144
|
+
onAutoPlayError,
|
|
12085
12145
|
logLevel,
|
|
12086
|
-
|
|
12087
|
-
|
|
12146
|
+
mountTime,
|
|
12147
|
+
reason: action.playReason,
|
|
12148
|
+
isPlayer: env.isPlayer
|
|
12088
12149
|
});
|
|
12089
12150
|
}
|
|
12151
|
+
if (action.warnAboutNonSeekable) {
|
|
12152
|
+
warnAboutNonSeekableMedia(current, "console-error");
|
|
12153
|
+
}
|
|
12090
12154
|
return;
|
|
12091
12155
|
}
|
|
12092
|
-
if (
|
|
12093
|
-
|
|
12094
|
-
}
|
|
12095
|
-
const pausedCondition = mediaRef.current.paused && !mediaRef.current.ended;
|
|
12096
|
-
const firstFrameCondition = absoluteFrame === 0;
|
|
12097
|
-
if (pausedCondition || firstFrameCondition) {
|
|
12098
|
-
const reason = pausedCondition ? "media tag is paused" : "absolute frame is 0";
|
|
12099
|
-
if (makesSenseToSeek) {
|
|
12156
|
+
if (action.type === "seek-if-not-playing") {
|
|
12157
|
+
if (action.why !== null) {
|
|
12100
12158
|
lastSeek.current = seek({
|
|
12101
|
-
mediaRef:
|
|
12102
|
-
time: shouldBeTime,
|
|
12159
|
+
mediaRef: current,
|
|
12160
|
+
time: action.shouldBeTime,
|
|
12103
12161
|
logLevel,
|
|
12104
|
-
why:
|
|
12162
|
+
why: action.why,
|
|
12105
12163
|
mountTime
|
|
12106
12164
|
});
|
|
12107
12165
|
}
|
|
12108
|
-
|
|
12109
|
-
|
|
12110
|
-
|
|
12111
|
-
|
|
12166
|
+
return;
|
|
12167
|
+
}
|
|
12168
|
+
if (action.why !== null) {
|
|
12169
|
+
lastSeek.current = seek({
|
|
12170
|
+
mediaRef: current,
|
|
12171
|
+
time: action.shouldBeTime,
|
|
12112
12172
|
logLevel,
|
|
12113
|
-
|
|
12114
|
-
|
|
12115
|
-
isPlayer: env.isPlayer
|
|
12173
|
+
why: action.why,
|
|
12174
|
+
mountTime
|
|
12116
12175
|
});
|
|
12117
|
-
|
|
12118
|
-
|
|
12119
|
-
|
|
12176
|
+
}
|
|
12177
|
+
playAndHandleNotAllowedError({
|
|
12178
|
+
mediaRef,
|
|
12179
|
+
mediaType,
|
|
12180
|
+
onAutoPlayError,
|
|
12181
|
+
logLevel,
|
|
12182
|
+
mountTime,
|
|
12183
|
+
reason: action.playReason,
|
|
12184
|
+
isPlayer: env.isPlayer
|
|
12185
|
+
});
|
|
12186
|
+
if (action.bufferUntilFirstFrame) {
|
|
12187
|
+
bufferUntilFirstFrame(action.shouldBeTime);
|
|
12120
12188
|
}
|
|
12121
12189
|
}, [
|
|
12122
12190
|
absoluteFrame,
|
|
@@ -15640,6 +15708,15 @@ var staticFile = (path) => {
|
|
|
15640
15708
|
}
|
|
15641
15709
|
return preparsed;
|
|
15642
15710
|
};
|
|
15711
|
+
var Still = (props2) => {
|
|
15712
|
+
const newProps = {
|
|
15713
|
+
...props2,
|
|
15714
|
+
durationInFrames: 1,
|
|
15715
|
+
fps: 1
|
|
15716
|
+
};
|
|
15717
|
+
return React42.createElement(Composition, newProps);
|
|
15718
|
+
};
|
|
15719
|
+
addSequenceStackTraces(Still);
|
|
15643
15720
|
var roundTo6Commas = (num) => {
|
|
15644
15721
|
return Math.round(num * 1e5) / 1e5;
|
|
15645
15722
|
};
|
package/dist/tailwind.css
CHANGED
|
@@ -341,6 +341,9 @@
|
|
|
341
341
|
.field-sizing-content {
|
|
342
342
|
field-sizing: content;
|
|
343
343
|
}
|
|
344
|
+
.aspect-square {
|
|
345
|
+
aspect-ratio: 1 / 1;
|
|
346
|
+
}
|
|
344
347
|
.aspect-video {
|
|
345
348
|
aspect-ratio: var(--aspect-video);
|
|
346
349
|
}
|
|
@@ -439,6 +442,9 @@
|
|
|
439
442
|
.max-h-\[110px\] {
|
|
440
443
|
max-height: 110px;
|
|
441
444
|
}
|
|
445
|
+
.max-h-full {
|
|
446
|
+
max-height: 100%;
|
|
447
|
+
}
|
|
442
448
|
.min-h-\[80px\] {
|
|
443
449
|
min-height: 80px;
|
|
444
450
|
}
|
|
@@ -556,6 +562,9 @@
|
|
|
556
562
|
.max-w-\[1200px\] {
|
|
557
563
|
max-width: 1200px;
|
|
558
564
|
}
|
|
565
|
+
.max-w-full {
|
|
566
|
+
max-width: 100%;
|
|
567
|
+
}
|
|
559
568
|
.min-w-\(--radix-select-trigger-width\) {
|
|
560
569
|
min-width: var(--radix-select-trigger-width);
|
|
561
570
|
}
|
|
@@ -583,6 +592,9 @@
|
|
|
583
592
|
.shrink-0 {
|
|
584
593
|
flex-shrink: 0;
|
|
585
594
|
}
|
|
595
|
+
.basis-0 {
|
|
596
|
+
flex-basis: calc(var(--spacing) * 0);
|
|
597
|
+
}
|
|
586
598
|
.-translate-x-1\/2 {
|
|
587
599
|
--tw-translate-x: calc(calc(1 / 2 * 100%) * -1);
|
|
588
600
|
translate: var(--tw-translate-x) var(--tw-translate-y);
|
|
@@ -951,9 +963,6 @@
|
|
|
951
963
|
.py-1\.5 {
|
|
952
964
|
padding-block: calc(var(--spacing) * 1.5);
|
|
953
965
|
}
|
|
954
|
-
.py-2 {
|
|
955
|
-
padding-block: calc(var(--spacing) * 2);
|
|
956
|
-
}
|
|
957
966
|
.py-3 {
|
|
958
967
|
padding-block: calc(var(--spacing) * 3);
|
|
959
968
|
}
|
|
@@ -1104,6 +1113,10 @@
|
|
|
1104
1113
|
--tw-leading: calc(var(--spacing) * 6);
|
|
1105
1114
|
line-height: calc(var(--spacing) * 6);
|
|
1106
1115
|
}
|
|
1116
|
+
.leading-\[1\.1\] {
|
|
1117
|
+
--tw-leading: 1.1;
|
|
1118
|
+
line-height: 1.1;
|
|
1119
|
+
}
|
|
1107
1120
|
.leading-none {
|
|
1108
1121
|
--tw-leading: 1;
|
|
1109
1122
|
line-height: 1;
|
|
@@ -1580,6 +1593,11 @@
|
|
|
1580
1593
|
line-height: calc(var(--spacing) * 5);
|
|
1581
1594
|
}
|
|
1582
1595
|
}
|
|
1596
|
+
.md\:mt-6 {
|
|
1597
|
+
@media (width >= 48rem) {
|
|
1598
|
+
margin-top: calc(var(--spacing) * 6);
|
|
1599
|
+
}
|
|
1600
|
+
}
|
|
1583
1601
|
.md\:mr-6 {
|
|
1584
1602
|
@media (width >= 48rem) {
|
|
1585
1603
|
margin-right: calc(var(--spacing) * 6);
|