remotion 4.0.478 → 4.0.481

package/dist/cjs/with-interactivity-schema.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withInteractivitySchema = exports.mergeValues = exports.selectActiveKeys = exports.readValuesFromProps = exports.getNestedValue = void 0;
+const react_1 = __importStar(require("react"));
+const delete_nested_key_js_1 = require("./delete-nested-key.js");
+const use_memoized_effects_js_1 = require("./effects/use-memoized-effects.js");
+const flatten_schema_js_1 = require("./flatten-schema.js");
+const interactivity_schema_js_1 = require("./interactivity-schema.js");
+const sequence_node_path_js_1 = require("./sequence-node-path.js");
+const SequenceManager_js_1 = require("./SequenceManager.js");
+const use_current_frame_js_1 = require("./use-current-frame.js");
+const use_remotion_environment_js_1 = require("./use-remotion-environment.js");
+const use_schema_js_1 = require("./use-schema.js");
+const getNestedValue = (obj, key) => {
+    const parts = key.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null ||
+            current === undefined ||
+            typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+};
+exports.getNestedValue = getNestedValue;
+const readValuesFromProps = (props, keys) => {
+    const out = {};
+    for (const key of keys) {
+        out[key] = (0, exports.getNestedValue)(props, key);
+    }
+    return out;
+};
+exports.readValuesFromProps = readValuesFromProps;
+const selectActiveKeys = (schema, values) => {
+    return Object.keys((0, flatten_schema_js_1.flattenActiveSchema)(schema, (key) => values[key]));
+};
+exports.selectActiveKeys = selectActiveKeys;
+const mergeValues = ({ props, valuesDotNotation, schemaKeys, propsToDelete, }) => {
+    const merged = { ...props };
+    for (const key of schemaKeys) {
+        const value = valuesDotNotation[key];
+        const parts = key.split('.');
+        if (parts.length === 1) {
+            merged[key] = value;
+            continue;
+        }
+        // For dot-notation keys like 'style.opacity',
+        // clone and set the nested path
+        let current = merged;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (typeof current[part] === 'object' && current[part] !== null) {
+                current[part] = { ...current[part] };
+            }
+            else {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    }
+    (0, delete_nested_key_js_1.deleteNestedKey)(merged, propsToDelete);
+    return merged;
+};
+exports.mergeValues = mergeValues;
+const stackToOverrideMap = {};
+const withInteractivitySchema = ({ Component, componentName, componentIdentity, schema, supportsEffects, }) => {
+    // Schema is static for a component, so we move this outside
+    const schemaWithSequenceName = (0, interactivity_schema_js_1.extendSchemaWithSequenceName)(schema);
+    const flatSchema = (0, flatten_schema_js_1.getFlatSchemaWithAllKeys)(schemaWithSequenceName);
+    const flatKeys = Object.keys(flatSchema);
+    const Wrapped = (0, react_1.forwardRef)((props, ref) => {
+        var _a;
+        const env = (0, use_remotion_environment_js_1.useRemotionEnvironment)();
+        if (!env.isStudio || env.isReadOnlyStudio || env.isRendering) {
+            return react_1.default.createElement(Component, {
+                ...props,
+                controls: null,
+                ref,
+            });
+        }
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const { propStatuses } = (0, react_1.useContext)(SequenceManager_js_1.VisualModePropStatusesContext);
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const { getDragOverrides } = (0, react_1.useContext)(SequenceManager_js_1.VisualModeDragOverridesContext);
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const nodePathMapping = (0, react_1.useContext)(sequence_node_path_js_1.OverrideIdsToNodePathsGettersContext);
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const frame = (0, use_current_frame_js_1.useCurrentFrame)();
+        // If the parent has passed `controls`, we should not override it.
+        // @ts-expect-error
+        if (props.controls) {
+            return react_1.default.createElement(Component, {
+                ...props,
+                ref,
+            });
+        }
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const [overrideId] = (0, react_1.useState)(() => {
+            const { stack } = props;
+            if (!stack) {
+                return String(Math.random());
+            }
+            const existingOverrideId = stackToOverrideMap[stack];
+            if (existingOverrideId) {
+                return existingOverrideId;
+            }
+            const newOverrideId = String(Math.random());
+            stackToOverrideMap[stack] = newOverrideId;
+            return newOverrideId;
+        });
+        const nodePath = (_a = nodePathMapping.overrideIdToNodePathMappings[overrideId]) !== null && _a !== void 0 ? _a : null;
+        // Read the runtime values for every flat key from the JSX props,
+        // memoized on the leaf values so the object reference is stable
+        // when nothing changed — otherwise downstream `useMemo`s churn and
+        // effects (e.g. Sequence registration) re-fire every render.
+        const runtimeValues = flatKeys.map((k) => (0, exports.getNestedValue)(props, k));
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const currentRuntimeValueDotNotation = (0, react_1.useMemo)(() => (0, exports.readValuesFromProps)(props, flatKeys), 
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        runtimeValues);
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const controls = (0, react_1.useMemo)(() => {
+            return {
+                schema: schemaWithSequenceName,
+                currentRuntimeValueDotNotation,
+                overrideId,
+                supportsEffects,
+                componentIdentity,
+                componentName,
+            };
+        }, [currentRuntimeValueDotNotation, overrideId]);
+        // 3. Apply drag/code overrides on top of the runtime values.
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const { merged: valuesDotNotation, propsToDelete } = (0, react_1.useMemo)(() => {
+            return (0, use_schema_js_1.computeEffectiveSchemaValuesDotNotation)({
+                schema: schemaWithSequenceName,
+                currentValue: currentRuntimeValueDotNotation,
+                overrideValues: nodePath === null ? {} : getDragOverrides(nodePath),
+                propStatus: nodePath === null
+                    ? undefined
+                    : (0, use_memoized_effects_js_1.getPropStatusesCtx)(propStatuses, nodePath),
+                frame,
+            });
+        }, [
+            currentRuntimeValueDotNotation,
+            getDragOverrides,
+            nodePath,
+            propStatuses,
+            frame,
+        ]);
+        // 4. Eliminate values forbidden by the resolved discriminated union.
+        const activeKeys = (0, exports.selectActiveKeys)(schemaWithSequenceName, valuesDotNotation);
+        // 5. Apply the active values back onto the props.
+        const mergedProps = (0, exports.mergeValues)({
+            props: props,
+            valuesDotNotation,
+            schemaKeys: activeKeys,
+            propsToDelete,
+        });
+        return react_1.default.createElement(Component, {
+            ...mergedProps,
+            controls,
+            ref,
+        });
+    });
+    Wrapped.displayName = `withInteractivitySchema(${Component.displayName || Component.name || 'Component'})`;
+    return Wrapped;
+};
+exports.withInteractivitySchema = withInteractivitySchema;

package/dist/cjs/wrap-in-schema.d.ts

@@ -1,16 +1,16 @@
 import React from 'react';
 import type { SequenceControls } from './CompositionManager.js';
-import { type SequenceSchema } from './sequence-field-schema.js';
+import { type InteractivitySchema } from './interactivity-schema.js';
 export declare const getNestedValue: (obj: Record<string, unknown>, key: string) => unknown;
 export declare const readValuesFromProps: (props: Record<string, unknown>, keys: string[]) => Record<string, unknown>;
-export declare const selectActiveKeys: (schema: SequenceSchema, values: Record<string, unknown>) => string[];
+export declare const selectActiveKeys: (schema: InteractivitySchema, values: Record<string, unknown>) => string[];
 export declare const mergeValues: ({ props, valuesDotNotation, schemaKeys, propsToDelete, }: {
     props: Record<string, unknown>;
     valuesDotNotation: Record<string, unknown>;
     schemaKeys: string[];
     propsToDelete: Set<string>;
 }) => Record<string, unknown>;
-export declare const wrapInSchema: <S extends SequenceSchema, Props extends object>({ Component, componentIdentity, schema, supportsEffects, }: {
+export declare const wrapInSchema: <S extends InteractivitySchema, Props extends object>({ Component, componentIdentity, schema, supportsEffects, }: {
     Component: React.ComponentType<Props & {
         readonly _experimentalControls: SequenceControls | undefined;
     }>;

package/dist/cjs/wrap-in-schema.js

@@ -38,7 +38,7 @@ const react_1 = __importStar(require("react"));
 const delete_nested_key_js_1 = require("./delete-nested-key.js");
 const use_memoized_effects_js_1 = require("./effects/use-memoized-effects.js");
 const flatten_schema_js_1 = require("./flatten-schema.js");
-const sequence_field_schema_js_1 = require("./sequence-field-schema.js");
+const interactivity_schema_js_1 = require("./interactivity-schema.js");
 const sequence_node_path_js_1 = require("./sequence-node-path.js");
 const SequenceManager_js_1 = require("./SequenceManager.js");
 const use_current_frame_js_1 = require("./use-current-frame.js");
@@ -100,7 +100,7 @@ exports.mergeValues = mergeValues;
 const stackToOverrideMap = {};
 const wrapInSchema = ({ Component, componentIdentity, schema, supportsEffects, }) => {
     // Schema is static for a component, so we move this outside
-    const schemaWithSequenceName = (0, sequence_field_schema_js_1.extendSchemaWithSequenceName)(schema);
+    const schemaWithSequenceName = (0, interactivity_schema_js_1.extendSchemaWithSequenceName)(schema);
     const flatSchema = (0, flatten_schema_js_1.getFlatSchemaWithAllKeys)(schemaWithSequenceName);
     const flatKeys = Object.keys(flatSchema);
     const Wrapped = (0, react_1.forwardRef)((props, ref) => {