remotion 4.0.526 → 4.0.528

package/dist/esm/no-react.mjs

@@ -237,13 +237,19 @@ function springCalculation({
 }) {
   const from = 0;
   const to = 1;
+  const resolvedConfig = {
+    damping: config.damping ?? defaultSpringConfig.damping,
+    mass: config.mass ?? defaultSpringConfig.mass,
+    stiffness: config.stiffness ?? defaultSpringConfig.stiffness,
+    overshootClamping: config.overshootClamping ?? defaultSpringConfig.overshootClamping
+  };
   const cacheKey = [
     frame,
     fps,
-    config.damping,
-    config.mass,
-    config.overshootClamping,
-    config.stiffness
+    resolvedConfig.damping,
+    resolvedConfig.mass,
+    resolvedConfig.overshootClamping,
+    resolvedConfig.stiffness
   ].join("-");
   if (calculationCache[cacheKey]) {
     return calculationCache[cacheKey];
@@ -262,20 +268,14 @@ function springCalculation({
     animation = advance({
       animation,
       now: time,
-      config: {
-        ...defaultSpringConfig,
-        ...config
-      }
+      config: resolvedConfig
     });
   }
   if (unevenRest > 0) {
     animation = advance({
       animation,
       now: frameClamped / fps * 1000,
-      config: {
-        ...defaultSpringConfig,
-        ...config
-      }
+      config: resolvedConfig
     });
   }
   calculationCache[cacheKey] = animation;
@@ -750,7 +750,7 @@ var parseAxisRotationValue = (output) => {
     axisRotation: true
   };
 };
-var parseStringInterpolationValue = (output) => {
+var parseStringInterpolationValue = (output, outputType) => {
   if (typeof output === "number") {
     if (!Number.isFinite(output)) {
       throw new Error(`outputRange must contain only finite numbers, but got [${output}]`);
@@ -763,8 +763,18 @@ var parseStringInterpolationValue = (output) => {
       axisRotation: false
     };
   }
+  if (outputType === "transform-origin") {
+    const transformOriginParts = output.trim().split(/\s+/);
+    if (transformOriginParts.length < 1 || transformOriginParts.length > 3 || transformOriginParts[0] === "") {
+      throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
+    }
+    return parseTransformOriginValue(output, transformOriginParts);
+  }
   const axisRotation = parseAxisRotationValue(output);
   if (axisRotation !== null) {
+    if (outputType !== undefined && outputType !== "rotate") {
+      throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a rotate value`);
+    }
     return axisRotation;
   }
   const parts = output.trim().split(/\s+/);
@@ -772,6 +782,9 @@ var parseStringInterpolationValue = (output) => {
     throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
   }
   if (parts.some((part) => transformOriginKeywords.has(part.toLowerCase()))) {
+    if (outputType !== undefined) {
+      throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a transform-origin value`);
+    }
     return parseTransformOriginValue(output, parts);
   }
   const parsed = parts.map((part) => parseStringInterpolationComponent(part, output));
@@ -781,6 +794,9 @@ var parseStringInterpolationValue = (output) => {
       throw new TypeError(`Cannot interpolate "${output}" because it mixes ${kind} and ${part.kind} values`);
     }
   }
+  if (outputType !== undefined && outputType !== kind) {
+    throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a ${kind} value`);
+  }
   if (kind === "scale") {
     const x = parsed[0].value;
     const y = parsed[1]?.value ?? x;
@@ -981,9 +997,10 @@ var interpolateString = ({
   input,
   inputRange,
   outputRange,
-  options
+  options,
+  outputType
 }) => {
-  const initiallyParsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const initiallyParsedOutputRange = outputRange.map((output) => parseStringInterpolationValue(output, outputType));
   const hasAxisRotation = initiallyParsedOutputRange.some((parsed) => parsed.axisRotation);
   const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
   const segmentIndex = inputRange.length === 1 ? 0 : findRange(posterizedInput, inputRange);
@@ -1063,6 +1080,36 @@ var interpolateString = ({
     axisRotation: hasAxisRotation
   });
 };
+var interpolateFontWeight = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const normalizedOutputRange = outputRange.map((output) => {
+    if (typeof output === "string") {
+      const lowerCaseOutput = output.toLowerCase();
+      if (lowerCaseOutput === "normal") {
+        return 400;
+      }
+      if (lowerCaseOutput === "bold") {
+        return 700;
+      }
+    }
+    const match = typeof output === "string" ? cssNumberRegex.exec(output) : null;
+    const value = typeof output === "number" ? output : match !== null && match[2] === undefined ? Number(match[1]) : Number.NaN;
+    if (!Number.isFinite(value) || value < 1 || value > 1000) {
+      throw new TypeError(`Cannot interpolate font weight "${output}". Expected "normal", "bold", or a number between 1 and 1000`);
+    }
+    return value;
+  });
+  return interpolateNumber({
+    input,
+    inputRange,
+    outputRange: normalizedOutputRange,
+    options
+  });
+};
 var interpolateDiscreteString = ({
   input,
   inputRange,
@@ -1194,6 +1241,12 @@ function assertValidInterpolateOutputOption(output) {
   }
   throw new Error(`output must be "linear" or "perceptual-scale", but got ${String(output)}`);
 }
+function assertValidInterpolateOutputType(outputType) {
+  if (outputType === undefined || outputType === "font-weight" || outputType === "scale" || outputType === "translate" || outputType === "rotate" || outputType === "transform-origin") {
+    return;
+  }
+  throw new Error(`outputType must be "font-weight", "scale", "translate", "rotate", or "transform-origin", but got ${String(outputType)}`);
+}
 function interpolate(input, inputRange, outputRange, options) {
   if (typeof input === "undefined") {
     throw new Error("input can not be undefined");
@@ -1212,26 +1265,48 @@ function interpolate(input, inputRange, outputRange, options) {
   assertValidInterpolateEasingOption(options?.easing, inputRange.length);
   assertValidInterpolatePosterizeOption(options?.posterize);
   assertValidInterpolateOutputOption(options?.output);
+  assertValidInterpolateOutputType(options?.outputType);
   if (typeof input !== "number") {
     throw new TypeError("Cannot interpolate an input which is not a number");
   }
   if (!Array.isArray(outputRange)) {
     throw new Error("outputRange must contain only numbers");
   }
+  const outputType = options?.outputType;
+  if (outputType === "font-weight") {
+    if (!outputRange.every((output) => typeof output === "number" || typeof output === "string")) {
+      throw new TypeError("Font weight outputRange must contain only numbers or strings");
+    }
+    return interpolateFontWeight({
+      input,
+      inputRange,
+      outputRange,
+      options
+    });
+  }
   const hasStringOutput = outputRange.some((output) => typeof output === "string");
+  if (outputType !== undefined && outputType !== "scale" && !hasStringOutput) {
+    throw new TypeError(`${outputType} outputRange must contain strings with the appropriate CSS units`);
+  }
   if (hasStringOutput) {
     if (!outputRange.every((output) => typeof output === "string" || typeof output === "number")) {
       throw new TypeError("outputRange must contain only numbers, or supported scale, translate, and rotate strings");
     }
     try {
-      return interpolateString({ input, inputRange, outputRange, options });
+      return interpolateString({
+        input,
+        inputRange,
+        outputRange,
+        options,
+        outputType
+      });
     } catch (error) {
       if (!outputRange.every((output) => typeof output === "string")) {
         throw error;
       }
       const hasNonNumericString = outputRange.some((output) => {
         try {
-          parseStringInterpolationValue(output);
+          parseStringInterpolationValue(output, outputType);
           return false;
         } catch (parseError) {
           return parseError instanceof UnsupportedStringInterpolationValueError;
@@ -1681,10 +1756,20 @@ var freezeField = {
   step: 1,
   hiddenFromList: true
 };
+var playbackRateField = {
+  type: "number",
+  default: 1,
+  min: 0.01,
+  step: 0.1,
+  description: "Playback rate",
+  hiddenFromList: false,
+  keyframable: false
+};
 var baseSchema = {
   durationInFrames: durationInFramesField,
   from: fromField,
   trimBefore: trimBeforeField,
+  playbackRate: playbackRateField,
   freeze: freezeField,
   hidden: hiddenField,
   name: sequenceNameField,
@@ -1705,6 +1790,7 @@ var sequenceSchema = {
 var baseSchemaWithoutFrom = {
   durationInFrames: durationInFramesField,
   trimBefore: trimBeforeField,
+  playbackRate: playbackRateField,
   freeze: freezeField,
   hidden: hiddenField,
   name: sequenceNameField,

package/dist/esm/version.mjs

@@ -1,5 +1,5 @@
 // src/version.ts
-var VERSION = "4.0.526";
+var VERSION = "4.0.528";
 export {
   VERSION
 };

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/core"
 	},
 	"name": "remotion",
-	"version": "4.0.526",
+	"version": "4.0.528",
 	"description": "Make videos programmatically",
 	"main": "dist/cjs/index.js",
 	"types": "dist/cjs/index.d.ts",
@@ -35,7 +35,7 @@
 		"react-dom": "19.2.3",
 		"webpack": "5.105.0",
 		"zod": "4.5.4",
-		"@remotion/eslint-config-internal": "4.0.526",
+		"@remotion/eslint-config-internal": "4.0.528",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},

package/dist/cjs/nonce.d.ts

@@ -1,11 +0,0 @@
-export type TNonceContext = {
-    getNonce: () => number;
-};
-type NonceHistoryItem = [number, number];
-export type NonceHistory = NonceHistoryItem[];
-export type NonceHistoryContext = {
-    get: () => NonceHistory;
-};
-export declare const NonceContext: import("react").Context<TNonceContext>;
-export declare const useNonce: () => NonceHistoryContext;
-export {};

package/dist/cjs/nonce.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useNonce = exports.NonceContext = void 0;
-const react_1 = require("react");
-exports.NonceContext = (0, react_1.createContext)({
-    getNonce: () => 0,
-});
-let fastRefreshNonce = 0;
-try {
-    if (typeof __webpack_module__ !== 'undefined') {
-        if (__webpack_module__.hot) {
-            __webpack_module__.hot.addStatusHandler((status) => {
-                if (status === 'idle') {
-                    fastRefreshNonce++;
-                }
-            });
-        }
-    }
-}
-catch (_a) {
-    // __webpack_module__ may throw ReferenceError in some environments
-}
-const useNonce = () => {
-    const context = (0, react_1.useContext)(exports.NonceContext);
-    const nonce = context.getNonce();
-    const nonceRef = (0, react_1.useRef)(nonce);
-    nonceRef.current = nonce;
-    const history = (0, react_1.useRef)([[fastRefreshNonce, nonce]]);
-    const get = (0, react_1.useCallback)(() => {
-        if (fastRefreshNonce !== history.current[history.current.length - 1][0]) {
-            history.current = [
-                ...history.current,
-                [fastRefreshNonce, nonceRef.current],
-            ];
-        }
-        return history.current;
-    }, [history]);
-    return (0, react_1.useMemo)(() => {
-        return { get };
-    }, [get]);
-};
-exports.useNonce = useNonce;