@remotion/cli 4.0.0-webhook.26 → 4.1.0-alpha1

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

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { z } from 'zod';
+import type { JSONPath } from './zod-types';
+import type { UpdaterFunction } from './ZodSwitch';
+export declare const ZodOptionalEditor: React.FC<{
+    showSaveButton: boolean;
+    jsonPath: JSONPath;
+    value: unknown;
+    defaultValue: unknown;
+    schema: z.ZodTypeAny;
+    setValue: UpdaterFunction<unknown>;
+    onSave: UpdaterFunction<unknown>;
+    onRemove: null | (() => void);
+    saving: boolean;
+    saveDisabledByParent: boolean;
+    mayPad: boolean;
+}>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodOptionalEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const ZodOrNullishEditor_1 = require("./ZodOrNullishEditor");
+const ZodOptionalEditor = ({ jsonPath, schema, setValue, onSave, defaultValue, value, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
+    const { innerType } = schema._def;
+    return ((0, jsx_runtime_1.jsx)(ZodOrNullishEditor_1.ZodOrNullishEditor, { defaultValue: defaultValue, jsonPath: jsonPath, onRemove: onRemove, onSave: onSave, schema: schema, setValue: setValue, showSaveButton: showSaveButton, value: value, nullishValue: undefined, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad, innerSchema: innerType }));
+};
+exports.ZodOptionalEditor = ZodOptionalEditor;

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

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import type { z } from 'zod';
+import type { JSONPath } from './zod-types';
+import type { UpdaterFunction } from './ZodSwitch';
+export declare const ZodOrNullishEditor: React.FC<{
+    showSaveButton: boolean;
+    jsonPath: JSONPath;
+    value: unknown;
+    defaultValue: unknown;
+    schema: z.ZodTypeAny;
+    innerSchema: z.ZodTypeAny;
+    setValue: UpdaterFunction<unknown>;
+    onSave: UpdaterFunction<unknown>;
+    onRemove: null | (() => void);
+    nullishValue: null | undefined;
+    saving: boolean;
+    saveDisabledByParent: boolean;
+    mayPad: boolean;
+}>;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodOrNullishEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const colors_1 = require("../../../helpers/colors");
+const Checkbox_1 = require("../../Checkbox");
+const get_zod_if_possible_1 = require("../../get-zod-if-possible");
+const layout_1 = require("../../layout");
+const create_zod_values_1 = require("./create-zod-values");
+const SchemaLabel_1 = require("./SchemaLabel");
+const ZodSwitch_1 = require("./ZodSwitch");
+const Fieldset_1 = require("./Fieldset");
+const local_state_1 = require("./local-state");
+const labelStyle = {
+    fontFamily: 'sans-serif',
+    fontSize: 14,
+    color: colors_1.LIGHT_TEXT,
+};
+const checkBoxWrapper = {
+    display: 'flex',
+    flexDirection: 'row',
+    alignItems: 'center',
+    marginTop: '5px',
+};
+const ZodOrNullishEditor = ({ jsonPath, schema, setValue, onSave, defaultValue, value, showSaveButton, onRemove, nullishValue, saving, saveDisabledByParent, mayPad, innerSchema, }) => {
+    const z = (0, get_zod_if_possible_1.useZodIfPossible)();
+    if (!z) {
+        throw new Error('expected zod');
+    }
+    const zodTypes = (0, get_zod_if_possible_1.useZodTypesIfPossible)();
+    const isChecked = value === nullishValue;
+    const { localValue, onChange: setLocalValue, reset, } = (0, local_state_1.useLocalState)({
+        schema,
+        setValue,
+        value,
+        defaultValue,
+    });
+    const onCheckBoxChange = (0, react_1.useCallback)((e) => {
+        const val = e.target.checked
+            ? nullishValue
+            : (0, create_zod_values_1.createZodValues)(innerSchema, z, zodTypes);
+        setLocalValue(() => val, false, false);
+    }, [innerSchema, nullishValue, setLocalValue, z, zodTypes]);
+    const save = (0, react_1.useCallback)(() => {
+        onSave(() => value, false, false);
+    }, [onSave, value]);
+    return ((0, jsx_runtime_1.jsxs)(Fieldset_1.Fieldset, { shouldPad: mayPad, success: localValue.zodValidation.success, children: [localValue.value === nullishValue ? ((0, jsx_runtime_1.jsx)(SchemaLabel_1.SchemaLabel, { isDefaultValue: localValue.value === defaultValue, jsonPath: jsonPath, onReset: reset, onSave: save, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, valid: localValue.zodValidation.success, saveDisabledByParent: saveDisabledByParent, suffix: null })) : ((0, jsx_runtime_1.jsx)(ZodSwitch_1.ZodSwitch, { value: localValue.value, setValue: setLocalValue, jsonPath: jsonPath, schema: innerSchema, defaultValue: value, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: false })), (0, jsx_runtime_1.jsxs)("div", { style: checkBoxWrapper, children: [(0, jsx_runtime_1.jsx)(Checkbox_1.Checkbox, { checked: isChecked, onChange: onCheckBoxChange, disabled: false, name: jsonPath.join('.') }), (0, jsx_runtime_1.jsx)(layout_1.Spacing, { x: 1 }), (0, jsx_runtime_1.jsx)("div", { style: labelStyle, children: String(nullishValue) })] })] }));
+};
+exports.ZodOrNullishEditor = ZodOrNullishEditor;

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { z } from 'zod';
+import type { JSONPath } from './zod-types';
+import type { UpdaterFunction } from './ZodSwitch';
+export declare const ZodStaticFileEditor: React.FC<{
+    schema: z.ZodTypeAny;
+    jsonPath: JSONPath;
+    value: string;
+    defaultValue: string;
+    setValue: UpdaterFunction<string>;
+    onSave: (updater: (oldState: string) => string) => void;
+    showSaveButton: boolean;
+    onRemove: null | (() => void);
+    saving: boolean;
+    saveDisabledByParent: boolean;
+    mayPad: boolean;
+}>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodStaticFileEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const remotion_1 = require("remotion");
+const Checkmark_1 = require("../../../icons/Checkmark");
+const get_zod_if_possible_1 = require("../../get-zod-if-possible");
+const ComboBox_1 = require("../../NewComposition/ComboBox");
+const local_state_1 = require("./local-state");
+const SchemaLabel_1 = require("./SchemaLabel");
+const Fieldset_1 = require("./Fieldset");
+const ZodFieldValidation_1 = require("./ZodFieldValidation");
+const container = {
+    width: '100%',
+};
+const ZodStaticFileEditor = ({ schema, jsonPath, setValue, defaultValue, value, onSave, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
+    const z = (0, get_zod_if_possible_1.useZodIfPossible)();
+    if (!z) {
+        throw new Error('expected zod');
+    }
+    const { localValue, onChange: setLocalValue, reset, } = (0, local_state_1.useLocalState)({
+        schema,
+        setValue,
+        value,
+        defaultValue,
+    });
+    const def = schema._def;
+    const typeName = def.typeName;
+    if (typeName !== z.ZodFirstPartyTypeKind.ZodString) {
+        throw new Error('expected enum');
+    }
+    const isRoot = jsonPath.length === 0;
+    const comboBoxValues = (0, react_1.useMemo)(() => {
+        return (0, remotion_1.getStaticFiles)().map((option) => {
+            return {
+                value: option.src,
+                label: option.name,
+                id: option.src,
+                keyHint: null,
+                leftItem: option.src === value ? (0, jsx_runtime_1.jsx)(Checkmark_1.Checkmark, {}) : null,
+                onClick: (id) => {
+                    setLocalValue(() => id, false, false);
+                },
+                quickSwitcherLabel: null,
+                subMenu: null,
+                type: 'item',
+            };
+        });
+    }, [setLocalValue, value]);
+    const save = (0, react_1.useCallback)(() => {
+        onSave(() => value);
+    }, [onSave, value]);
+    return ((0, jsx_runtime_1.jsxs)(Fieldset_1.Fieldset, { shouldPad: mayPad, success: localValue.zodValidation.success, children: [(0, jsx_runtime_1.jsx)(SchemaLabel_1.SchemaLabel, { onSave: save, showSaveButton: showSaveButton, isDefaultValue: localValue.value === defaultValue, onReset: reset, jsonPath: jsonPath, onRemove: onRemove, saving: saving, valid: localValue.zodValidation.success, saveDisabledByParent: saveDisabledByParent, suffix: null }), (0, jsx_runtime_1.jsx)("div", { style: isRoot ? undefined : container, children: (0, jsx_runtime_1.jsx)(ComboBox_1.Combobox, { values: comboBoxValues, selectedId: localValue.value, title: value }) }), (0, jsx_runtime_1.jsx)(ZodFieldValidation_1.ZodFieldValidation, { path: jsonPath, localValue: localValue })] }));
+};
+exports.ZodStaticFileEditor = ZodStaticFileEditor;

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { z } from 'zod';
+import type { JSONPath } from './zod-types';
+import type { UpdaterFunction } from './ZodSwitch';
+export declare const ZodStringEditor: React.FC<{
+    schema: z.ZodTypeAny;
+    jsonPath: JSONPath;
+    value: string;
+    defaultValue: string;
+    setValue: UpdaterFunction<string>;
+    onSave: UpdaterFunction<string>;
+    onRemove: null | (() => void);
+    showSaveButton: boolean;
+    saving: boolean;
+    saveDisabledByParent: boolean;
+    mayPad: boolean;
+}>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodStringEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const get_zod_if_possible_1 = require("../../get-zod-if-possible");
+const RemInput_1 = require("../../NewComposition/RemInput");
+const local_state_1 = require("./local-state");
+const SchemaLabel_1 = require("./SchemaLabel");
+const Fieldset_1 = require("./Fieldset");
+const ZodFieldValidation_1 = require("./ZodFieldValidation");
+const fullWidth = {
+    width: '100%',
+};
+const ZodStringEditor = ({ jsonPath, value, setValue, showSaveButton, defaultValue, schema, onSave, onRemove, saving, saveDisabledByParent, mayPad, }) => {
+    const z = (0, get_zod_if_possible_1.useZodIfPossible)();
+    if (!z) {
+        throw new Error('expected zod');
+    }
+    const { localValue, onChange: setLocalValue, reset, } = (0, local_state_1.useLocalState)({
+        schema,
+        setValue,
+        value,
+        defaultValue,
+    });
+    const onChange = (0, react_1.useCallback)((e) => {
+        setLocalValue(() => e.target.value, false, false);
+    }, [setLocalValue]);
+    const save = (0, react_1.useCallback)(() => {
+        onSave(() => value, false, false);
+    }, [onSave, value]);
+    return ((0, jsx_runtime_1.jsxs)(Fieldset_1.Fieldset, { shouldPad: mayPad, success: false, children: [(0, jsx_runtime_1.jsx)(SchemaLabel_1.SchemaLabel, { isDefaultValue: localValue.value === defaultValue, jsonPath: jsonPath, onReset: reset, onSave: save, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, valid: localValue.zodValidation.success, saveDisabledByParent: saveDisabledByParent, suffix: null }), (0, jsx_runtime_1.jsxs)("div", { style: fullWidth, children: [(0, jsx_runtime_1.jsx)(RemInput_1.RemotionInput, { value: localValue.value, status: localValue.zodValidation ? 'ok' : 'error', placeholder: jsonPath.join('.'), onChange: onChange, rightAlign: false, name: jsonPath.join('.') }), (0, jsx_runtime_1.jsx)(ZodFieldValidation_1.ZodFieldValidation, { path: jsonPath, localValue: localValue })] })] }));
+};
+exports.ZodStringEditor = ZodStringEditor;

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { z } from 'zod';
+import type { JSONPath } from './zod-types';
+export type UpdaterFunction<T> = (updater: (oldValue: T) => T, forceApply: boolean, increment: boolean) => void;
+export declare const ZodSwitch: React.FC<{
+    schema: z.ZodTypeAny;
+    jsonPath: JSONPath;
+    value: unknown;
+    defaultValue: unknown;
+    setValue: UpdaterFunction<unknown>;
+    onSave: UpdaterFunction<unknown>;
+    showSaveButton: boolean;
+    onRemove: null | (() => void);
+    saving: boolean;
+    saveDisabledByParent: boolean;
+    mayPad: boolean;
+}>;

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodSwitch = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const get_zod_if_possible_1 = require("../../get-zod-if-possible");
+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, value, setValue, defaultValue, onSave, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
+    const def = schema._def;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const typeName = def.typeName;
+    const z = (0, get_zod_if_possible_1.useZodIfPossible)();
+    if (!z) {
+        throw new Error('expected zod');
+    }
+    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, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodString) {
+        if (value.startsWith(window.remotion_staticBase)) {
+            return ((0, jsx_runtime_1.jsx)(ZodStaticFileEditor_1.ZodStaticFileEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+        }
+        return ((0, jsx_runtime_1.jsx)(ZodStringEditor_1.ZodStringEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodDate) {
+        return ((0, jsx_runtime_1.jsx)(ZodDateEditor_1.ZodDateEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodNumber) {
+        return ((0, jsx_runtime_1.jsx)(ZodNumberEditor_1.ZodNumberEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodBoolean) {
+        return ((0, jsx_runtime_1.jsx)(ZodBooleanEditor_1.ZodBooleanEditor, { value: value, setValue: setValue, jsonPath: jsonPath, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad, schema: schema }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodUndefined) {
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'undefined', saving: saving, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodNull) {
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'null', saving: saving, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodAny) {
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'any (not editable)', saving: saving, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodBigInt) {
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'BigInt (not editable)', saving: saving, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodUnknown) {
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: 'unknown (not editable)', saving: saving, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodArray) {
+        return ((0, jsx_runtime_1.jsx)(ZodArrayEditor_1.ZodArrayEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodEnum) {
+        return ((0, jsx_runtime_1.jsx)(ZodEnumEditor_1.ZodEnumEditor, { setValue: setValue, value: value, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodEffects) {
+        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, onSave: onSave, defaultValue: defaultValue, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+        }
+        return ((0, jsx_runtime_1.jsx)(ZodEffectEditor_1.ZodEffectEditor, { value: value, setValue: setValue, jsonPath: jsonPath, schema: schema, defaultValue: defaultValue, onSave: onSave, showSaveButton: showSaveButton, onRemove: onRemove, saving: saving, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodUnion) {
+        return ((0, jsx_runtime_1.jsx)(ZodUnionEditor_1.ZodUnionEditor, { schema: schema, showSaveButton: showSaveButton, jsonPath: jsonPath, value: value, defaultValue: defaultValue, setValue: setValue, onSave: onSave, onRemove: onRemove, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodOptional) {
+        return ((0, jsx_runtime_1.jsx)(ZodOptionalEditor_1.ZodOptionalEditor, { jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodNullable) {
+        return ((0, jsx_runtime_1.jsx)(ZodNullableEditor_1.ZodNullableEditor, { jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    if (typeName === z.ZodFirstPartyTypeKind.ZodDefault) {
+        return ((0, jsx_runtime_1.jsx)(ZodDefaultEditor_1.ZodDefaultEditor, { jsonPath: jsonPath, showSaveButton: showSaveButton, defaultValue: defaultValue, value: value, setValue: setValue, onSave: onSave, onRemove: onRemove, schema: schema, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+    }
+    return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, showSaveButton: showSaveButton, label: `${typeName} (not editable)`, saving: saving, mayPad: mayPad }));
+};
+exports.ZodSwitch = ZodSwitch;

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

@@ -0,0 +1,17 @@
+/// <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;
+    value: unknown;
+    defaultValue: unknown;
+    schema: z.ZodTypeAny;
+    setValue: UpdaterFunction<unknown>;
+    onSave: UpdaterFunction<unknown>;
+    onRemove: null | (() => void);
+    saving: boolean;
+    saveDisabledByParent: boolean;
+    mayPad: boolean;
+}>;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodUnionEditor = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const get_zod_if_possible_1 = require("../../get-zod-if-possible");
+const ZodNonEditableValue_1 = require("./ZodNonEditableValue");
+const ZodOrNullishEditor_1 = require("./ZodOrNullishEditor");
+const findNull = (value, zodType) => {
+    const nullIndex = value.findIndex((v) => v._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull ||
+        v._def.typeName === zodType.ZodFirstPartyTypeKind.ZodUndefined);
+    if (nullIndex === -1) {
+        return null;
+    }
+    const nullishValue = value[nullIndex]._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull
+        ? null
+        : undefined;
+    const otherSchema = value[nullIndex === 0 ? 1 : 0];
+    const otherSchemaIsAlsoNullish = otherSchema._def.typeName === zodType.ZodFirstPartyTypeKind.ZodNull ||
+        otherSchema._def.typeName === zodType.ZodFirstPartyTypeKind.ZodUndefined;
+    return {
+        nullIndex,
+        nullishValue,
+        otherSchema,
+        otherSchemaIsAlsoNullish,
+    };
+};
+const ZodUnionEditor = ({ jsonPath, schema, setValue, onSave, defaultValue, value, showSaveButton, onRemove, saving, saveDisabledByParent, mayPad, }) => {
+    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', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
+    }
+    if (options.length < 2) {
+        return ((0, jsx_runtime_1.jsx)(ZodNonEditableValue_1.ZonNonEditableValue, { jsonPath: jsonPath, label: 'Union with less than 2 options not editable', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
+    }
+    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', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
+    }
+    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', showSaveButton: showSaveButton, saving: saving, mayPad: mayPad }));
+    }
+    return ((0, jsx_runtime_1.jsx)(ZodOrNullishEditor_1.ZodOrNullishEditor, { defaultValue: defaultValue, jsonPath: jsonPath, onRemove: onRemove, onSave: onSave, schema: schema, innerSchema: otherSchema, setValue: setValue, showSaveButton: showSaveButton, value: value, nullishValue: nullishValue, saving: saving, saveDisabledByParent: saveDisabledByParent, mayPad: mayPad }));
+};
+exports.ZodUnionEditor = ZodUnionEditor;

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZodValues = void 0;
+const createZodValues = (schema, zodRuntime, zodTypes) => {
+    if (!schema) {
+        throw new Error('Invalid zod schema');
+    }
+    const def = schema._def;
+    const typeName = def.typeName;
+    switch (typeName) {
+        case zodRuntime.ZodFirstPartyTypeKind.ZodString:
+            return '';
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNumber:
+            return 0;
+        case zodRuntime.ZodFirstPartyTypeKind.ZodBigInt:
+            return BigInt(0);
+        case zodRuntime.ZodFirstPartyTypeKind.ZodBoolean:
+            return false;
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNaN:
+            return NaN;
+        case zodRuntime.ZodFirstPartyTypeKind.ZodDate:
+            return new Date();
+        case zodRuntime.ZodFirstPartyTypeKind.ZodSymbol:
+            return Symbol('remotion');
+        case zodRuntime.ZodFirstPartyTypeKind.ZodUndefined:
+            return undefined;
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNull:
+            return null;
+        case zodRuntime.ZodFirstPartyTypeKind.ZodAny:
+            throw new Error('Cannot create a value for type z.any()');
+        case zodRuntime.ZodFirstPartyTypeKind.ZodUnknown:
+            throw new Error('Cannot create a value for type z.unknown()');
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNever:
+            throw new Error('Cannot create a value for type z.never()');
+        case zodRuntime.ZodFirstPartyTypeKind.ZodVoid:
+            return undefined;
+        case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
+            const shape = def.shape();
+            const keys = Object.keys(shape);
+            const returnValue = keys.reduce((existing, key) => {
+                existing[key] = (0, exports.createZodValues)(shape[key], zodRuntime, zodTypes);
+                return existing;
+            }, {});
+            return returnValue;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
+            return [
+                (0, exports.createZodValues)(def.type, zodRuntime, zodTypes),
+            ];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
+            const firstOptions = def.options[0];
+            return firstOptions
+                ? (0, exports.createZodValues)(firstOptions, zodRuntime, zodTypes)
+                : undefined;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
+            const options = def.options[0];
+            return (0, exports.createZodValues)(options, zodRuntime, zodTypes);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
+            return def.value;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodEffects: {
+            if (zodTypes &&
+                schema._def.description ===
+                    zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
+                return '#ffffff';
+            }
+            return (0, exports.createZodValues)(def.schema, zodRuntime, zodTypes);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
+            const { left, right } = def;
+            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, 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, zodTypes));
+            return items;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
+            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, 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, zodTypes);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
+            const defType = def;
+            const values = (0, exports.createZodValues)(defType.valueType, zodRuntime, zodTypes);
+            return new Set([values]);
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodFunction: {
+            throw new Error('Cannot create a value for type function');
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodEnum: {
+            const { values } = def;
+            return values[0];
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodNativeEnum: {
+            return 0;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
+            const defType = def;
+            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, zodTypes);
+            return value;
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
+            const defType = def;
+            return defType.defaultValue();
+        }
+        case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
+            const defType = def;
+            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, 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, 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, zodTypes);
+            return value;
+        }
+        default:
+            throw new Error('Not implemented: ' + typeName);
+    }
+};
+exports.createZodValues = createZodValues;

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,30 @@
+"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 (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    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 type EnumPath = (string | number)[];
+export declare const extractEnumJsonPaths: (schema: Zod.ZodTypeAny, zodRuntime: ZodType, currentPath: (string | number)[]) => (string | number)[][];