@remotion/studio 4.0.424 → 4.0.426

package/dist/esm/index.mjs

@@ -201,6 +201,110 @@ var restartStudio = () => {
 // src/api/save-default-props.ts
 import { getRemotionEnvironment as getRemotionEnvironment4 } from "remotion";
 
+// src/components/RenderModal/SchemaEditor/zod-schema-type.ts
+var getZodDef = (schema) => {
+  if (schema._def)
+    return schema._def;
+  if (schema._zod)
+    return schema._zod.def;
+  throw new Error("Invalid zod schema: missing _def and _zod");
+};
+var v3TypeNameMap = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBoolean: "boolean",
+  ZodObject: "object",
+  ZodArray: "array",
+  ZodEnum: "enum",
+  ZodUnion: "union",
+  ZodDiscriminatedUnion: "discriminatedUnion",
+  ZodOptional: "optional",
+  ZodNullable: "nullable",
+  ZodDefault: "default",
+  ZodTuple: "tuple",
+  ZodDate: "date",
+  ZodAny: "any",
+  ZodUnknown: "unknown",
+  ZodBigInt: "bigint",
+  ZodNull: "null",
+  ZodUndefined: "undefined",
+  ZodEffects: "effects",
+  ZodLiteral: "literal",
+  ZodRecord: "record",
+  ZodNever: "never",
+  ZodVoid: "void",
+  ZodNaN: "nan",
+  ZodSymbol: "symbol",
+  ZodIntersection: "intersection",
+  ZodMap: "map",
+  ZodSet: "set",
+  ZodLazy: "lazy",
+  ZodFunction: "function",
+  ZodNativeEnum: "nativeEnum",
+  ZodCatch: "catch",
+  ZodPromise: "promise",
+  ZodBranded: "branded",
+  ZodPipeline: "pipeline"
+};
+var isZodV3Schema = (schema) => {
+  const def = getZodDef(schema);
+  return "typeName" in def;
+};
+var getZodSchemaType = (schema) => {
+  const def = getZodDef(schema);
+  if ("typeName" in def) {
+    const { typeName } = def;
+    return v3TypeNameMap[typeName] ?? typeName;
+  }
+  const { type } = def;
+  if (type === "union" && def.discriminator !== undefined) {
+    return "discriminatedUnion";
+  }
+  return type;
+};
+var getZodSchemaDescription = (schema) => {
+  if (isZodV3Schema(schema)) {
+    return getZodDef(schema).description;
+  }
+  return schema.description;
+};
+var getObjectShape = (schema) => {
+  const { shape } = getZodDef(schema);
+  return typeof shape === "function" ? shape() : shape;
+};
+var getArrayElement = (schema) => {
+  const def = getZodDef(schema);
+  return isZodV3Schema(schema) ? def.type : def.element;
+};
+var getInnerType = (schema) => {
+  return getZodDef(schema).innerType;
+};
+var getEffectsInner = (schema) => {
+  return getZodDef(schema).schema;
+};
+var getUnionOptions = (schema) => {
+  return getZodDef(schema).options;
+};
+var getIntersectionSchemas = (schema) => {
+  const def = getZodDef(schema);
+  return { left: def.left, right: def.right };
+};
+var getTupleItems = (schema) => {
+  return getZodDef(schema).items;
+};
+var getRecordValueType = (schema) => {
+  return getZodDef(schema).valueType;
+};
+var getRecordKeyType = (schema) => {
+  return getZodDef(schema).keyType;
+};
+var getPipelineOutput = (schema) => {
+  return getZodDef(schema).out;
+};
+var getBrandedInner = (schema) => {
+  return isZodV3Schema(schema) ? getZodDef(schema).type : schema;
+};
+
 // src/components/RenderModal/SchemaEditor/extract-enum-json-paths.ts
 var extractEnumJsonPaths = ({
   schema,
@@ -208,11 +312,14 @@ var extractEnumJsonPaths = ({
   currentPath,
   zodTypes
 }) => {
-  const def = schema._def;
-  const typeName = def.typeName;
+  const description = getZodSchemaDescription(schema);
+  if (zodTypes && description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
+    return [currentPath];
+  }
+  const typeName = getZodSchemaType(schema);
   switch (typeName) {
-    case zodRuntime.ZodFirstPartyTypeKind.ZodObject: {
-      const shape = def.shape();
+    case "object": {
+      const shape = getObjectShape(schema);
       const keys = Object.keys(shape);
       return keys.map((key) => {
         return extractEnumJsonPaths({
@@ -223,16 +330,16 @@ var extractEnumJsonPaths = ({
         });
       }).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodArray: {
+    case "array": {
       return extractEnumJsonPaths({
-        schema: def.type,
+        schema: getArrayElement(schema),
         zodRuntime,
         currentPath: [...currentPath, "[]"],
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodUnion: {
-      return def.options.map((option) => {
+    case "union": {
+      return getUnionOptions(schema).map((option) => {
         return extractEnumJsonPaths({
           schema: option,
           zodRuntime,
@@ -241,8 +348,8 @@ var extractEnumJsonPaths = ({
         });
       }).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-      return def.options.map((op) => {
+    case "discriminatedUnion": {
+      return getUnionOptions(schema).map((op) => {
         return extractEnumJsonPaths({
           schema: op,
           zodRuntime,
@@ -251,22 +358,19 @@ var extractEnumJsonPaths = ({
         });
       }).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 extractEnumJsonPaths({
-        schema: def.schema,
+        schema: getEffectsInner(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodIntersection: {
-      const { left, right } = def;
+    case "intersection": {
+      const { left, right } = getIntersectionSchemas(schema);
       const leftValue = extractEnumJsonPaths({
         schema: left,
         zodRuntime,
@@ -281,109 +385,94 @@ var extractEnumJsonPaths = ({
       });
       return [...leftValue, ...rightValue];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodTuple: {
-      return def.items.map((item, i) => extractEnumJsonPaths({
+    case "tuple": {
+      return getTupleItems(schema).map((item, i) => extractEnumJsonPaths({
         schema: item,
         zodRuntime,
         currentPath: [...currentPath, i],
         zodTypes
       })).flat(1);
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodRecord: {
-      const values = extractEnumJsonPaths({
-        schema: def.valueType,
+    case "record": {
+      const recordPath = [...currentPath, "{}"];
+      const keyResults = extractEnumJsonPaths({
+        schema: getRecordKeyType(schema),
         zodRuntime,
-        currentPath: [...currentPath, "{}"],
+        currentPath: recordPath,
         zodTypes
       });
-      return values;
+      const valueResults = extractEnumJsonPaths({
+        schema: 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 = extractEnumJsonPaths({
-        schema: defType.innerType,
-        zodRuntime,
-        currentPath,
-        zodTypes
-      });
-      return value;
-    }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodNullable: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.innerType,
-        zodRuntime,
-        currentPath,
-        zodTypes
-      });
-      return value;
-    }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodDefault: {
-      const defType = def;
+    case "optional":
+    case "nullable":
+    case "catch": {
       return extractEnumJsonPaths({
-        schema: defType.innerType,
+        schema: getInnerType(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodCatch: {
-      const defType = def;
+    case "default": {
       return extractEnumJsonPaths({
-        schema: defType.innerType,
+        schema: getInnerType(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodPromise: {
+    case "promise": {
       return [];
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodBranded: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.type,
+    case "branded": {
+      return extractEnumJsonPaths({
+        schema: getBrandedInner(schema),
         zodRuntime,
         currentPath,
         zodTypes
       });
-      return value;
     }
-    case zodRuntime.ZodFirstPartyTypeKind.ZodPipeline: {
-      const defType = def;
-      const value = extractEnumJsonPaths({
-        schema: defType.out,
+    case "pipeline":
+    case "pipe": {
+      return extractEnumJsonPaths({
+        schema: 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:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodLazy:
-    case zodRuntime.ZodFirstPartyTypeKind.ZodSet: {
+    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: