@hyperframes/parsers 0.8.171 → 0.8.172

package/dist/assetResolution.d.ts

@@ -53,6 +53,8 @@ declare function resolveExistingLocalAsset(projectDir: string, url: string): {
     resolved: string;
     rootRelativePath: string;
 } | null;
+/** The project file a `src` authored in `compositionFile` loads in preview and render; null when none exists. */
+declare function resolveAuthoredAssetFile(projectDir: string, compositionFile: string, src: string): string | null;
 /** Resolves a media `src` like a browser URL (`..` clamps at the project root); a miss returns the base-dir join. */
 declare function resolveProjectRelativeSrc(src: string, baseDir: string, compiledDir?: string): string;
 /** Blanks out comments, `<style>`, and `<script>` bodies so tag-scanning
@@ -69,4 +71,4 @@ type ProjectFileRead = {
 /** Reads through one descriptor, so the file-type check and the read see the same file. */
 declare function readProjectFile(path: string): ProjectFileRead;
 
-export { type ProjectFileRead, cleanAssetUrl, collectSubCompositionSrcs, hasUnresolvedTemplatingToken, isRemoteOrInlineUrl, isUnresolvedAssetPlaceholder, isWithinProjectRoot, maskNonScannableRanges, readProjectFile, resolveExistingLocalAsset, resolveLocalAssetCandidates, resolveProjectRelativeSrc };
+export { type ProjectFileRead, cleanAssetUrl, collectSubCompositionSrcs, hasUnresolvedTemplatingToken, isRemoteOrInlineUrl, isUnresolvedAssetPlaceholder, isWithinProjectRoot, maskNonScannableRanges, readProjectFile, resolveAuthoredAssetFile, resolveExistingLocalAsset, resolveLocalAssetCandidates, resolveProjectRelativeSrc };

package/dist/assetResolution.js

@@ -88,7 +88,7 @@ function decodeAuthoredAttribute(value) {
 
 // src/assetResolution.ts
 import { closeSync, constants, existsSync, fstatSync, openSync, readFileSync } from "fs";
-import { isAbsolute, join, posix, relative, resolve, sep } from "path";
+import { isAbsolute as isAbsolute2, join as join2, posix as posix2, relative as relative2, resolve as resolve3, sep } from "path";
 
 // src/utils/urlPath.ts
 function decodeUrlPathVariants(path) {
@@ -104,6 +104,46 @@ function decodeWellFormedEscapes(path) {
     }
   });
 }
+function splitUrlSuffix(urlValue) {
+  const queryIdx = urlValue.indexOf("?");
+  const hashIdx = urlValue.indexOf("#");
+  if (queryIdx < 0 && hashIdx < 0) return { basePath: urlValue, suffix: "" };
+  let cutIdx = urlValue.length;
+  if (queryIdx >= 0) cutIdx = Math.min(cutIdx, queryIdx);
+  if (hashIdx >= 0) cutIdx = Math.min(cutIdx, hashIdx);
+  return { basePath: urlValue.slice(0, cutIdx), suffix: urlValue.slice(cutIdx) };
+}
+function encodeUrlPath(path) {
+  return encodeURIComponent(path).replace(/%2F/g, "/").replace(/['()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+// src/rewriteSubCompPaths.ts
+import { posix } from "path";
+
+// src/assetPaths.ts
+import { isAbsolute, relative, resolve } from "path";
+function isNonRelativeUrl(val) {
+  return !val || val.startsWith("http://") || val.startsWith("https://") || val.startsWith("//") || val.startsWith("data:") || val.startsWith("#") || val.startsWith("/");
+}
+
+// src/rewriteSubCompPaths.ts
+var { join, resolve: resolve2, dirname } = posix;
+var isAbsoluteOrSpecial = isNonRelativeUrl;
+function needsRewrite(val) {
+  return val.startsWith("../") || val === "..";
+}
+function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
+  if (isAbsoluteOrSpecial(relativePath)) return relativePath;
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return relativePath;
+  const { basePath, suffix } = splitUrlSuffix(relativePath);
+  const slashed = basePath.replace(/\\/g, "/");
+  if (!slashed || slashed.startsWith("/")) return relativePath;
+  const filePath = decodeWellFormedEscapes(slashed);
+  const sibling = resolve2("/", join(compDir, filePath)).slice(1);
+  if (!needsRewrite(filePath) && (!assetExists || !assetExists(sibling))) return relativePath;
+  return encodeUrlPath(sibling) + suffix;
+}
 
 // src/assetResolution.ts
 function isRemoteOrInlineUrl(url) {
@@ -134,7 +174,7 @@ function collectSubCompositionSrcs(html) {
 function cleanAssetUrl(url) {
   return url.trim().split(/[?#]/, 1)[0] ?? "";
 }
-function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve, relative, isAbsolute }) {
+function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve: resolve3, relative: relative2, isAbsolute: isAbsolute2 }) {
   const projectRoot = pathModule.resolve(projectDir);
   const relativePath = pathModule.relative(projectRoot, candidate);
   return relativePath === "" || !relativePath.startsWith("..") && !pathModule.isAbsolute(relativePath);
@@ -144,49 +184,55 @@ function addCandidate(candidates, candidate) {
 }
 function resolveLocalAssetCandidates(projectDir, url) {
   const cleanUrl = cleanAssetUrl(url);
-  const projectRoot = resolve(projectDir);
+  const projectRoot = resolve3(projectDir);
   const candidates = [];
   for (const variant of decodeUrlPathVariants(cleanUrl)) {
     const projectRelative = variant.startsWith("/") ? variant.slice(1) : variant;
-    const resolved = resolve(projectRoot, projectRelative);
+    const resolved = resolve3(projectRoot, projectRelative);
     if (isWithinProjectRoot(projectRoot, resolved)) {
       addCandidate(candidates, resolved);
       continue;
     }
-    const normalized = posix.normalize(projectRelative.replace(/\\/g, "/"));
+    const normalized = posix2.normalize(projectRelative.replace(/\\/g, "/"));
     const clamped = normalized.replace(/^(\.\.\/)+/, "");
     if (clamped && !clamped.startsWith("..")) {
-      addCandidate(candidates, resolve(projectRoot, clamped));
+      addCandidate(candidates, resolve3(projectRoot, clamped));
     }
   }
   return candidates;
 }
 function resolveExistingLocalAsset(projectDir, url) {
-  const projectRoot = resolve(projectDir);
+  const projectRoot = resolve3(projectDir);
   const resolved = resolveLocalAssetCandidates(projectRoot, url).find(existsSync);
   if (!resolved) return null;
-  return { resolved, rootRelativePath: relative(projectRoot, resolved) };
+  return { resolved, rootRelativePath: relative2(projectRoot, resolved) };
+}
+function resolveAuthoredAssetFile(projectDir, compositionFile, src) {
+  const cleanSrc = cleanAssetUrl(src.trim());
+  if (!cleanSrc) return null;
+  const rootRelative = cleanSrc.startsWith("/") ? cleanSrc : rewriteAssetPath(compositionFile, cleanSrc, (path) => existsSync(join2(projectDir, path)));
+  return resolveExistingLocalAsset(projectDir, rootRelative)?.resolved ?? null;
 }
 function reanchoredCandidates(variant, baseDir, compiledDir) {
-  const baseAbs = resolve(baseDir);
-  const joinedAbs = resolve(join(baseDir, variant));
+  const baseAbs = resolve3(baseDir);
+  const joinedAbs = resolve3(join2(baseDir, variant));
   if (joinedAbs === baseAbs || joinedAbs.startsWith(baseAbs + sep)) return [];
-  const stripped = posix.normalize(variant.replace(/\\/g, "/")).replace(/^(\.\.\/)+/, "");
+  const stripped = posix2.normalize(variant.replace(/\\/g, "/")).replace(/^(\.\.\/)+/, "");
   if (!stripped || stripped === variant || stripped.startsWith("..")) return [];
-  return compiledDir ? [join(compiledDir, stripped), join(baseDir, stripped)] : [join(baseDir, stripped)];
+  return compiledDir ? [join2(compiledDir, stripped), join2(baseDir, stripped)] : [join2(baseDir, stripped)];
 }
 function resolveProjectRelativeSrc(src, baseDir, compiledDir) {
   const cleanSrc = cleanAssetUrl(src);
-  if (isAbsolute(cleanSrc) && existsSync(cleanSrc)) return cleanSrc;
+  if (isAbsolute2(cleanSrc) && existsSync(cleanSrc)) return cleanSrc;
   const candidates = /* @__PURE__ */ new Set();
   for (const variant of decodeUrlPathVariants(cleanSrc)) {
     for (const candidate of reanchoredCandidates(variant, baseDir, compiledDir)) {
       candidates.add(candidate);
     }
-    if (compiledDir) candidates.add(join(compiledDir, variant));
-    candidates.add(join(baseDir, variant));
+    if (compiledDir) candidates.add(join2(compiledDir, variant));
+    candidates.add(join2(baseDir, variant));
   }
-  return [...candidates].find(existsSync) ?? join(baseDir, cleanSrc);
+  return [...candidates].find(existsSync) ?? join2(baseDir, cleanSrc);
 }
 function maskRange(src, pattern) {
   return src.replace(pattern, (m) => " ".repeat(m.length));
@@ -237,6 +283,7 @@ export {
   isWithinProjectRoot,
   maskNonScannableRanges,
   readProjectFile,
+  resolveAuthoredAssetFile,
   resolveExistingLocalAsset,
   resolveLocalAssetCandidates,
   resolveProjectRelativeSrc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/parsers",
-  "version": "0.8.171",
+  "version": "0.8.172",
   "repository": {
     "type": "git",
     "url": "https://github.com/heygen-com/hyperframes",
@@ -119,7 +119,7 @@
     "tsx": "^4.21.0",
     "typescript": "^5.0.0",
     "vitest": "^4.1.11",
-    "@hyperframes/core": "0.8.171"
+    "@hyperframes/core": "0.8.172"
   },
   "scripts": {
     "build": "tsup",