π₯ Make videos programmatically with React
import type {ZodTypesType} from '../../get-zod-if-possible';
import {
type AnyZodSchema,
getArrayElement,
getBrandedInner,
getDefaultValue,
getEffectsInner,
getFirstEnumValue,
getInnerType,
getIntersectionSchemas,
getLiteralValue,
getObjectShape,
getPipelineInput,
getPipelineOutput,
getRecordKeyType,
getRecordValueType,
getTupleItems,
getUnionOptions,
getZodDef,
getZodSchemaDescription,
getZodSchemaType,
isZodV3Schema,
} from './zod-schema-type';
export const createZodValues = (
schema: AnyZodSchema,
zodRuntime: unknown,
zodTypes: ZodTypesType | null,
): unknown => {
if (!schema) {
throw new Error('Invalid zod schema');
}
// 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 = getZodSchemaDescription(schema);
if (zodTypes) {
if (description === zodTypes.ZodZypesInternals.REMOTION_COLOR_BRAND) {
return '#ffffff';
}
if (description === zodTypes.ZodZypesInternals.REMOTION_TEXTAREA_BRAND) {
return '';
}
if (description === zodTypes.ZodZypesInternals.REMOTION_MATRIX_BRAND) {
return [
[1, 0, 0],
[0, 1, 0],
[0, 0, 1],
];
}
}
const typeName = getZodSchemaType(schema);
switch (typeName) {
case 'string':
return '';
case 'number': {
const {checks} = getZodDef(schema);
if (checks) {
if (isZodV3Schema(schema)) {
for (const check of checks) {
if (check.kind === 'min') return check.value;
if (check.kind === 'max' && check.value < 0) return check.value;
}
} else {
for (const check of checks) {
const cd = check._zod?.def;
if (cd?.check === 'greater_than') return cd.value;
if (cd?.check === 'less_than' && cd.value < 0) return cd.value;
}
}
}
return 0;
}
case 'bigint':
return BigInt(0);
case 'boolean':
return false;
case 'nan':
return NaN;
case 'date':
return new Date();
case 'symbol':
return Symbol('remotion');
case 'undefined':
case 'void':
return undefined;
case 'null':
return null;
case 'any':
case 'custom':
throw new Error('Cannot create a value for type z.any()');
case 'unknown':
throw new Error('Cannot create a value for type z.unknown()');
case 'never':
throw new Error('Cannot create a value for type z.never()');
case 'object': {
const shape = getObjectShape(schema);
const keys = Object.keys(shape);
const returnValue = keys.reduce(
(existing, key) => {
existing[key] = createZodValues(shape[key], zodRuntime, zodTypes);
return existing;
},
{} as Record<string, unknown>,
);
return returnValue;
}
case 'array': {
return [createZodValues(getArrayElement(schema), zodRuntime, zodTypes)];
}
case 'union': {
const firstOption = getUnionOptions(schema)[0];
return firstOption
? createZodValues(firstOption, zodRuntime, zodTypes)
: undefined;
}
case 'discriminatedUnion': {
const firstOption = getUnionOptions(schema)[0];
return createZodValues(firstOption, zodRuntime, zodTypes);
}
case 'literal': {
return getLiteralValue(schema);
}
case 'effects': {
return createZodValues(getEffectsInner(schema), zodRuntime, zodTypes);
}
case 'intersection': {
const {left, right} = getIntersectionSchemas(schema);
const leftValue = 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 = 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 'tuple': {
return getTupleItems(schema).map((item) =>
createZodValues(item, zodRuntime, zodTypes),
);
}
case 'record': {
const values = createZodValues(
getRecordValueType(schema),
zodRuntime,
zodTypes,
);
return {key: values};
}
case 'map': {
const values = createZodValues(
getRecordValueType(schema),
zodRuntime,
zodTypes,
);
const key = createZodValues(
getRecordKeyType(schema),
zodRuntime,
zodTypes,
);
return new Map([[key, values]]);
}
case 'lazy': {
const type = getZodDef(schema).getter();
return createZodValues(type, zodRuntime, zodTypes);
}
case 'set': {
const values = createZodValues(
getZodDef(schema).valueType,
zodRuntime,
zodTypes,
);
return new Set([values]);
}
case 'function': {
throw new Error('Cannot create a value for type function');
}
case 'enum': {
return getFirstEnumValue(schema);
}
case 'nativeEnum': {
return 0;
}
case 'optional':
case 'nullable':
case 'catch': {
return createZodValues(getInnerType(schema), zodRuntime, zodTypes);
}
case 'default': {
return getDefaultValue(schema);
}
case 'promise': {
const def = getZodDef(schema);
// v3: _def.type, v4: _def.innerType
const inner = isZodV3Schema(schema) ? def.type : def.innerType;
const value = createZodValues(inner, zodRuntime, zodTypes);
return Promise.resolve(value);
}
case 'branded': {
return createZodValues(getBrandedInner(schema), zodRuntime, zodTypes);
}
case 'pipeline':
case 'pipe': {
const out = getPipelineOutput(schema);
// In v4, .transform() creates pipe { in, out: transform }.
// Since we don't apply transforms, use the input side.
if (getZodSchemaType(out) === 'transform') {
return createZodValues(getPipelineInput(schema), zodRuntime, zodTypes);
}
return createZodValues(out, zodRuntime, zodTypes);
}
default:
throw new Error('Not implemented: ' + typeName);
}
};