npm - @gannochenko/staticstripes - Versions diffs - 0.0.1 - Mend

@gannochenko/staticstripes 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (86) hide show

package/.prettierrc +8 -0
package/Makefile +69 -0
package/dist/asset-manager.d.ts +16 -0
package/dist/asset-manager.d.ts.map +1 -0
package/dist/asset-manager.js +50 -0
package/dist/asset-manager.js.map +1 -0
package/dist/cli.d.ts +3 -0
package/dist/cli.d.ts.map +1 -0
package/dist/cli.js +257 -0
package/dist/cli.js.map +1 -0
package/dist/container-renderer.d.ts +21 -0
package/dist/container-renderer.d.ts.map +1 -0
package/dist/container-renderer.js +149 -0
package/dist/container-renderer.js.map +1 -0
package/dist/expression-parser.d.ts +63 -0
package/dist/expression-parser.d.ts.map +1 -0
package/dist/expression-parser.js +145 -0
package/dist/expression-parser.js.map +1 -0
package/dist/ffmpeg.d.ts +375 -0
package/dist/ffmpeg.d.ts.map +1 -0
package/dist/ffmpeg.js +997 -0
package/dist/ffmpeg.js.map +1 -0
package/dist/ffprobe.d.ts +2 -0
package/dist/ffprobe.d.ts.map +1 -0
package/dist/ffprobe.js +31 -0
package/dist/ffprobe.js.map +1 -0
package/dist/html-parser.d.ts +56 -0
package/dist/html-parser.d.ts.map +1 -0
package/dist/html-parser.js +208 -0
package/dist/html-parser.js.map +1 -0
package/dist/html-project-parser.d.ts +169 -0
package/dist/html-project-parser.d.ts.map +1 -0
package/dist/html-project-parser.js +954 -0
package/dist/html-project-parser.js.map +1 -0
package/dist/index.d.ts +6 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +18 -0
package/dist/index.js.map +1 -0
package/dist/label-generator.d.ts +35 -0
package/dist/label-generator.d.ts.map +1 -0
package/dist/label-generator.js +69 -0
package/dist/label-generator.js.map +1 -0
package/dist/project.d.ts +29 -0
package/dist/project.d.ts.map +1 -0
package/dist/project.js +137 -0
package/dist/project.js.map +1 -0
package/dist/sample-sequences.d.ts +5 -0
package/dist/sample-sequences.d.ts.map +1 -0
package/dist/sample-sequences.js +199 -0
package/dist/sample-sequences.js.map +1 -0
package/dist/sample-streams.d.ts +2 -0
package/dist/sample-streams.d.ts.map +1 -0
package/dist/sample-streams.js +109 -0
package/dist/sample-streams.js.map +1 -0
package/dist/sequence.d.ts +21 -0
package/dist/sequence.d.ts.map +1 -0
package/dist/sequence.js +269 -0
package/dist/sequence.js.map +1 -0
package/dist/stream.d.ts +135 -0
package/dist/stream.d.ts.map +1 -0
package/dist/stream.js +779 -0
package/dist/stream.js.map +1 -0
package/dist/type.d.ts +73 -0
package/dist/type.d.ts.map +1 -0
package/dist/type.js +3 -0
package/dist/type.js.map +1 -0
package/eslint.config.js +44 -0
package/package.json +50 -0
package/src/asset-manager.ts +55 -0
package/src/cli.ts +306 -0
package/src/container-renderer.ts +190 -0
package/src/expression-parser.test.ts +459 -0
package/src/expression-parser.ts +199 -0
package/src/ffmpeg.ts +1403 -0
package/src/ffprobe.ts +29 -0
package/src/html-parser.ts +221 -0
package/src/html-project-parser.ts +1195 -0
package/src/index.ts +9 -0
package/src/label-generator.ts +74 -0
package/src/project.ts +180 -0
package/src/sample-sequences.ts +225 -0
package/src/sample-streams.ts +142 -0
package/src/sequence.ts +330 -0
package/src/stream.ts +1012 -0
package/src/type.ts +81 -0
package/tsconfig.json +24 -0

package/src/container-renderer.ts ADDED Viewed

@@ -0,0 +1,190 @@
+import puppeteer from 'puppeteer';
+import { writeFile, mkdir, readdir, unlink } from 'fs/promises';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { createHash } from 'crypto';
+import { Container } from './type';
+export interface RenderContainerOptions {
+  container: Container;
+  cssText: string;
+  width: number;
+  height: number;
+  projectDir: string;
+}
+export interface ContainerRenderResult {
+  container: Container;
+  screenshotPath: string;
+}
+/**
+ * Generates a hash from container content and CSS
+ */
+function generateCacheKey(containerHtml: string, cssText: string): string {
+  const hash = createHash('sha256');
+  hash.update(containerHtml);
+  hash.update(cssText);
+  return hash.digest('hex').substring(0, 16);
+}
+/**
+ * Renders a container to a PNG screenshot using Puppeteer
+ */
+export async function renderContainer(
+  options: RenderContainerOptions,
+): Promise<ContainerRenderResult> {
+  const { container, cssText, width, height, projectDir } = options;
+  // Create cache directory
+  const cacheDir = resolve(projectDir, '.cache', 'containers');
+  if (!existsSync(cacheDir)) {
+    await mkdir(cacheDir, { recursive: true });
+  }
+  // Generate cache key from content hash
+  const cacheKey = generateCacheKey(container.htmlContent, cssText);
+  const screenshotPath = resolve(cacheDir, `${cacheKey}.png`);
+  // Check if cached version exists
+  if (existsSync(screenshotPath)) {
+    console.log(
+      `Using cached container "${container.id}" (hash: ${cacheKey}) from ${screenshotPath}`,
+    );
+    return {
+      container,
+      screenshotPath,
+    };
+  }
+  // Build complete HTML document
+  const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      width: ${width}px;
+      height: ${height}px;
+      overflow: hidden;
+      background: transparent;
+      font-size: 16px;
+    }
+    ${cssText}
+  </style>
+</head>
+<body>
+  ${container.htmlContent}
+</body>
+</html>
+  `.trim();
+  // Launch browser and render
+  const browser = await puppeteer.launch({
+    headless: true,
+    args: ['--no-sandbox', '--disable-setuid-sandbox'],
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setViewport({ width, height });
+    await page.setContent(html, { waitUntil: 'networkidle0' });
+    // Take screenshot with transparent background
+    const screenshot = await page.screenshot({
+      type: 'png',
+      omitBackground: true,
+      clip: {
+        x: 0,
+        y: 0,
+        width,
+        height,
+      },
+    });
+    // Save to file
+    await writeFile(screenshotPath, screenshot);
+    console.log(
+      `Rendered container "${container.id}" (hash: ${cacheKey}) to ${screenshotPath}`,
+    );
+    return {
+      container,
+      screenshotPath,
+    };
+  } finally {
+    await browser.close();
+  }
+}
+/**
+ * Cleans up stale cache entries that are not in the active set
+ */
+async function cleanupStaleCache(
+  cacheDir: string,
+  activeCacheKeys: Set<string>,
+): Promise<void> {
+  if (!existsSync(cacheDir)) {
+    return;
+  }
+  const files = await readdir(cacheDir);
+  const pngFiles = files.filter((file) => file.endsWith('.png'));
+  let removedCount = 0;
+  for (const file of pngFiles) {
+    const cacheKey = file.replace('.png', '');
+    if (!activeCacheKeys.has(cacheKey)) {
+      const filePath = resolve(cacheDir, file);
+      await unlink(filePath);
+      console.log(`Removed stale cache entry: ${file}`);
+      removedCount++;
+    }
+  }
+  if (removedCount > 0) {
+    console.log(`Cleaned up ${removedCount} stale cache entries`);
+  }
+}
+/**
+ * Renders multiple containers in sequence
+ */
+export async function renderContainers(
+  containers: Container[],
+  cssText: string,
+  width: number,
+  height: number,
+  projectDir: string,
+): Promise<ContainerRenderResult[]> {
+  const results: ContainerRenderResult[] = [];
+  const activeCacheKeys = new Set<string>();
+  // Render all containers and collect active cache keys
+  for (const container of containers) {
+    const cacheKey = generateCacheKey(container.htmlContent, cssText);
+    activeCacheKeys.add(cacheKey);
+    const result = await renderContainer({
+      container,
+      cssText,
+      width,
+      height,
+      projectDir,
+    });
+    results.push(result);
+  }
+  // Clean up stale cache entries
+  const cacheDir = resolve(projectDir, '.cache', 'containers');
+  await cleanupStaleCache(cacheDir, activeCacheKeys);
+  return results;
+}

package/src/expression-parser.test.ts ADDED Viewed

@@ -0,0 +1,459 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseExpression,
+  evaluateCompiledExpression,
+  parseValueLazy,
+  calculateFinalValue,
+  isCalcExpression,
+  ExpressionContext,
+  CompiledExpression,
+} from './expression-parser';
+describe('expression-parser', () => {
+  describe('isCalcExpression', () => {
+    it('should identify calc expressions', () => {
+      expect(isCalcExpression('calc(5 + 3)')).toBe(true);
+      expect(isCalcExpression('  calc(5 + 3)')).toBe(true);
+      expect(isCalcExpression('5')).toBe(false);
+      expect(isCalcExpression('something else')).toBe(false);
+    });
+  });
+  describe('parseExpression', () => {
+    it('should parse and evaluate simple numeric expression', () => {
+      const compiled = parseExpression('calc(5 + 3)');
+      expect(compiled.original).toBe('calc(5 + 3)');
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map(),
+      });
+      expect(result).toBe(8);
+    });
+    it('should parse and evaluate expression with url() fragment reference', () => {
+      const compiled = parseExpression('calc(url(#ending_screen.time.start))');
+      expect(compiled.original).toBe('calc(url(#ending_screen.time.start))');
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map([
+          [
+            'ending_screen',
+            {
+              time: { start: 12000, end: 17000, duration: 5000 },
+            },
+          ],
+        ]),
+      });
+      expect(result).toBe(12000);
+    });
+    it('should parse and evaluate expression with seconds unit', () => {
+      const compiled = parseExpression('calc(5s)');
+      expect(compiled.original).toBe('calc(5s)');
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map(),
+      });
+      expect(result).toBe(5000);
+    });
+    it('should parse and evaluate expression with milliseconds unit', () => {
+      const compiled = parseExpression('calc(5000ms)');
+      expect(compiled.original).toBe('calc(5000ms)');
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map(),
+      });
+      expect(result).toBe(5000);
+    });
+    it('should parse and evaluate expression with decimal seconds', () => {
+      const compiled = parseExpression('calc(1.5s)');
+      expect(compiled.original).toBe('calc(1.5s)');
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map(),
+      });
+      expect(result).toBe(1500);
+    });
+    it('should parse and evaluate complex expression with url() and time units', () => {
+      const compiled = parseExpression(
+        'calc(url(#ending_screen.time.start) * -1 + 5s)',
+      );
+      expect(compiled.original).toBe(
+        'calc(url(#ending_screen.time.start) * -1 + 5s)',
+      );
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map([
+          [
+            'ending_screen',
+            {
+              time: { start: 10000, end: 15000, duration: 5000 },
+            },
+          ],
+        ]),
+      });
+      expect(result).toBe(-5000); // -10000 + 5000
+    });
+    it('should parse and evaluate expression with multiple fragment references', () => {
+      const compiled = parseExpression(
+        'calc(url(#scene1.time.end) - url(#scene2.time.start))',
+      );
+      expect(compiled.original).toBe(
+        'calc(url(#scene1.time.end) - url(#scene2.time.start))',
+      );
+      const result = evaluateCompiledExpression(compiled, {
+        fragments: new Map([
+          ['scene1', { time: { start: 0, end: 5000, duration: 5000 } }],
+          ['scene2', { time: { start: 3000, end: 8000, duration: 5000 } }],
+        ]),
+      });
+      expect(result).toBe(2000); // 5000 - 3000
+    });
+    it('should throw error for invalid expression', () => {
+      expect(() => parseExpression('calc(5 + )')).toThrow(/Failed to parse/);
+    });
+  });
+  describe('evaluateCompiledExpression', () => {
+    it('should evaluate simple numeric expression', () => {
+      const compiled = parseExpression('calc(5 + 3)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(8);
+    });
+    it('should evaluate expression with seconds converted to milliseconds', () => {
+      const compiled = parseExpression('calc(5s)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(5000);
+    });
+    it('should evaluate expression with milliseconds', () => {
+      const compiled = parseExpression('calc(5000ms)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(5000);
+    });
+    it('should evaluate expression with decimal seconds', () => {
+      const compiled = parseExpression('calc(1.5s)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(1500);
+    });
+    it('should evaluate expression with fragment reference', () => {
+      const compiled = parseExpression('calc(url(#ending_screen.time.start))');
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'ending_screen',
+            {
+              time: {
+                start: 10000,
+                end: 15000,
+                duration: 5000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(10000);
+    });
+    it('should evaluate expression with fragment reference and math', () => {
+      const compiled = parseExpression(
+        'calc(url(#ending_screen.time.start) * -1)',
+      );
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'ending_screen',
+            {
+              time: {
+                start: 10000,
+                end: 15000,
+                duration: 5000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(-10000);
+    });
+    it('should evaluate complex expression with fragment and time unit', () => {
+      const compiled = parseExpression(
+        'calc(url(#ending_screen.time.start) * -1 + 5s)',
+      );
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'ending_screen',
+            {
+              time: {
+                start: 10000,
+                end: 15000,
+                duration: 5000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(-5000); // -10000 + 5000
+    });
+    it('should evaluate expression with multiple fragment references', () => {
+      const compiled = parseExpression(
+        'calc(url(#scene1.time.end) - url(#scene2.time.start))',
+      );
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'scene1',
+            {
+              time: {
+                start: 0,
+                end: 5000,
+                duration: 5000,
+              },
+            },
+          ],
+          [
+            'scene2',
+            {
+              time: {
+                start: 3000,
+                end: 8000,
+                duration: 5000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(2000); // 5000 - 3000
+    });
+    it('should evaluate expression with duration property', () => {
+      const compiled = parseExpression('calc(url(#intro.time.duration) + 1000)');
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'intro',
+            {
+              time: {
+                start: 0,
+                end: 3000,
+                duration: 3000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(4000);
+    });
+    it('should throw error for missing fragment', () => {
+      const compiled = parseExpression('calc(url(#nonexistent.time.start))');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      expect(() => evaluateCompiledExpression(compiled, context)).toThrow(
+        /Fragment with id "nonexistent" not found/,
+      );
+    });
+    it('should throw error for missing property', () => {
+      const compiled = parseExpression('calc(url(#intro.time.invalid))');
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'intro',
+            {
+              time: {
+                start: 0,
+                end: 3000,
+                duration: 3000,
+              },
+            },
+          ],
+        ]),
+      };
+      expect(() => evaluateCompiledExpression(compiled, context)).toThrow(
+        /Property "time.invalid" not found/,
+      );
+    });
+  });
+  describe('parseValueLazy', () => {
+    it('should return number as-is', () => {
+      const result = parseValueLazy(5000);
+      expect(result).toBe(5000);
+    });
+    it('should parse string number', () => {
+      const result = parseValueLazy('5000');
+      expect(result).toBe(5000);
+    });
+    it('should compile calc expression', () => {
+      const result = parseValueLazy('calc(5 + 3)');
+      expect(typeof result).toBe('object');
+      expect((result as CompiledExpression).original).toBe('calc(5 + 3)');
+    });
+    it('should compile calc expression with url()', () => {
+      const result = parseValueLazy('calc(url(#intro.time.start) + 1000)');
+      expect(typeof result).toBe('object');
+      expect((result as CompiledExpression).original).toBe(
+        'calc(url(#intro.time.start) + 1000)',
+      );
+    });
+    it('should throw error for invalid value', () => {
+      expect(() => parseValueLazy('invalid')).toThrow(/Invalid value/);
+    });
+  });
+  describe('calculateFinalValue', () => {
+    const context: ExpressionContext = {
+      fragments: new Map([
+        [
+          'intro',
+          {
+            time: {
+              start: 0,
+              end: 3000,
+              duration: 3000,
+            },
+          },
+        ],
+      ]),
+    };
+    it('should return number as-is', () => {
+      const result = calculateFinalValue(5000, context);
+      expect(result).toBe(5000);
+    });
+    it('should evaluate compiled expression', () => {
+      const compiled = parseExpression('calc(url(#intro.time.duration) + 1000)');
+      const result = calculateFinalValue(compiled, context);
+      expect(result).toBe(4000);
+    });
+  });
+  describe('Integration: compile once, evaluate many', () => {
+    it('should compile once and evaluate with different contexts', () => {
+      const compiled = parseExpression('calc(url(#fragment.time.start) + 2s)');
+      const context1: ExpressionContext = {
+        fragments: new Map([
+          [
+            'fragment',
+            {
+              time: {
+                start: 1000,
+                end: 6000,
+                duration: 5000,
+              },
+            },
+          ],
+        ]),
+      };
+      const context2: ExpressionContext = {
+        fragments: new Map([
+          [
+            'fragment',
+            {
+              time: {
+                start: 5000,
+                end: 10000,
+                duration: 5000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result1 = evaluateCompiledExpression(compiled, context1);
+      const result2 = evaluateCompiledExpression(compiled, context2);
+      expect(result1).toBe(3000); // 1000 + 2000
+      expect(result2).toBe(7000); // 5000 + 2000
+    });
+  });
+  describe('Edge cases', () => {
+    it('should handle negative numbers', () => {
+      const compiled = parseExpression('calc(-5s)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(-5000);
+    });
+    it('should handle division', () => {
+      const compiled = parseExpression('calc(10s / 2)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(5000);
+    });
+    it('should handle parentheses', () => {
+      const compiled = parseExpression('calc((2s + 3s) * 2)');
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(10000); // (2000 + 3000) * 2
+    });
+    it('should handle complex nested property paths', () => {
+      const compiled = parseExpression('calc(url(#fragment.time.start))');
+      const context: ExpressionContext = {
+        fragments: new Map([
+          [
+            'fragment',
+            {
+              time: {
+                start: 1500,
+                end: 4500,
+                duration: 3000,
+              },
+            },
+          ],
+        ]),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(1500);
+    });
+    it('should not convert "ms" or "s" in middle of words', () => {
+      // This would be an odd case, but the regex should use word boundaries
+      const compiled = parseExpression('calc(100)'); // Normal case
+      const context: ExpressionContext = {
+        fragments: new Map(),
+      };
+      const result = evaluateCompiledExpression(compiled, context);
+      expect(result).toBe(100);
+    });
+  });
+});