@remotion/studio 4.0.424 → 4.0.426

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

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractEnumJsonPaths = void 0;
+const zod_schema_type_1 = require("./zod-schema-type");
 const extractEnumJsonPaths = ({ schema, zodRuntime, currentPath, zodTypes, }) => {
-    const def = schema._def;
-    const typeName = def.typeName;
+    // In v4, .refine()/.describe() don't wrap in effects — the description
+    // lives directly on the schema. Check for branded descriptions early
+    // so they are detected regardless of the underlying type.
+    const description = (0, zod_schema_type_1.getZodSchemaDescription)(schema);
+    if (zodTypes &&
+        description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+        return [currentPath];
+    }
+    const typeName = (0, zod_schema_type_1.getZodSchemaType)(schema);
     switch (typeName) {
-        case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
-            const shape = def.shape();
+        case 'object': {
+            const shape = (0, zod_schema_type_1.getObjectShape)(schema);
             const keys = Object.keys(shape);
             return keys
                 .map((key) => {
@@ -19,16 +27,16 @@ const extractEnumJsonPaths = ({ schema, zodRuntime, currentPath, zodTypes, }) =>
             })
                 .flat(1);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
+        case 'array': {
             return (0, exports.extractEnumJsonPaths)({
-                schema: def.type,
+                schema: (0, zod_schema_type_1.getArrayElement)(schema),
                 zodRuntime,
                 currentPath: [...currentPath, '[]'],
                 zodTypes,
             });
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
-            return def.options
+        case 'union': {
+            return (0, zod_schema_type_1.getUnionOptions)(schema)
                 .map((option) => {
                 return (0, exports.extractEnumJsonPaths)({
                     schema: option,
@@ -39,8 +47,8 @@ const extractEnumJsonPaths = ({ schema, zodRuntime, currentPath, zodTypes, }) =>
             })
                 .flat(1);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-            return def.options
+        case 'discriminatedUnion': {
+            return (0, zod_schema_type_1.getUnionOptions)(schema)
                 .map((op) => {
                 return (0, exports.extractEnumJsonPaths)({
                     schema: op,
@@ -51,24 +59,19 @@ const extractEnumJsonPaths = ({ schema, zodRuntime, currentPath, zodTypes, }) =>
             })
                 .flat(1);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodLiteral: {
+        case 'literal': {
             return [currentPath];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodEffects: {
-            if (zodTypes &&
-                schema._def.description ===
-                    zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
-                return [currentPath];
-            }
+        case 'effects': {
             return (0, exports.extractEnumJsonPaths)({
-                schema: def.schema,
+                schema: (0, zod_schema_type_1.getEffectsInner)(schema),
                 zodRuntime,
                 currentPath,
                 zodTypes,
             });
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
-            const { left, right } = def;
+        case 'intersection': {
+            const { left, right } = (0, zod_schema_type_1.getIntersectionSchemas)(schema);
             const leftValue = (0, exports.extractEnumJsonPaths)({
                 schema: left,
                 zodRuntime,
@@ -83,8 +86,8 @@ const extractEnumJsonPaths = ({ schema, zodRuntime, currentPath, zodTypes, }) =>
             });
             return [...leftValue, ...rightValue];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
-            return def.items
+        case 'tuple': {
+            return (0, zod_schema_type_1.getTupleItems)(schema)
                 .map((item, i) => (0, exports.extractEnumJsonPaths)({
                 schema: item,
                 zodRuntime,
@@ -93,104 +96,86 @@ const extractEnumJsonPaths = ({ schema, zodRuntime, currentPath, zodTypes, }) =>
             }))
                 .flat(1);
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
-            const values = (0, exports.extractEnumJsonPaths)({
-                schema: def.valueType,
+        case 'record': {
+            const recordPath = [...currentPath, '{}'];
+            const keyResults = (0, exports.extractEnumJsonPaths)({
+                schema: (0, zod_schema_type_1.getRecordKeyType)(schema),
                 zodRuntime,
-                currentPath: [...currentPath, '{}'],
+                currentPath: recordPath,
                 zodTypes,
             });
-            return values;
+            const valueResults = (0, exports.extractEnumJsonPaths)({
+                schema: (0, zod_schema_type_1.getRecordValueType)(schema),
+                zodRuntime,
+                currentPath: recordPath,
+                zodTypes,
+            });
+            return [...keyResults, ...valueResults];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodFunction: {
+        case 'function': {
             throw new Error('Cannot create a value for type function');
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodEnum: {
+        case 'enum': {
             return [currentPath];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNativeEnum: {
+        case 'nativeEnum': {
             return [];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodOptional: {
-            const defType = def;
-            const value = (0, exports.extractEnumJsonPaths)({
-                schema: defType.innerType,
-                zodRuntime,
-                currentPath,
-                zodTypes,
-            });
-            return value;
-        }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
-            const defType = def;
-            const value = (0, exports.extractEnumJsonPaths)({
-                schema: defType.innerType,
-                zodRuntime,
-                currentPath,
-                zodTypes,
-            });
-            return value;
-        }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
-            const defType = def;
+        case 'optional':
+        case 'nullable':
+        case 'catch': {
             return (0, exports.extractEnumJsonPaths)({
-                schema: defType.innerType,
+                schema: (0, zod_schema_type_1.getInnerType)(schema),
                 zodRuntime,
                 currentPath,
                 zodTypes,
             });
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
-            const defType = def;
+        case 'default': {
             return (0, exports.extractEnumJsonPaths)({
-                schema: defType.innerType,
+                schema: (0, zod_schema_type_1.getInnerType)(schema),
                 zodRuntime,
                 currentPath,
                 zodTypes,
             });
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
+        case 'promise': {
             return [];
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const defType = def;
-            const value = (0, exports.extractEnumJsonPaths)({
-                schema: defType.type,
+        case 'branded': {
+            return (0, exports.extractEnumJsonPaths)({
+                schema: (0, zod_schema_type_1.getBrandedInner)(schema),
                 zodRuntime,
                 currentPath,
                 zodTypes,
             });
-            return value;
         }
-        case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const defType = def;
-            const value = (0, exports.extractEnumJsonPaths)({
-                schema: defType.out,
+        case 'pipeline':
+        case 'pipe': {
+            return (0, exports.extractEnumJsonPaths)({
+                schema: (0, zod_schema_type_1.getPipelineOutput)(schema),
                 zodRuntime,
                 currentPath,
                 zodTypes,
             });
-            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
+        }
+        case 'string':
+        case 'number':
+        case 'bigint':
+        case 'boolean':
+        case 'nan':
+        case 'date':
+        case 'symbol':
+        case 'undefined':
+        case 'null':
+        case 'any':
+        case 'unknown':
+        case 'never':
+        case 'void':
+        case 'map':
+        case 'lazy':
+        case 'set':
+        case 'custom': {
             return [];
         }
         default:

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

@@ -1,9 +1,9 @@
 import React from 'react';
-import type { z } from 'zod';
 import type { UpdaterFunction } from './ZodSwitch';
+import type { AnyZodSchema, ZodSafeParseResult } from './zod-schema-type';
 export type LocalState<T> = {
     value: T;
-    zodValidation: z.SafeParseReturnType<unknown, unknown>;
+    zodValidation: ZodSafeParseResult;
     keyStabilityRevision: number;
 };
 export type RevisionContextType = {
@@ -12,7 +12,7 @@ export type RevisionContextType = {
 export declare const RevisionContext: React.Context<RevisionContextType>;
 export declare const useLocalState: <T>({ unsavedValue, schema, setValue, savedValue, }: {
     unsavedValue: T;
-    schema: z.ZodTypeAny;
+    schema: AnyZodSchema;
     setValue: UpdaterFunction<T>;
     savedValue: T;
 }) => {

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

@@ -5,6 +5,7 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const remotion_1 = require("remotion");
 const deep_equal_1 = require("./deep-equal");
+const zod_schema_type_1 = require("./zod-schema-type");
 exports.RevisionContext = (0, react_1.createContext)({
     childResetRevision: 0,
 });
@@ -16,7 +17,7 @@ const useLocalState = ({ unsavedValue, schema, setValue, savedValue, }) => {
             [parentRevision]: {
                 value: unsavedValue,
                 keyStabilityRevision: 0,
-                zodValidation: schema.safeParse(unsavedValue),
+                zodValidation: (0, zod_schema_type_1.zodSafeParse)(schema, unsavedValue),
             },
         };
     });
@@ -26,7 +27,7 @@ const useLocalState = ({ unsavedValue, schema, setValue, savedValue, }) => {
             return {
                 value: unsavedValue,
                 keyStabilityRevision: 0,
-                zodValidation: schema.safeParse(unsavedValue),
+                zodValidation: (0, zod_schema_type_1.zodSafeParse)(schema, unsavedValue),
             };
         }
         return localValueOrNull[parentRevision];
@@ -45,7 +46,7 @@ const useLocalState = ({ unsavedValue, schema, setValue, savedValue, }) => {
         return (localUnsavedValue !== null && localUnsavedValue !== void 0 ? localUnsavedValue : {
             value: savedValue,
             keyStabilityRevision: 0,
-            zodValidation: schema.safeParse(savedValue),
+            zodValidation: (0, zod_schema_type_1.zodSafeParse)(schema, savedValue),
         });
     }, [localUnsavedValue, savedValue, schema]);
     const stateRef = (0, react_1.useRef)(currentLocalValue);
@@ -59,7 +60,7 @@ const useLocalState = ({ unsavedValue, schema, setValue, savedValue, }) => {
         if (isSame) {
             return;
         }
-        const safeParse = schema.safeParse(newValue);
+        const safeParse = (0, zod_schema_type_1.zodSafeParse)(schema, newValue);
         if (safeParse.success || forceApply) {
             setValue(updater, forceApply, increment);
         }

package/dist/components/RenderModal/SchemaEditor/zod-schema-type.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Normalizes zod schema type detection across v3 and v4.
+ *
+ * v3 schemas have `_def.typeName` (e.g. "ZodString")
+ * v4 schemas have `_def.type` (e.g. "string") and `_zod` property
+ *
+ * This module provides a unified type name using v4-style lowercase strings,
+ * and accessor helpers that abstract v3/v4 `_def` property differences.
+ */
+/**
+ * Structural type for any Zod schema (v3 or v4).
+ *
+ * v3 schemas have `_def` with `typeName` property.
+ * v4 classic schemas have `_def` with `type` property.
+ * v4 core schemas have `_zod.def` with `type` property.
+ * At runtime, all zod schemas have `_def` (classic layer adds it for v4).
+ */
+export interface ZodValidationError {
+    format(): {
+        _errors: string[];
+    };
+    issues: readonly {
+        code: string;
+        message: string;
+        path: readonly PropertyKey[];
+    }[];
+}
+export type ZodSafeParseResult = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    error: ZodValidationError;
+};
+export interface AnyZodSchema {
+    readonly _def?: Record<string, any>;
+    readonly _zod?: {
+        def: Record<string, any>;
+        [key: string]: any;
+    };
+    readonly description?: string;
+}
+/**
+ * Call safeParse on any Zod schema (v3 or v4).
+ * All Zod schemas have safeParse at runtime, but some v4 internal types
+ * (like $ZodObject) don't declare it in their type definition.
+ */
+export declare const zodSafeParse: (schema: AnyZodSchema, data: unknown) => ZodSafeParseResult;
+export declare const getZodDef: (schema: AnyZodSchema) => Record<string, any>;
+export type ZodSchemaType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'enum' | 'union' | 'discriminatedUnion' | 'optional' | 'nullable' | 'default' | 'tuple' | 'date' | 'any' | 'unknown' | 'bigint' | 'null' | 'undefined' | 'effects' | 'literal' | 'record' | 'never' | (string & {});
+export declare const isZodV3Schema: (schema: AnyZodSchema) => boolean;
+/**
+ * Get the normalized type name for a zod schema (v3 or v4).
+ *
+ * In v4, discriminatedUnion is a union with a `discriminator` property on `_def`.
+ * This function returns 'discriminatedUnion' for that case.
+ */
+export declare const getZodSchemaType: (schema: AnyZodSchema) => ZodSchemaType;
+/**
+ * Get the description of a schema, handling v3 vs v4 differences.
+ *
+ * v3: _def.description
+ * v4: schema.description
+ */
+export declare const getZodSchemaDescription: (schema: AnyZodSchema) => string | undefined;
+/**
+ * Get the shape of an object schema.
+ * v3: _def.shape() (function)
+ * v4: _def.shape (plain object)
+ */
+export declare const getObjectShape: (schema: AnyZodSchema) => Record<string, AnyZodSchema>;
+/**
+ * Get the element schema of an array.
+ * v3: _def.type
+ * v4: _def.element
+ */
+export declare const getArrayElement: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the inner type for wrappers like optional, nullable, default, catch.
+ * Both v3 and v4 use _def.innerType.
+ */
+export declare const getInnerType: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the inner schema for effects (v3 only - v4 doesn't wrap).
+ * v3: _def.schema
+ */
+export declare const getEffectsInner: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the literal value.
+ * v3: _def.value (single value)
+ * v4: _def.values (array of values) - take the first
+ */
+export declare const getLiteralValue: (schema: AnyZodSchema) => unknown;
+/**
+ * Get enum values as an array of strings.
+ * v3: _def.values (string[])
+ * v4: _def.entries (Record<string,string>) - convert to values array
+ */
+export declare const getEnumValues: (schema: AnyZodSchema) => string[];
+/**
+ * Get the first valid value from an enum schema.
+ * Handles both regular enums and nativeEnums.
+ *
+ * In v4, nativeEnums are represented as regular enums with bidirectional
+ * entries (e.g. { Apple: 0, "0": "Apple" }). This function filters out
+ * the reverse mappings to return actual enum values.
+ */
+export declare const getFirstEnumValue: (schema: AnyZodSchema) => unknown;
+/**
+ * Get the union/discriminatedUnion options array.
+ * Both v3 and v4 use _def.options.
+ */
+export declare const getUnionOptions: (schema: AnyZodSchema) => AnyZodSchema[];
+/**
+ * Get the default value from a ZodDefault.
+ * v3: _def.defaultValue() (function)
+ * v4: _def.defaultValue (plain value)
+ */
+export declare const getDefaultValue: (schema: AnyZodSchema) => unknown;
+/**
+ * Get the discriminator key from a discriminated union.
+ * v3: _def.discriminator
+ * v4: _def.discriminator
+ */
+export declare const getDiscriminator: (schema: AnyZodSchema) => string;
+/**
+ * Get all discriminator option keys from a discriminated union.
+ * v3: [..._def.optionsMap.keys()]
+ * v4: iterate options and extract literal values from discriminator field
+ */
+export declare const getDiscriminatedOptionKeys: (schema: AnyZodSchema) => string[];
+/**
+ * Get the option schema matching a discriminator value.
+ * v3: _def.optionsMap.get(value)
+ * v4: find matching option by inspecting literal values
+ */
+export declare const getDiscriminatedOption: (schema: AnyZodSchema, discriminatorValue: string) => AnyZodSchema | undefined;
+/**
+ * Get the left and right schemas from an intersection.
+ * Both v3 and v4 use _def.left and _def.right.
+ */
+export declare const getIntersectionSchemas: (schema: AnyZodSchema) => {
+    left: AnyZodSchema;
+    right: AnyZodSchema;
+};
+/**
+ * Get the items array from a tuple schema.
+ * Both v3 and v4 use _def.items.
+ */
+export declare const getTupleItems: (schema: AnyZodSchema) => AnyZodSchema[];
+/**
+ * Get the value type schema from a record.
+ * Both v3 and v4 use _def.valueType.
+ */
+export declare const getRecordValueType: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the key type schema from a record.
+ * Both v3 and v4 use _def.keyType.
+ */
+export declare const getRecordKeyType: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the output schema from a pipeline/pipe.
+ * Both v3 and v4 use _def.out.
+ */
+export declare const getPipelineOutput: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the input schema from a pipeline/pipe.
+ * Both v3 and v4 use _def.in.
+ */
+export declare const getPipelineInput: (schema: AnyZodSchema) => AnyZodSchema;
+/**
+ * Get the inner schema from a branded type.
+ * v3: _def.type
+ * v4: branded is the schema itself (branding is type-level only)
+ */
+export declare const getBrandedInner: (schema: AnyZodSchema) => AnyZodSchema;