@remotion/cli 4.0.0-alpha.217 → 4.0.0-alpha10

package/dist/editor/components/RenderModal/SchemaEditor/ZodSwitch.js

@@ -7,15 +7,18 @@ const ZodArrayEditor_1 = require("./ZodArrayEditor");
 const ZodBooleanEditor_1 = require("./ZodBooleanEditor");
 const ZodColorEditor_1 = require("./ZodColorEditor");
 const ZodDateEditor_1 = require("./ZodDateEditor");
+const ZodDefaultEditor_1 = require("./ZodDefaultEditor");
+const ZodEffectEditor_1 = require("./ZodEffectEditor");
 const ZodEnumEditor_1 = require("./ZodEnumEditor");
 const ZodNonEditableValue_1 = require("./ZodNonEditableValue");
 const ZodNullableEditor_1 = require("./ZodNullableEditor");
 const ZodNumberEditor_1 = require("./ZodNumberEditor");
 const ZodObjectEditor_1 = require("./ZodObjectEditor");
 const ZodOptionalEditor_1 = require("./ZodOptionalEditor");
+const ZodStaticFileEditor_1 = require("./ZodStaticFileEditor");
 const ZodStringEditor_1 = require("./ZodStringEditor");
 const ZodUnionEditor_1 = require("./ZodUnionEditor");
-const ZodSwitch = ({ schema, jsonPath, compact, value, setValue, defaultValue, onSave, showSaveButton, onRemove, }) => {
+const ZodSwitch = ({ schema, jsonPath, compact, value, setValue, defaultValue, onSave, showSaveButton, onRemove, saving, saveDisabledByParent, }) => {
     const def = schema._def;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const typeName = def.typeName;
@@ -23,59 +26,67 @@ const ZodSwitch = ({ schema, jsonPath, compact, value, setValue, defaultValue, o
     if (!z) {
         throw new Error('expected zod');
     }
-    const zodColor = (0, get_zod_if_possible_1.useZodColorIfPossible)();
+    const zodTypes = (0, get_zod_if_possible_1.useZodTypesIfPossible)();
     // TODO: (Maybe?) enable saving of inserted input props by cmd+s /ctrl + s (also for JSON view)
     if (typeName === z.ZodFirstPartyTypeKind.ZodObject) {
-        return ((0, jsx_runtime_1.jsx)(ZodObjectEditor_1.ZodObjectEditor, { setValue: setValue, value: value, defaultValue: defaultValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodObjectEditor_1.ZodObjectEditor, { setValue: setValue, value: value, defaultValue: defaultValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodString) {
-        return ((0, jsx_runtime_1.jsx)(ZodStringEditor_1.ZodStringEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove }));
+        if (value.startsWith(window.remotion_staticBase)) {
+            return ((0, jsx_runtime_1.jsx)(ZodStaticFileEditor_1.ZodStaticFileEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
+        }
+        return ((0, jsx_runtime_1.jsx)(ZodStringEditor_1.ZodStringEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodDate) {
-        return ((0, jsx_runtime_1.jsx)(ZodDateEditor_1.ZodDateEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodDateEditor_1.ZodDateEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodNumber) {
-        return ((0, jsx_runtime_1.jsx)(ZodNumberEditor_1.ZodNumberEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodNumberEditor_1.ZodNumberEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodBoolean) {
-        return ((0, jsx_runtime_1.jsx)(ZodBooleanEditor_1.ZodBooleanEditor, { value: value, setValue: setValue, jsonPath: jsonPath, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodBooleanEditor_1.ZodBooleanEditor, { value: value, setValue: setValue, jsonPath: jsonPath, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodUndefined) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'undefined' }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'undefined', saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodNull) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'null' }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'null', saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodAny) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'any (not editable)' }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'any (not editable)', saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodBigInt) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'BigInt (not editable)' }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'BigInt (not editable)', saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodUnknown) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'unknown (not editable)' }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'unknown (not editable)', saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodArray) {
-        return ((0, jsx_runtime_1.jsx)(ZodArrayEditor_1.ZodArrayEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodArrayEditor_1.ZodArrayEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodEnum) {
-        return ((0, jsx_runtime_1.jsx)(ZodEnumEditor_1.ZodEnumEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodEnumEditor_1.ZodEnumEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodEffects) {
-        if (zodColor &&
-            schema._def.description === zodColor.ZColorInternals.REMOTION_COLOR_BRAND) {
-            return ((0, jsx_runtime_1.jsx)(ZodColorEditor_1.ZodColorEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove }));
+        if (zodTypes &&
+            schema._def.description ===
+                zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+            return ((0, jsx_runtime_1.jsx)(ZodColorEditor_1.ZodColorEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
         }
+        return ((0, jsx_runtime_1.jsx)(ZodEffectEditor_1.ZodEffectEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, compact: compact, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodUnion) {
-        return ((0, jsx_runtime_1.jsx)(ZodUnionEditor_1.ZodUnionEditor, { schema: schema, showSaveButton: showSaveButton, jsonPath: jsonPath, compact: compact, value: value, defaultValue: defaultValue, setValue: setValue, onSave: onSave, onRemove: onRemove }));
+        return ((0, jsx_runtime_1.jsx)(ZodUnionEditor_1.ZodUnionEditor, { schema: schema, showSaveButton: showSaveButton, jsonPath: jsonPath, compact: compact, value: value, defaultValue: defaultValue, setValue: setValue, onSave: onSave, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodOptional) {
-        return ((0, jsx_runtime_1.jsx)(ZodOptionalEditor_1.ZodOptionalEditor, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema }));
+        return ((0, jsx_runtime_1.jsx)(ZodOptionalEditor_1.ZodOptionalEditor, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
     if (typeName === z.ZodFirstPartyTypeKind.ZodNullable) {
-        return ((0, jsx_runtime_1.jsx)(ZodNullableEditor_1.ZodNullableEditor, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema }));
+        return ((0, jsx_runtime_1.jsx)(ZodNullableEditor_1.ZodNullableEditor, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodDefault) {
+        return ((0, jsx_runtime_1.jsx)(ZodDefaultEditor_1.ZodDefaultEditor, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent }));
     }
-    return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: `${typeName} (not editable)` }));
+    return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { compact: compact, jsonPath: jsonPath, showSaveButton: showSaveButton, label: `${typeName} (not editable)`, saving: saving }));
 };
 exports.ZodSwitch = ZodSwitch;

package/dist/editor/components/RenderModal/SchemaEditor/ZodUnionEditor.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import type { z } from 'zod';
 import type { JSONPath } from './zod-types';
+import type { UpdaterFunction } from './ZodSwitch';
 export declare const ZodUnionEditor: React.FC<{
     showSaveButton: boolean;
     jsonPath: JSONPath;
@@ -8,7 +9,9 @@ export declare const ZodUnionEditor: React.FC<{
     value: unknown;
     defaultValue: unknown;
     schema: z.ZodTypeAny;
-    setValue: React.Dispatch<React.SetStateAction<unknown>>;
-    onSave: (updater: (oldNum: unknown) => unknown) => void;
+    setValue: UpdaterFunction<unknown>;
+    onSave: UpdaterFunction<unknown>;
     onRemove: null | (() => void);
+    saving: boolean;
+    saveDisabledByParent: boolean;
 }>;

package/dist/editor/components/RenderModal/SchemaEditor/ZodUnionEditor.js

@@ -24,26 +24,26 @@ const findNull = (value, zodType) => {
         otherSchemaIsAlsoNullish,
     };
 };
-const ZodUnionEditor = ({ jsonPath, compact, schema, setValue, onSave, defaultValue, value, showSaveButton, onRemove, }) => {
+const ZodUnionEditor = ({ jsonPath, compact, schema, setValue, onSave, defaultValue, value, showSaveButton, onRemove, saving, saveDisabledByParent, }) => {
     const { options } = schema._def;
     const z = (0, get_zod_if_possible_1.useZodIfPossible)();
     if (!z) {
         throw new Error('expected zod');
     }
     if (options.length > 2) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with more than 2 options not editable', compact: compact, showSaveButton: showSaveButton }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with more than 2 options not editable', compact: compact, showSaveButton: showSaveButton, saving: saving }));
     }
     if (options.length < 2) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with less than 2 options not editable', compact: compact, showSaveButton: showSaveButton }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with less than 2 options not editable', compact: compact, showSaveButton: showSaveButton, saving: saving }));
     }
     const nullResult = findNull(options, z);
     if (!nullResult) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union only editable with 1 value being null', compact: compact, showSaveButton: showSaveButton }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union only editable with 1 value being null', compact: compact, showSaveButton: showSaveButton, saving: saving }));
     }
     const { otherSchema, nullishValue, otherSchemaIsAlsoNullish } = nullResult;
     if (otherSchemaIsAlsoNullish) {
-        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Not editable - both union values are nullish', compact: compact, showSaveButton: showSaveButton }));
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Not editable - both union values are nullish', compact: compact, showSaveButton: showSaveButton, saving: saving }));
     }
-    return ((0, jsx_runtime_1.jsx)(ZodOrNullishEditor_1.ZodOrNullishEditor, { compact: compact, defaultValue: defaultValue, jsonPath: jsonPath, onRemove: onRemove, onSave: onSave, schema: otherSchema, setValue: setValue, showSaveButton: showSaveButton, value: value, nullishValue: nullishValue }));
+    return ((0, jsx_runtime_1.jsx)(ZodOrNullishEditor_1.ZodOrNullishEditor, { compact: compact, defaultValue: defaultValue, jsonPath: jsonPath, onRemove: onRemove, onSave: onSave, schema: otherSchema, setValue: setValue, showSaveButton: showSaveButton, value: value, nullishValue: nullishValue, saving: saving, saveDisabledByParent: saveDisabledByParent }));
 };
 exports.ZodUnionEditor = ZodUnionEditor;

package/dist/editor/components/RenderModal/SchemaEditor/create-zod-values.d.ts

@@ -1,2 +1,2 @@
-import type { ZodColorType, ZodType } from '../../get-zod-if-possible';
-export declare const createZodValues: (schema: Zod.ZodTypeAny, zodRuntime: ZodType, zColorRuntime: ZodColorType | null) => unknown;
+import type { ZodType, ZodTypesType } from '../../get-zod-if-possible';
+export declare const createZodValues: (schema: Zod.ZodTypeAny, zodRuntime: ZodType, zodTypes: ZodTypesType | null) => unknown;

package/dist/editor/components/RenderModal/SchemaEditor/create-zod-values.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createZodValues = void 0;
-const createZodValues = (schema, zodRuntime, zColorRuntime) => {
+const createZodValues = (schema, zodRuntime, zodTypes) => {
     if (!schema) {
         throw new Error('Invalid zod schema');
     }
@@ -38,71 +38,71 @@ const createZodValues = (schema, zodRuntime, zColorRuntime) => {
             const shape = def.shape();
             const keys = Object.keys(shape);
             const returnValue = keys.reduce((existing, key) => {
-                existing[key] = (0, exports.createZodValues)(shape[key], zodRuntime, zColorRuntime);
+                existing[key] = (0, exports.createZodValues)(shape[key], zodRuntime, zodTypes);
                 return existing;
             }, {});
             return returnValue;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
             return [
-                (0, exports.createZodValues)(def.type, zodRuntime, zColorRuntime),
+                (0, exports.createZodValues)(def.type, zodRuntime, zodTypes),
             ];
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
             const firstOptions = def.options[0];
             return firstOptions
-                ? (0, exports.createZodValues)(firstOptions, zodRuntime, zColorRuntime)
+                ? (0, exports.createZodValues)(firstOptions, zodRuntime, zodTypes)
                 : undefined;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
             const options = def.options[0];
-            return (0, exports.createZodValues)(options, zodRuntime, zColorRuntime);
+            return (0, exports.createZodValues)(options, zodRuntime, zodTypes);
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
             return def.value;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodEffects: {
-            if (zColorRuntime &&
+            if (zodTypes &&
                 schema._def.description ===
-                    zColorRuntime.ZColorInternals.REMOTION_COLOR_BRAND) {
+                    zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
                 return '#ffffff';
             }
-            return (0, exports.createZodValues)(def.schema, zodRuntime, zColorRuntime);
+            return (0, exports.createZodValues)(def.schema, zodRuntime, zodTypes);
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
             const { left, right } = def;
-            const leftValue = (0, exports.createZodValues)(left, zodRuntime, zColorRuntime);
+            const leftValue = (0, exports.createZodValues)(left, zodRuntime, zodTypes);
             if (typeof leftValue !== 'object') {
                 throw new Error('Cannot create value for type z.intersection: Left side is not an object');
             }
-            const rightValue = (0, exports.createZodValues)(right, zodRuntime, zColorRuntime);
+            const rightValue = (0, exports.createZodValues)(right, zodRuntime, zodTypes);
             if (typeof rightValue !== 'object') {
                 throw new Error('Cannot create value for type z.intersection: Right side is not an object');
             }
             return { ...leftValue, ...rightValue };
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
-            const items = def.items.map((item) => (0, exports.createZodValues)(item, zodRuntime, zColorRuntime));
+            const items = def.items.map((item) => (0, exports.createZodValues)(item, zodRuntime, zodTypes));
             return items;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
-            const values = (0, exports.createZodValues)(def.valueType, zodRuntime, zColorRuntime);
+            const values = (0, exports.createZodValues)(def.valueType, zodRuntime, zodTypes);
             return { key: values };
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodMap: {
             const defType = def;
-            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zColorRuntime);
-            const key = (0, exports.createZodValues)(defType.keyType, zodRuntime, zColorRuntime);
+            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zodTypes);
+            const key = (0, exports.createZodValues)(defType.keyType, zodRuntime, zodTypes);
             return new Map([[key, values]]);
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodLazy: {
             const defType = def;
             const type = defType.getter();
-            return (0, exports.createZodValues)(type, zodRuntime, zColorRuntime);
+            return (0, exports.createZodValues)(type, zodRuntime, zodTypes);
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
             const defType = def;
-            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zColorRuntime);
+            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zodTypes);
             return new Set([values]);
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodFunction: {
@@ -117,12 +117,12 @@ const createZodValues = (schema, zodRuntime, zColorRuntime) => {
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
             const defType = def;
-            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zColorRuntime);
+            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zodTypes);
             return value;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
             const defType = def;
-            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zColorRuntime);
+            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zodTypes);
             return value;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
@@ -131,24 +131,24 @@ const createZodValues = (schema, zodRuntime, zColorRuntime) => {
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
             const defType = def;
-            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zColorRuntime);
+            const value = (0, exports.createZodValues)(defType.innerType, zodRuntime, zodTypes);
             return value;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
             const defType = def;
-            const value = (0, exports.createZodValues)(defType.type, zodRuntime, zColorRuntime);
+            const value = (0, exports.createZodValues)(defType.type, zodRuntime, zodTypes);
             return Promise.resolve(value);
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const defType = def;
-            const value = (0, exports.createZodValues)(defType.type, zodRuntime, zColorRuntime);
+            const value = (0, exports.createZodValues)(defType.type, zodRuntime, zodTypes);
             return value;
         }
         case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const defType = def;
-            const value = (0, exports.createZodValues)(defType.out, zodRuntime, zColorRuntime);
+            const value = (0, exports.createZodValues)(defType.out, zodRuntime, zodTypes);
             return value;
         }
         default:

package/dist/editor/components/RenderModal/SchemaEditor/deep-equal.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any): boolean;

package/dist/editor/components/RenderModal/SchemaEditor/deep-equal.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a !== 'object' ||
+        a === null ||
+        typeof b !== 'object' ||
+        b === null) {
+        return false;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (const key of keysA) {
+        if (!keysB.includes(key) || !deepEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.deepEqual = deepEqual;

package/dist/editor/components/RenderModal/SchemaEditor/extract-enum-json-paths.d.ts

@@ -0,0 +1,3 @@
+import type { ZodType } from '../../get-zod-if-possible';
+export declare type EnumPath = (string | number)[];
+export declare const extractEnumJsonPaths: (schema: Zod.ZodTypeAny, zodRuntime: ZodType, currentPath: (string | number)[]) => (string | number)[][];

package/dist/editor/components/RenderModal/SchemaEditor/extract-enum-json-paths.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractEnumJsonPaths = void 0;
+const extractEnumJsonPaths = (schema, zodRuntime, currentPath) => {
+    const def = schema._def;
+    const typeName = def.typeName;
+    switch (typeName) {
+        case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
+            const shape = def.shape();
+            const keys = Object.keys(shape);
+            return keys
+                .map((key) => {
+                return (0, exports.extractEnumJsonPaths)(shape[key], zodRuntime, [
+                    ...currentPath,
+                    key,
+                ]);
+            })
+                .flat(1);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
+            return (0, exports.extractEnumJsonPaths)(def.type, zodRuntime, [
+                ...currentPath,
+                '[]',
+            ]);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
+            return def.options
+                .map((option) => {
+                return (0, exports.extractEnumJsonPaths)(option, zodRuntime, currentPath);
+            })
+                .flat(1);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
+            return def.options
+                .map((op) => {
+                return (0, exports.extractEnumJsonPaths)(op, zodRuntime, currentPath);
+            })
+                .flat(1);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
+            return [currentPath];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodEffects: {
+            return (0, exports.extractEnumJsonPaths)(def.schema, zodRuntime, currentPath);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
+            const { left, right } = def;
+            const leftValue = (0, exports.extractEnumJsonPaths)(left, zodRuntime, currentPath);
+            const rightValue = (0, exports.extractEnumJsonPaths)(right, zodRuntime, currentPath);
+            return [...leftValue, ...rightValue];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
+            return def.items
+                .map((item, i) => (0, exports.extractEnumJsonPaths)(item, zodRuntime, [...currentPath, i]))
+                .flat(1);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
+            const values = (0, exports.extractEnumJsonPaths)(def.valueType, zodRuntime, [...currentPath, '{}']);
+            return values;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodFunction: {
+            throw new Error('Cannot create a value for type function');
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodEnum: {
+            return [currentPath];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNativeEnum: {
+            return [];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
+            const defType = def;
+            const value = (0, exports.extractEnumJsonPaths)(defType.innerType, zodRuntime, currentPath);
+            return value;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
+            const defType = def;
+            const value = (0, exports.extractEnumJsonPaths)(defType.innerType, zodRuntime, currentPath);
+            return value;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
+            const defType = def;
+            return (0, exports.extractEnumJsonPaths)(defType.innerType, zodRuntime, currentPath);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
+            const defType = def;
+            return (0, exports.extractEnumJsonPaths)(defType.innerType, zodRuntime, currentPath);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
+            return [];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const defType = def;
+            const value = (0, exports.extractEnumJsonPaths)(defType.type, zodRuntime, currentPath);
+            return value;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const defType = def;
+            const value = (0, exports.extractEnumJsonPaths)(defType.out, zodRuntime, currentPath);
+            return value;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodString:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNumber:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodBigInt:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodBoolean:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNaN:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodDate:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodSymbol:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodUndefined:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNull:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodAny:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodUnknown:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNever:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodVoid:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodMap: // Maps are not serializable
+        case zodRuntime.ZodFirstPartyTypeKind.ZodLazy:
+        case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
+            // Sets are not serializable
+            return [];
+        }
+        default:
+            throw new Error('Not implemented: ' + typeName);
+    }
+};
+exports.extractEnumJsonPaths = extractEnumJsonPaths;

package/dist/editor/components/RenderModal/SchemaEditor/input-props-serialization.d.ts

@@ -0,0 +1,14 @@
+export declare type SerializedJSONWithCustomFields = {
+    serializedString: string;
+    customDateUsed: boolean;
+    customFileUsed: boolean;
+    mapUsed: boolean;
+    setUsed: boolean;
+};
+export declare const FILE_TOKEN = "remotion-file:";
+export declare const serializeJSONWithDate: ({ data, indent, staticBase, }: {
+    data: unknown;
+    indent: number | undefined;
+    staticBase: string;
+}) => SerializedJSONWithCustomFields;
+export declare const deserializeJSONWithCustomFields: (data: string) => any;

package/dist/editor/components/RenderModal/SchemaEditor/input-props-serialization.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeJSONWithCustomFields = exports.serializeJSONWithDate = exports.FILE_TOKEN = void 0;
+const DATE_TOKEN = 'remotion-date:';
+exports.FILE_TOKEN = 'remotion-file:';
+const serializeJSONWithDate = ({ data, indent, staticBase, }) => {
+    let customDateUsed = false;
+    let customFileUsed = false;
+    let mapUsed = false;
+    let setUsed = false;
+    const serializedString = JSON.stringify(data, function (key, value) {
+        const item = this[key];
+        if (item instanceof Date) {
+            customDateUsed = true;
+            return `${DATE_TOKEN}${item.toISOString()}`;
+        }
+        if (item instanceof Map) {
+            mapUsed = true;
+            return value;
+        }
+        if (item instanceof Set) {
+            setUsed = true;
+            return value;
+        }
+        if (typeof item === 'string' && item.startsWith(staticBase)) {
+            customFileUsed = true;
+            return `${exports.FILE_TOKEN}${item.replace(staticBase + '/', '')}`;
+        }
+        return value;
+    }, indent);
+    return { serializedString, customDateUsed, customFileUsed, mapUsed, setUsed };
+};
+exports.serializeJSONWithDate = serializeJSONWithDate;
+const deserializeJSONWithCustomFields = (data) => {
+    return JSON.parse(data, (_, value) => {
+        if (typeof value === 'string' && value.startsWith(DATE_TOKEN)) {
+            return new Date(value.replace(DATE_TOKEN, ''));
+        }
+        return value;
+    });
+};
+exports.deserializeJSONWithCustomFields = deserializeJSONWithCustomFields;

package/dist/editor/components/RenderModal/SchemaEditor/local-state.d.ts

@@ -0,0 +1,16 @@
+import type { z } from 'zod';
+import type { UpdaterFunction } from './ZodSwitch';
+declare type LocalState<T> = {
+    value: T;
+    zodValidation: z.SafeParseReturnType<unknown, unknown>;
+    revision: number;
+};
+export declare const useLocalState: <T>({ value, schema, setValue, }: {
+    value: T;
+    schema: z.ZodTypeAny;
+    setValue: UpdaterFunction<T>;
+}) => {
+    localValue: LocalState<T>;
+    onChange: (updater: (oldV: T) => T, forceApply: boolean) => void;
+};
+export {};

package/dist/editor/components/RenderModal/SchemaEditor/local-state.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocalState = void 0;
+const react_1 = require("react");
+const deep_equal_1 = require("./deep-equal");
+const useLocalState = ({ value, schema, setValue, }) => {
+    const [localValue, setLocalValue] = (0, react_1.useState)(() => {
+        return {
+            value,
+            zodValidation: schema.safeParse(value),
+            revision: 0,
+        };
+    });
+    const stateRef = (0, react_1.useRef)(localValue);
+    stateRef.current = localValue;
+    const onChange = (0, react_1.useCallback)((updater, forceApply) => {
+        const newValue = updater(stateRef.current.value);
+        const isSame = (0, deep_equal_1.deepEqual)(newValue, stateRef.current.value);
+        if (isSame) {
+            return;
+        }
+        const safeParse = schema.safeParse(newValue);
+        if (safeParse.success || forceApply) {
+            setValue(updater, forceApply);
+        }
+        setLocalValue((oldLocalState) => {
+            const newState = {
+                revision: oldLocalState.revision + 1,
+                value: newValue,
+                zodValidation: safeParse,
+            };
+            stateRef.current = newState;
+            return newState;
+        });
+    }, [schema, setValue]);
+    return { localValue, onChange };
+};
+exports.useLocalState = useLocalState;

package/dist/editor/components/RenderModal/get-render-modal-warnings.d.ts

@@ -1,3 +1,4 @@
+import type { PropsEditType } from './DataEditor';
 export declare type TypeCanSaveState = {
     canUpdate: true;
 } | {
@@ -5,7 +6,14 @@ export declare type TypeCanSaveState = {
     reason: string;
     determined: boolean;
 };
-export declare const getRenderModalWarnings: ({ cliProps, canSaveDefaultProps, }: {
+export declare const defaultTypeCanSaveState: TypeCanSaveState;
+export declare const getRenderModalWarnings: ({ cliProps, canSaveDefaultProps, isCustomDateUsed, customFileUsed, jsMapUsed, jsSetUsed, inJSONEditor, propsEditType, }: {
     cliProps: unknown;
     canSaveDefaultProps: TypeCanSaveState;
+    isCustomDateUsed: boolean;
+    customFileUsed: boolean;
+    jsMapUsed: boolean;
+    jsSetUsed: boolean;
+    inJSONEditor: boolean;
+    propsEditType: PropsEditType;
 }) => string[];