fully declare new schema in zod

Author: andykais

lib/parsers/template.zod.ts

@@ -1,9 +1,9 @@
 import { z } from 'https://deno.land/x/zod@v3.9.0/mod.ts'
 import * as t from '../template_input.zod.ts'
-import { assert } from '../../type-equality.ts'
+import { assert } from '../type-equality.ts'
 
 
-const Id = z.string().regex(/[a-zA-Z0-9-_]/)
+const ClipId = z.string().regex(/[a-zA-Z0-9-_]/)
 
 const Pixels = z.string().regex(/\d+px/)
 
@@ -16,29 +16,49 @@ const Color = z.string()
 const Timestamp = z.string() // I think we will delay parsing this till after we probe files because we need access to full file durations to resolve variables
 
 const Size = z.object({
-  width: z.union([Pixels, Percentage]).optional(),
-  height: z.union([Pixels, Percentage]).optional(),
-  relative_to: Id.optional(),
-})
+  width: z.union([Pixels, Percentage]).default('100%'),
+  height: z.union([Pixels, Percentage]).default('100%'),
+  relative_to: ClipId.optional(),
+}).strict()
 
 const AlignX = z.union([z.literal('left'), z.literal('right'), z.literal('center')])
 const AlignY = z.union([z.literal('top'), z.literal('bottom'), z.literal('center')])
 const Layout = Size.extend({
-  x: z.union([AlignX, z.object({ offset: z.union([Pixels, Percentage]).optional(), align: AlignX.optional() })]).optional(),
-  y: z.union([AlignY, z.object({ offset: z.union([Pixels, Percentage]).optional(), align: AlignY.optional() })]).optional(),
-})
+  x: z.union([AlignX, z.object({ offset: z.union([Pixels, Percentage]).optional(), align: AlignX.optional() })]).default('left').transform(val => typeof val === 'object' ?  val : { offset: '0px', align: val }),
+  y: z.union([AlignY, z.object({ offset: z.union([Pixels, Percentage]).optional(), align: AlignY.optional() })]).default('top').transform(val => typeof val === 'object' ?  val : { offset: '0px', align: val }),
+}).strict()
 
 const ClipBase = z.object({
-  id: Id.optional(),
+  id: ClipId.optional(),
   layout: Layout.optional(),
   crop: Layout.optional(),
+  zoompan: z.object({
+    keyframe: Timestamp,
+    zoom: Percentage.optional(),
+    x: z.union([Pixels, Percentage]).optional(),
+    y: z.union([Pixels, Percentage]).optional(),
+  }).strict().array().optional(),
   rotate: Degrees.optional(),
+  speed: Percentage.default('100%'),
+  framerate: z.object({
+    fps: z.number().min(0),
+    smooth: z.boolean().default(false),
+  }).strict().optional(),
+  transition: z.object({
+    fade_in: Timestamp.optional(),
+    fade_out: Timestamp.optional(),
+  }).strict().optional(),
+  trim: z.object({
+    start: Timestamp.optional(),
+    stop: Timestamp.optional(),
+    variable_length: z.union([z.literal('start'), z.literal('stop')]),
+  }).strict().optional(),
 }).strict()
 
 const MediaClip = ClipBase.extend({
   file: z.string(),
-  volume: z.number().min(0).optional(),
-})
+  volume: Percentage.default('100%'),
+}).strict()
 
 const TextClip = ClipBase.extend({
   text: z.string(),
@@ -51,15 +71,28 @@ const TextClip = ClipBase.extend({
     background_color: Color.optional(),
     outline_color: Color.optional(),
     outline_size: z.number().optional(),
-  }).strict().optional()
-})
+  }).strict().optional(),
+
+  duration: Timestamp.optional(),
+}).strict()
+
+const TimelineClip: z.ZodSchema<t.TimelineClip> = z.lazy(() => z.object({
+  id: ClipId.optional(),
+  offset: Timestamp.default('0'),
+  z_index: z.number().default(0),
+  type: z.union([z.literal('parallel'), z.literal('sequence')]).default('parallel'),
+  next: TimelineClip.array().optional(),
+}))
 
 const Template = z.object({
   size: Size.optional(),
   clips: MediaClip.array().min(1),
   captions: TextClip.array().min(1).optional(),
+  timeline: TimelineClip.array().min(1).optional(),
   preview: Timestamp.optional(),
 })
 
 // this is a typescript exacty type assertion. It does nothing at runtime
 assert({} as z.input<typeof Template>, {} as t.Template)
+
+export { Template }

lib/template_input.zod.ts

@@ -67,16 +67,61 @@ export interface ClipBase {
   crop?: Layout
 
   /** Zoom and pan a clip */
-  // zoompan?: {
-  //   [timestamp: string]: {
-  //     zoom?: Percentage
-  //     x?: Percentage | Pixels
-  //     y?: Percentage | Pixels
-  //   }
-  // }
+  zoompan?: {
+    /** The timstamp when the zoom and pan has settled */
+    keyframe: Timestamp
+
+    /** A percentage that the clip should be zoomed in or zoomed out */
+    zoom?: Percentage
+
+    /** A horizontal pan.
+     *   Percentages are relative to the cropped clip. E.g. 50% puts the left side in the center of the screen.
+     *   If there is a desire, we could add an `origin: 'center' | 'corner'` field to make the origin variable.
+     */
+    x?: Percentage | Pixels
+
+    /** A vertical pan.
+     *   Percentages are relative to the cropped clip. E.g. 50% puts the top side in the center of the screen.
+     */
+    y?: Percentage | Pixels
+  }[]
 
   /** Angle at which the clip should be rotated */
   rotate?: Degrees
+
+  /** Speed at which a clip should be played (200% is 2x speed) */
+  speed?: Percentage
+
+  /** Set the framerate for the clip */
+  framerate?: {
+
+    /** Set the frames per second for the input clip */
+    fps: number
+
+    /** smooth: true will interpolate frames that are missing
+    * _if_ the desired framerate is higher than the input framerate */
+    smooth?: boolean
+  }
+
+  /** Effect to transition a clip in or out of the page */
+  transition?: { fade_in?: Timestamp; fade_out?: Timestamp }
+
+  /** Trim the duration of a clip */
+  trim?: {
+
+    /** Trim time off the start of a clip (similar to -ss argument in ffmpeg) */
+    start?: Timestamp
+
+    /** Trim time off the end of a clip (similar to -to argument in ffmpeg) */
+    stop?: Timestamp
+
+    /**
+     * Auto-trim the clip so that it is not longer than the other longest clip
+     *  If more than one variable_length clip is used in a sequence on the timeline, only the last clip will have variable length.
+     *  If all clips on the timeline have variable length, all clips will share the shortest clip's duration.
+     */
+    variable_length: 'start' | 'stop'
+  }
 }
 
 /**
@@ -114,50 +159,53 @@ export interface TextClip extends ClipBase {
     /** Text outline size (default is zero) */
     outline_size?: number
   }
+
+  /**
+   * Specify the length a caption should be shown in the render
+   *  If not specified, text clip length is essentially the same as `trim: { variable_length: 'end' }`
+   */
+  duration?: Timestamp
 }
 
 /**
  * A MediaClip is any clip which takes in an image, audio or video.
  * Note that an audio file will not allow visual fields like "layout" or "zoompan"
  */
 export interface MediaClip extends ClipBase {
+
   /** Audio volume of the clip, this number is relative to the other clip's volume values. Defaults to 1. */
-  volume?: number
+  volume?: Percentage
+
   /** File path to the clip. If it is a relative path, it will be relative to the location of the template file */
   file: string
 }
 
 
 export interface TimelineClip {
-  id: string
+  /** Clip id that is being added to the timeline */
+  id?: string
+
   /**
    * offset the clip start position by a specified duration. (Maybe we support negative durations too?)
    * default is "0"
    */
   offset?: Timestamp
 
-  /** trim works very similar to clips trim, except that we can specify 'fit' instead of a duration. */
-  trim_to_fit: 'start' | 'end'
-
   /**
    * specify the vertical height of a clip. Think foreground and background
    * default is 0
    */
   z_index?: number
 
-  /** Specify list of clips that should appear after the specified clip */
-  next?: TimelineItem[]
-}
+  /** specify whether the next clips will be played one after another or all at the same time
+   * @default 'sequence'
+   */
+  type?: 'parallel' | 'sequence'
 
-export interface TimelineSequence {
-  /** Specify a list of timeline items that should occur sequentially one after another */
-  sequence: TimelineItem
-  /** specify the vertical height of a clip. Think foreground and background */
-  z_index?: number
+  /** Specify list of clips that should appear after the specified clip */
+  next?: TimelineClip[]
 }
 
-export type TimelineItem = TimelineClip | TimelineSequence
-
 
 export interface Template {
   /**
@@ -180,7 +228,7 @@ export interface Template {
    * The default timeline starts all the clips at the same time. E.g.
    * [{ id: "CLIP_0", offset: "0" }, { id: "CLIP_1", offset: "0" }, ...]
    */
-  // timeline?: TimelineItem[]
+  timeline?: TimelineClip[]
 
   /**
    * Preview the rendered output at a position. Used with the --preview flag.