file watcher handle weird neovim saving

Author: andykais

ffmpeg-templates.zod.ts

@@ -0,0 +1,39 @@
+import * as flags from 'https://deno.land/std@0.91.0/flags/mod.ts'
+import ffmpeg_templates from './lib/cli.zod.ts'
+
+
+const VERSION = 'v0.2.0'
+
+
+const args = flags.parse(Deno.args)
+if (args._.length < 1 || args._.length > 2 || args['help']) {
+  console.error(`ffmpeg-templates ${VERSION}
+
+Usage: ffmpeg-templates <template_filepath> [<output_folder>] [options]
+
+ARGS:
+  <template_filepath>                       Path to a YAML or JSON template file which defines the structure of
+                                            the outputted video
+
+  <output_folder>                           The folder in which the output and generated assets will be saved to.
+                                            When not specified, a folder will be created adjacent to the template.
+
+OPTIONS:
+  --preview                                 Instead of outputting the whole video, output a single frame as a jpg.
+                                            Use this flag to set up your layouts and iterate quickly.
+
+  --open                                    Open the outputted file after it is rendered.
+
+  --watch                                   Run continously when the template file changes. This is most useful
+                                            in tandem with --preview.
+
+  --develop                                 Alias for running "--watch --preview --open"
+
+  --quiet                                   Do not print a progress bar
+
+  --debug                                   Write debug information to a file
+
+  --help                                    Print this message.`)
+  Deno.exit(args['help'] ? 0 : 1)
+}
+await ffmpeg_templates(...Deno.args)

lib/cli.zod.ts

@@ -20,7 +20,7 @@ function parse_cli_args(deno_args: string[]) {
   if (args['develop']) args = { ...args, watch: true, preview: true, open: true }
   const positional_args = args._.map((a) => a.toString())
   const template_filepath = positional_args[0]
-  const { dir, name } = path.parse(args.template_filepath)
+  const { dir, name } = path.parse(template_filepath)
   let output_folder = path.join(dir, 'ffmpeg-templates-projects', dir, `${name}`)
   if (positional_args[1]) output_folder
   return {
@@ -69,6 +69,23 @@ async function try_render_video(template_filepath: string, sample_frame: boolean
 }
 
 
+async function watch(filepath: string, fn: () => Promise<void>) {
+  let lock = false
+  for await (const event of Deno.watchFs(filepath)) {
+    if (event.kind === 'modify' && lock === false) {
+      lock = true
+      setTimeout(() => {
+        fn().then(() => {
+          lock = false
+        })
+      }, 50) // assume that all file modifications are completed in 50ms
+    }
+    if (event.kind === 'remove') break
+  }
+  watch(filepath, fn)
+}
+
+
 export default async function (...deno_args: string[]) {
   const args = parse_cli_args(deno_args)
   const { template_filepath } = args
@@ -89,20 +106,10 @@ export default async function (...deno_args: string[]) {
 
   if (args.watch) {
     logger.info(`watching ${template_filepath} for changes`)
-    let lock = false
-    for await (const event of Deno.watchFs(template_filepath)) {
-      console.log({ event, lock})
-      if (event.kind === 'modify' && !lock) {
-        lock = true
-        setTimeout(() => {
-          logger.info(`template ${template_filepath} was changed. Starting render.`)
-          try_render_video(template_filepath, args.preview, context_options).then(() => {
-            lock = false
-            logger.info(`watching ${template_filepath} for changes`)
-          })
-          // assume that all file modifications are completed in 50ms
-        }, 50)
-      }
-    }
+    await watch(template_filepath, async () => {
+      logger.info(`template ${template_filepath} was changed. Starting render.`)
+      await try_render_video(template_filepath, args.preview, context_options)
+      logger.info(`watching ${template_filepath} for changes`)
+    })
   }
 }

lib/mod.zod.ts

@@ -6,16 +6,6 @@ import type { Logger } from './logger.ts'
 import type { OnProgress, FfmpegProgress } from './bindings/ffmpeg.ts'
 
 
-interface RenderOptions {
-  ffmpeg_verbosity?: 'quiet' | 'error' | 'warning' | 'info' | 'debug'
-  debug_logs?: boolean
-  progress_callback?: OnProgress
-  cwd?: string
-}
-interface RenderOptionsInternal extends RenderOptions {
-  render_sample_frame?: boolean
-}
-
 async function render(context: Context, render_sample_frame: boolean) {
   return {
     template: '',

lib/parsers/template.zod.ts

@@ -1,5 +1,6 @@
 import { z } from 'https://deno.land/x/zod@v3.9.0/mod.ts'
 import * as t from '../template_input.zod.ts'
+import * as errors from '../errors.ts'
 import { assert } from '../type-equality.ts'
 
 
@@ -103,9 +104,24 @@ const Template = z.object({
 // this is a typescript exacty type assertion. It does nothing at runtime
 assert({} as z.input<typeof Template>, {} as t.Template)
 
+
+function pretty_zod_errors(error: z.ZodError) {
+  return error.errors.map(e => {
+    const path = e.path.join('.')
+    return `  ${path}: ${e.message}`
+  }).join('\n')
+}
+
+
 function parse_template(template_input: z.input<typeof Template>): z.infer<typeof Template> {
-  const result = Template.parse(template_input)
-  return result
+  try {
+    const result = Template.parse(template_input)
+    return result
+  } catch (e) {
+    if (e instanceof z.ZodError) throw new errors.InputError(`Invalid template format:\n${pretty_zod_errors(e)}`)
+    else throw e
+  
+  }
 }
 
 export { parse_template }