@gannochenko/staticstripes 0.0.9 → 0.0.11

package/src/html-project-parser.ts

@@ -7,6 +7,7 @@ import {
   SequenceDefinition,
   Fragment,
   Container,
+  FFmpegOption,
 } from './type';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
@@ -34,10 +35,18 @@ export class HTMLProjectParser {
     this.validateAssetFiles(assets);
 
     const outputs = this.processOutputs();
+    const ffmpegOptions = this.processFfmpegOptions();
     const sequences = this.processSequences(assets);
     const cssText = this.html.cssText;
 
-    return new Project(sequences, assets, outputs, cssText, this.projectPath);
+    return new Project(
+      sequences,
+      assets,
+      outputs,
+      ffmpegOptions,
+      cssText,
+      this.projectPath,
+    );
   }
 
   /**
@@ -458,6 +467,85 @@ export class HTMLProjectParser {
     return results;
   }
 
+  /**
+   * Processes ffmpeg options from the parsed HTML
+   */
+  private processFfmpegOptions(): Map<string, FFmpegOption> {
+    const ffmpegElements = this.findFfmpegElements();
+    const options = new Map<string, FFmpegOption>();
+
+    // Process each <ffmpeg> element (should typically be only one)
+    for (const ffmpegElement of ffmpegElements) {
+      // Find all <option> child elements
+      if ('childNodes' in ffmpegElement && ffmpegElement.childNodes) {
+        for (const child of ffmpegElement.childNodes) {
+          if ('tagName' in child) {
+            const childElement = child as Element;
+            if (childElement.tagName === 'option') {
+              const attrs = new Map(
+                childElement.attrs.map((attr) => [attr.name, attr.value]),
+              );
+
+              const name = attrs.get('name');
+              if (!name) {
+                continue; // Skip options without name
+              }
+
+              // Get the text content (the FFmpeg arguments)
+              let args = '';
+              if ('childNodes' in childElement && childElement.childNodes) {
+                for (const textNode of childElement.childNodes) {
+                  if ('value' in textNode) {
+                    args += textNode.value;
+                  }
+                }
+              }
+
+              // Trim whitespace
+              args = args.trim();
+
+              const option: FFmpegOption = {
+                name,
+                args,
+              };
+
+              options.set(name, option);
+            }
+          }
+        }
+      }
+    }
+
+    return options;
+  }
+
+  /**
+   * Finds all ffmpeg elements in the HTML
+   */
+  private findFfmpegElements(): Element[] {
+    const results: Element[] = [];
+
+    const traverse = (node: ASTNode) => {
+      if ('tagName' in node) {
+        const element = node as Element;
+
+        // Check if element is an <ffmpeg> tag
+        if (element.tagName === 'ffmpeg') {
+          results.push(element);
+        }
+      }
+
+      if ('childNodes' in node && node.childNodes) {
+        for (const child of node.childNodes) {
+          traverse(child);
+        }
+      }
+    };
+
+    traverse(this.html.ast);
+    return results;
+  }
+
   /**
    * Processes sequences and fragments from the parsed HTML
    */

package/src/project.ts

@@ -1,4 +1,4 @@
-import { Asset, Output, SequenceDefinition } from './type';
+import { Asset, Output, SequenceDefinition, FFmpegOption } from './type';
 import { Label } from './ffmpeg';
 import { AssetManager } from './asset-manager';
 import { Sequence } from './sequence';
@@ -15,6 +15,7 @@ export class Project {
     private sequencesDefinitions: SequenceDefinition[],
     assets: Asset[],
     private outputs: Map<string, Output>,
+    private ffmpegOptions: Map<string, FFmpegOption>,
     private cssText: string,
     private projectPath: string,
   ) {
@@ -93,6 +94,14 @@ export class Project {
     return this.outputs;
   }
 
+  public getFfmpegOptions(): Map<string, FFmpegOption> {
+    return this.ffmpegOptions;
+  }
+
+  public getFfmpegOption(name: string): FFmpegOption | undefined {
+    return this.ffmpegOptions.get(name);
+  }
+
   public getCssText(): string {
     return this.cssText;
   }
@@ -121,7 +130,10 @@ export class Project {
   /**
    * Renders all containers and creates virtual assets for them
    */
-  public async renderContainers(outputName: string): Promise<void> {
+  public async renderContainers(
+    outputName: string,
+    activeCacheKeys?: Set<string>,
+  ): Promise<void> {
     const output = this.getOutput(outputName);
     if (!output) {
       throw new Error(`Output "${outputName}" not found`);
@@ -147,6 +159,8 @@ export class Project {
       output.resolution.width,
       output.resolution.height,
       projectDir,
+      outputName,
+      activeCacheKeys,
     );
 
     // Create virtual assets and update fragment assetNames

package/src/type.ts

@@ -73,6 +73,11 @@ export type Output = {
   fps: number; // e.g. 30
 };
 
+export type FFmpegOption = {
+  name: string; // e.g. "preview", "production"
+  args: string; // e.g. "-c:v h264_nvenc -preset fast"
+};
+
 export type ProjectStructure = {
   sequences: SequenceDefinition[];
   assets: Map<string, Asset>;