@hyperframes/lint 0.8.40 → 0.8.41

package/dist/index.js

@@ -5379,7 +5379,7 @@ import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
 import { dirname, extname, join as join2, relative, resolve } from "path";
 import { rewriteAssetPath as rewriteAssetPath2 } from "@hyperframes/parsers/asset-paths";
 import { checkSubCompositionUsability } from "@hyperframes/parsers/sub-composition-validity";
-import { parseHTML as parseHTML2 } from "linkedom";
+import { parseHTML as parseHTML3 } from "linkedom";
 import {
   cleanAssetUrl as cleanAssetUrl2,
   collectSubCompositionSrcs,
@@ -5396,6 +5396,7 @@ import { execFile } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
 import { rewriteAssetPath } from "@hyperframes/parsers/asset-paths";
+import { parseNumeric } from "@hyperframes/parsers/composition-contract";
 import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
 import {
   cleanAssetUrl,
@@ -5404,6 +5405,7 @@ import {
   maskNonScannableRanges,
   resolveExistingLocalAsset
 } from "@hyperframes/parsers/asset-resolution";
+import { parseHTML as parseHTML2 } from "linkedom";
 var PROBE_TIMEOUT_MS = 4e3;
 var PROBE_CONCURRENCY = 8;
 function execFileAsync(file, args) {
@@ -5414,6 +5416,29 @@ function execFileAsync(file, args) {
     });
   });
 }
+async function mapWithProbeConcurrency(entries, probe) {
+  const results = new Array(entries.length);
+  let nextIndex = 0;
+  const workerCount = Math.min(PROBE_CONCURRENCY, entries.length);
+  const runWorker = async () => {
+    for (; ; ) {
+      const index = nextIndex++;
+      if (index >= entries.length) return;
+      const entry = entries[index];
+      if (entry !== void 0) results[index] = await probe(entry);
+    }
+  };
+  await Promise.all(Array.from({ length: workerCount }, runWorker));
+  return results;
+}
+function resolveLocalVideoReference(projectDir, rawSrc, compSrcPath) {
+  if (isUnresolvedAssetPlaceholder(rawSrc)) return null;
+  const src = cleanAssetUrl(rawSrc);
+  if (!src || isRemoteOrInlineUrl(src)) return null;
+  const rootRelative = compSrcPath ? rewriteAssetPath(compSrcPath, src, (path) => existsSync(join(projectDir, path))) : src;
+  const asset = resolveExistingLocalAsset(projectDir, rootRelative);
+  return asset ? { resolved: asset.resolved, src } : null;
+}
 function hasHevcStream(json) {
   if (typeof json !== "object" || json === null) return false;
   const streams = Reflect.get(json, "streams");
@@ -5451,35 +5476,143 @@ function collectLocalVideoCandidates(projectDir, htmlSources) {
     let match;
     while ((match = re.exec(scannable)) !== null) {
       const rawSrc = match[2] ?? "";
-      if (isUnresolvedAssetPlaceholder(rawSrc)) continue;
-      const src = cleanAssetUrl(rawSrc);
-      if (!src) continue;
-      if (isRemoteOrInlineUrl(src)) continue;
-      const rootRelative = compSrcPath ? rewriteAssetPath(compSrcPath, src, (path) => existsSync(join(projectDir, path))) : src;
-      const resolvedAsset = resolveExistingLocalAsset(projectDir, rootRelative);
-      if (!resolvedAsset) continue;
-      if (!candidates.has(resolvedAsset.resolved)) candidates.set(resolvedAsset.resolved, src);
+      const reference = resolveLocalVideoReference(projectDir, rawSrc, compSrcPath);
+      if (!reference || candidates.has(reference.resolved)) continue;
+      candidates.set(reference.resolved, reference.src);
     }
   }
   return candidates;
 }
+function collectVideoElements(html) {
+  const { document } = parseHTML2(html);
+  const roots = [document];
+  const videos = [];
+  for (let index = 0; index < roots.length; index++) {
+    const root = roots[index];
+    if (!root) continue;
+    videos.push(...root.querySelectorAll("video"));
+    for (const template of root.querySelectorAll("template")) {
+      roots.push(template.content);
+    }
+  }
+  return videos;
+}
+function readPositiveNumber(raw) {
+  const value = parseNumeric(raw);
+  return value !== null && value > 0 ? value : null;
+}
+function readNonNegativeNumber(raw) {
+  const value = parseNumeric(raw);
+  return value !== null && value >= 0 ? value : null;
+}
+function readFiniteVideoSlot(video, file) {
+  if (video.hasAttribute("loop")) return null;
+  if (video.hasAttribute("data-var-src")) return null;
+  if (video.hasAttribute("data-playback-start")) return null;
+  if (readPositiveNumber(video.getAttribute("data-duration")) === null) return null;
+  const mediaStart = readNonNegativeNumber(video.getAttribute("data-media-start"));
+  if (mediaStart === null) return null;
+  return {
+    rawSrc: video.getAttribute("src") ?? "",
+    file,
+    ...video.id ? { elementId: video.id } : {},
+    mediaStart
+  };
+}
+function collectLocalFiniteVideoSlots(projectDir, htmlSources) {
+  const slotsByPath = /* @__PURE__ */ new Map();
+  for (const { html, compSrcPath } of htmlSources) {
+    for (const video of collectVideoElements(html)) {
+      const slot = readFiniteVideoSlot(video, compSrcPath ?? "index.html");
+      if (!slot) continue;
+      const reference = resolveLocalVideoReference(projectDir, slot.rawSrc, compSrcPath);
+      if (!reference) continue;
+      const slots = slotsByPath.get(reference.resolved) ?? [];
+      slots.push({
+        src: reference.src,
+        file: slot.file,
+        ...slot.elementId ? { elementId: slot.elementId } : {},
+        mediaStart: slot.mediaStart
+      });
+      slotsByPath.set(reference.resolved, slots);
+    }
+  }
+  return slotsByPath;
+}
+function parsePositiveDuration(value) {
+  const duration = typeof value === "number" || typeof value === "string" ? Number(value) : NaN;
+  return Number.isFinite(duration) && duration > 0 ? duration : null;
+}
+function readPlayableVideoDuration(stdout) {
+  try {
+    const metadata = JSON.parse(stdout);
+    if (typeof metadata !== "object" || metadata === null) return null;
+    const streams = Reflect.get(metadata, "streams");
+    const stream = Array.isArray(streams) ? streams.find((candidate) => typeof candidate === "object" && candidate !== null) : null;
+    const streamDuration = stream ? parsePositiveDuration(Reflect.get(stream, "duration")) : null;
+    if (streamDuration !== null) return streamDuration;
+    const format = Reflect.get(metadata, "format");
+    return typeof format === "object" && format !== null ? parsePositiveDuration(Reflect.get(format, "duration")) : null;
+  } catch {
+    return null;
+  }
+}
+async function probePlayableVideoDuration(ffprobePath, filePath) {
+  try {
+    return readPlayableVideoDuration(
+      await execFileAsync(ffprobePath, [
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=duration:format=duration",
+        "-of",
+        "json",
+        "--",
+        filePath
+      ])
+    );
+  } catch {
+    return null;
+  }
+}
+async function lintVideoMediaStartPastEof(projectDir, htmlSources) {
+  const slotsByPath = collectLocalFiniteVideoSlots(projectDir, htmlSources);
+  if (slotsByPath.size === 0) return [];
+  const ffprobePath = findFfBinary("ffprobe", { configuredMustExist: true });
+  if (!ffprobePath) return [];
+  const entries = [...slotsByPath.entries()];
+  const durations = await mapWithProbeConcurrency(
+    entries,
+    (entry) => probePlayableVideoDuration(ffprobePath, entry[0])
+  );
+  const findings = [];
+  for (const [index, [, slots]] of entries.entries()) {
+    const sourceDuration = durations[index];
+    if (sourceDuration == null) continue;
+    for (const slot of slots) {
+      if (slot.mediaStart < sourceDuration) continue;
+      findings.push({
+        code: "video_media_start_at_or_past_eof",
+        severity: "warning",
+        message: `Video "${slot.src}" starts at ${slot.mediaStart}s, at or past its ${sourceDuration}s playable source duration. The video will hold its final frame for the explicit slot.`,
+        file: slot.file,
+        ...slot.elementId ? { elementId: slot.elementId } : {},
+        fixHint: `Trim data-media-start below ${sourceDuration}s if this final-frame hold is unintended.`
+      });
+    }
+  }
+  return findings;
+}
 async function lintHevcPreviewCodec(candidates) {
   if (candidates.size === 0) return [];
   const ffprobePath = findFfBinary("ffprobe", { configuredMustExist: true });
   if (!ffprobePath) return [];
   const entries = [...candidates.entries()];
-  const isHevc = new Array(entries.length).fill(false);
-  let nextIndex = 0;
-  const workerCount = Math.min(PROBE_CONCURRENCY, entries.length);
-  await Promise.all(
-    Array.from({ length: workerCount }, async () => {
-      while (nextIndex < entries.length) {
-        const index = nextIndex++;
-        const entry = entries[index];
-        if (!entry) break;
-        isHevc[index] = await probeIsHevc(ffprobePath, entry[0]);
-      }
-    })
+  const isHevc = await mapWithProbeConcurrency(
+    entries,
+    (entry) => probeIsHevc(ffprobePath, entry[0])
   );
   const hevcSrcs = entries.filter((_, i) => isHevc[i]).map(([, src]) => src);
   if (hevcSrcs.length === 0) return [];
@@ -5496,7 +5629,7 @@ async function lintHevcPreviewCodec(candidates) {
 
 // src/project.ts
 function parseSubCompHtml(html) {
-  return parseHTML2(html).document;
+  return parseHTML3(html).document;
 }
 function querySelectorAllIncludingTemplates(root, selector) {
   const matches = [...root.querySelectorAll(selector)];
@@ -5534,7 +5667,7 @@ function collectLocalStylesheets(projectDir, document, compSrcPath) {
 }
 function collectExternalStyles(projectDir, html, compSrcPath) {
   const styles = [];
-  const { document } = parseHTML2(html);
+  const { document } = parseHTML3(html);
   for (const { href, content } of collectLocalStylesheets(projectDir, document, compSrcPath)) {
     styles.push({ href, content });
   }
@@ -5542,7 +5675,7 @@ function collectExternalStyles(projectDir, html, compSrcPath) {
 }
 function collectCssSources(projectDir, html, compSrcPath) {
   const sources = [];
-  const { document } = parseHTML2(html);
+  const { document } = parseHTML3(html);
   for (const style of querySelectorAllIncludingTemplates(document, "style")) {
     sources.push({ content: style.textContent ?? "" });
   }
@@ -5640,6 +5773,7 @@ async function lintProject(projectDir, entryFile) {
     ...!entryFile ? lintBlankRootWithStandaloneComposition(rootHtml, allHtmlSources) : [],
     ...lintDuplicateAudioTracks(allHtmlSources),
     ...lintMissingOrEmptySubComposition(projectDir, rootHtml),
+    ...await lintVideoMediaStartPastEof(projectDir, allHtmlSources),
     ...await lintHevcPreviewCodec(collectLocalVideoCandidates(projectDir, allHtmlSources))
   ];
   if (projectFindings.length > 0) {
@@ -5661,7 +5795,7 @@ async function lintProject(projectDir, entryFile) {
   return { results, totalErrors, totalWarnings, totalInfos };
 }
 function lintBlankRootWithStandaloneComposition(rootHtml, htmlSources) {
-  const { document: rootDocument } = parseHTML2(rootHtml);
+  const { document: rootDocument } = parseHTML3(rootHtml);
   const root = rootDocument.querySelector("body [data-composition-id]");
   if (!root || root.querySelector("*:not(script):not(style):not(link):not(meta):not(template)")) {
     return [];
@@ -5669,7 +5803,7 @@ function lintBlankRootWithStandaloneComposition(rootHtml, htmlSources) {
   const standaloneCandidates = [];
   for (const source of htmlSources) {
     if (!source.compSrcPath) continue;
-    const { document } = parseHTML2(source.html);
+    const { document } = parseHTML3(source.html);
     const composition = document.querySelector("body [data-composition-id]");
     if (!composition) continue;
     const authoredTimedContent = Array.from(