@tutti-os/workspace-file-preview 0.0.190 → 0.0.192

package/dist/{chunk-SUQYO7VX.js → chunk-SDSS6OA5.js}

@@ -1,4 +1,4 @@
-// src/core/workspaceFilePreview.ts
+// src/core/workspaceFilePreviewKinds.ts
 var imageExtensions = /* @__PURE__ */ new Set([
   "avif",
   "gif",
@@ -8,13 +8,6 @@ var imageExtensions = /* @__PURE__ */ new Set([
   "svg",
   "webp"
 ]);
-var browserOpenableHtmlExtensions = /* @__PURE__ */ new Set([
-  "htm",
-  "html",
-  "shtml",
-  "xhtml"
-]);
-var browserOpenableVideoExtensions = /* @__PURE__ */ new Set(["mp4", "webm"]);
 var videoExtensions = /* @__PURE__ */ new Set([
   "avi",
   "m2ts",
@@ -27,8 +20,25 @@ var videoExtensions = /* @__PURE__ */ new Set([
   "webm",
   "wmv"
 ]);
-var workspaceFileVideoHandlerCollisionExtensions = /* @__PURE__ */ new Set(["ts"]);
+var workspaceFileBrowserVideoExtensions = /* @__PURE__ */ new Set(["mp4", "webm"]);
+var audioExtensions = /* @__PURE__ */ new Set([
+  "aac",
+  "flac",
+  "m4a",
+  "mp3",
+  "oga",
+  "ogg",
+  "opus",
+  "wav"
+]);
 var markdownExtensions = /* @__PURE__ */ new Set(["md", "mdx"]);
+var jsonExtensions = /* @__PURE__ */ new Set(["json", "jsonc"]);
+var csvExtensions = /* @__PURE__ */ new Set(["csv", "tsv"]);
+var htmlExtensions = /* @__PURE__ */ new Set(["htm", "html", "shtml", "xhtml"]);
+var pdfExtensions = /* @__PURE__ */ new Set(["pdf"]);
+var docxExtensions = /* @__PURE__ */ new Set(["docx"]);
+var xlsxExtensions = /* @__PURE__ */ new Set(["xlsx"]);
+var pptxExtensions = /* @__PURE__ */ new Set(["pptx"]);
 var codeExtensions = /* @__PURE__ */ new Set([
   "bash",
   "c",
@@ -40,11 +50,10 @@ var codeExtensions = /* @__PURE__ */ new Set([
   "go",
   "h",
   "hpp",
-  "html",
+  "ini",
   "java",
   "js",
   "jsx",
-  "json",
   "lua",
   "m",
   "mm",
@@ -65,7 +74,16 @@ var codeExtensions = /* @__PURE__ */ new Set([
   "yml",
   "zsh"
 ]);
-var documentExtensions = /* @__PURE__ */ new Set([
+var plainTextExtensions = /* @__PURE__ */ new Set(["env", "log", "txt"]);
+var textFileNames = /* @__PURE__ */ new Set([
+  ".gitignore",
+  ".npmrc",
+  ".nvmrc",
+  "dockerfile",
+  "makefile",
+  "readme"
+]);
+var documentVisualExtensions = /* @__PURE__ */ new Set([
   "csv",
   "doc",
   "docx",
@@ -76,61 +94,39 @@ var documentExtensions = /* @__PURE__ */ new Set([
   "xls",
   "xlsx"
 ]);
-var textExtensions = /* @__PURE__ */ new Set([
-  "bash",
-  "c",
-  "cc",
-  "conf",
-  "cpp",
-  "cs",
-  "css",
-  "csv",
-  "env",
-  "go",
-  "h",
-  "hpp",
-  "html",
-  "ini",
-  "java",
-  "js",
+var textDegradablePreviewKinds = /* @__PURE__ */ new Set([
+  "text",
+  "code",
+  "markdown",
   "json",
-  "jsx",
-  "log",
-  "lua",
-  "m",
-  "md",
-  "mdx",
-  "mm",
-  "php",
-  "plist",
-  "proto",
-  "py",
-  "rb",
-  "rs",
-  "sh",
-  "sql",
-  "swift",
-  "toml",
-  "ts",
-  "tsx",
-  "txt",
-  "xml",
-  "yaml",
-  "yml",
-  "zsh"
-]);
-var textFileNames = /* @__PURE__ */ new Set([
-  ".gitignore",
-  ".npmrc",
-  ".nvmrc",
-  "dockerfile",
-  "makefile",
-  "readme"
+  "csv",
+  "html"
 ]);
-var workspaceFileTextMaxBytes = 1024 * 1024;
-var workspaceFilePreviewMaxBytes = 20 * 1024 * 1024;
+function resolveWorkspaceFileExtension(pathOrName) {
+  const name = pathOrName.split("/").pop()?.trim().toLowerCase() ?? "";
+  const dotIndex = name.lastIndexOf(".");
+  return dotIndex > 0 ? name.slice(dotIndex + 1) : "";
+}
+function resolveWorkspaceFilePreviewName(entry) {
+  return entry.name?.trim() || entry.path.split("/").pop()?.trim() || entry.path;
+}
+function isWorkspaceFileDirectoryKind(kind) {
+  return kind === "directory" || kind === "folder";
+}
+function isTextDegradablePreviewKind(kind) {
+  return textDegradablePreviewKinds.has(kind);
+}
+function resolveWorkspaceFileBuiltinRenderKind(kind) {
+  if (kind === "image" || kind === "video") {
+    return kind;
+  }
+  if (isTextDegradablePreviewKind(kind)) {
+    return "text";
+  }
+  return null;
+}
 function resolveWorkspaceFileVisualKind(entry) {
-  if (entry.kind === "directory" || entry.kind === "folder") {
+  if (isWorkspaceFileDirectoryKind(entry.kind)) {
     return "directory";
   }
   const extension = resolveWorkspaceFileExtension(
@@ -145,49 +141,82 @@ function resolveWorkspaceFileVisualKind(entry) {
   if (markdownExtensions.has(extension)) {
     return "markdown";
   }
-  if (codeExtensions.has(extension)) {
+  if (codeExtensions.has(extension) || jsonExtensions.has(extension)) {
     return "code";
   }
-  if (documentExtensions.has(extension)) {
+  if (documentVisualExtensions.has(extension) || htmlExtensions.has(extension) || pptxExtensions.has(extension)) {
     return "document";
   }
   return "binary";
 }
-function resolveWorkspaceFileExtension(pathOrName) {
-  const name = pathOrName.split("/").pop()?.trim().toLowerCase() ?? "";
-  const dotIndex = name.lastIndexOf(".");
-  return dotIndex > 0 ? name.slice(dotIndex + 1) : "";
-}
-function isWorkspaceFileBrowserOpenable(entry) {
+function classifyWorkspaceFilePreviewKind(entry) {
+  if (isWorkspaceFileDirectoryKind(entry.kind)) {
+    return "directory";
+  }
   if (entry.kind !== "file") {
-    return false;
+    return "unsupported";
   }
-  const extension = resolveWorkspaceFileExtension(
-    entry.path || entry.name || ""
-  );
-  if (extension === "pdf" || browserOpenableHtmlExtensions.has(extension) || imageExtensions.has(extension) || browserOpenableVideoExtensions.has(extension)) {
-    return true;
+  const name = resolveWorkspaceFilePreviewName(entry);
+  const extension = resolveWorkspaceFileExtension(name);
+  const normalizedName = name.trim().toLowerCase();
+  if (imageExtensions.has(extension)) {
+    return "image";
   }
-  return classifyWorkspaceFilePreviewKind(entry) === "text";
-}
-function shouldFilterVideoPlayersForOpenWith(entry) {
-  if (entry.kind !== "file") {
-    return false;
+  if (videoExtensions.has(extension)) {
+    return "video";
   }
-  const visualKind = resolveWorkspaceFileVisualKind(entry);
-  if (visualKind === "video") {
-    return false;
+  if (audioExtensions.has(extension)) {
+    return "audio";
   }
-  const extension = resolveWorkspaceFileExtension(
-    entry.path || entry.name || ""
-  );
-  if (workspaceFileVideoHandlerCollisionExtensions.has(extension)) {
-    return true;
+  if (markdownExtensions.has(extension)) {
+    return "markdown";
   }
-  if (visualKind === "code" || visualKind === "markdown") {
-    return true;
+  if (jsonExtensions.has(extension)) {
+    return "json";
+  }
+  if (csvExtensions.has(extension)) {
+    return "csv";
+  }
+  if (htmlExtensions.has(extension)) {
+    return "html";
+  }
+  if (pdfExtensions.has(extension)) {
+    return "pdf";
+  }
+  if (docxExtensions.has(extension)) {
+    return "docx";
+  }
+  if (xlsxExtensions.has(extension)) {
+    return "xlsx";
   }
-  return classifyWorkspaceFilePreviewKind(entry) === "text";
+  if (pptxExtensions.has(extension)) {
+    return "pptx";
+  }
+  if (codeExtensions.has(extension)) {
+    return "code";
+  }
+  if (plainTextExtensions.has(extension) || textFileNames.has(normalizedName)) {
+    return "text";
+  }
+  return "unsupported";
+}
+function resolveWorkspaceFilePreviewTarget(entry) {
+  const previewKind = classifyWorkspaceFilePreviewKind(entry);
+  if (resolveWorkspaceFileBuiltinRenderKind(previewKind) === null) {
+    return null;
+  }
+  const target = {
+    previewKind,
+    name: resolveWorkspaceFilePreviewName(entry),
+    path: entry.path
+  };
+  if (entry.mtimeMs !== void 0) {
+    target.mtimeMs = entry.mtimeMs;
+  }
+  if (entry.sizeBytes !== void 0) {
+    target.sizeBytes = entry.sizeBytes;
+  }
+  return target;
 }
 function resolveWorkspaceImageMimeType(pathOrName) {
   switch (resolveWorkspaceFileExtension(pathOrName)) {
@@ -218,57 +247,35 @@ function resolveWorkspaceVideoMimeType(pathOrName) {
       return null;
   }
 }
-function classifyWorkspaceFilePreviewKind(entry) {
-  if (entry.kind !== "file") {
-    return null;
-  }
-  const name = resolveWorkspaceFilePreviewName(entry);
-  if (resolveWorkspaceImageMimeType(name) !== null) {
-    return "image";
-  }
-  if (resolveWorkspaceVideoMimeType(name) !== null) {
-    return "video";
-  }
-  const normalizedName = name.trim().toLowerCase();
-  const extension = resolveWorkspaceFileExtension(name);
-  if (textExtensions.has(extension) || textFileNames.has(normalizedName)) {
-    return "text";
-  }
-  return null;
+function isWorkspaceFileBrowserHtmlExtension(extension) {
+  return htmlExtensions.has(extension);
 }
-function resolveWorkspaceFileActivationTarget(entry) {
-  const fileKind = classifyWorkspaceFilePreviewKind(entry);
-  if (!fileKind) {
-    return null;
-  }
-  const target = {
-    fileKind,
-    name: resolveWorkspaceFilePreviewName(entry),
-    path: entry.path
-  };
-  if (entry.mtimeMs !== void 0) {
-    target.mtimeMs = entry.mtimeMs;
-  }
-  if (entry.sizeBytes !== void 0) {
-    target.sizeBytes = entry.sizeBytes;
-  }
-  return target;
+function isWorkspaceFileImageExtension(extension) {
+  return imageExtensions.has(extension);
 }
-function resolveWorkspaceFilePreviewReadiness(entry) {
-  if (entry.kind === "directory" || entry.kind === "folder") {
+
+// src/core/workspaceFilePreview.ts
+var workspaceFileTextMaxBytes = 1024 * 1024;
+var workspaceFilePreviewMaxBytes = 20 * 1024 * 1024;
+function resolveWorkspaceFilePreviewReadiness(entry, options) {
+  const previewKind = classifyWorkspaceFilePreviewKind(entry);
+  if (previewKind === "directory") {
     return {
       entry,
       status: "directory"
     };
   }
-  const target = resolveWorkspaceFileActivationTarget(entry);
-  if (!target) {
+  const builtin = resolveWorkspaceFileBuiltinRenderKind(previewKind);
+  const hostRenderable = options?.hasHostRenderer?.(previewKind) === true && previewKind !== "unsupported";
+  if (!builtin && !hostRenderable) {
     return {
       entry,
+      previewKind,
       status: "unsupported"
     };
   }
-  if (target.fileKind === "text" && isWorkspaceTextFileTooLarge(entry.sizeBytes)) {
+  const target = resolveWorkspaceFilePreviewTarget(entry) ?? createWorkspaceFilePreviewTarget(entry, previewKind);
+  if ((builtin === "text" || isTextDegradablePreviewKind(previewKind)) && isWorkspaceTextFileTooLarge(entry.sizeBytes)) {
     return {
       entry,
       maxSizeBytes: workspaceFileTextMaxBytes,
@@ -291,22 +298,35 @@ function resolveWorkspaceFilePreviewReadiness(entry) {
   };
 }
 function createWorkspaceFilePreviewLoadedState(input) {
-  if (input.target.fileKind === "image") {
+  const previewKind = input.target.previewKind;
+  const builtin = resolveWorkspaceFileBuiltinRenderKind(previewKind);
+  if (builtin === "image") {
     return {
       bytes: copyWorkspaceFilePreviewBytes(input.bytes),
       contentType: input.contentType ?? resolveWorkspaceImageMimeType(input.target.name) ?? "application/octet-stream",
       entry: input.target,
+      previewKind: "image",
       status: "image"
     };
   }
-  if (input.target.fileKind === "video") {
+  if (builtin === "video") {
     return {
       bytes: copyWorkspaceFilePreviewBytes(input.bytes),
       contentType: input.contentType ?? resolveWorkspaceVideoMimeType(input.target.name) ?? "application/octet-stream",
       entry: input.target,
+      previewKind: "video",
       status: "video"
     };
   }
+  if (input.preferHostBytes || builtin === null) {
+    return {
+      bytes: copyWorkspaceFilePreviewBytes(input.bytes),
+      contentType: input.contentType ?? null,
+      entry: input.target,
+      previewKind,
+      status: "bytes"
+    };
+  }
   try {
     const content = decodeWorkspaceTextFile(input.bytes);
     if (looksLikeBinaryText(content)) {
@@ -319,6 +339,7 @@ function createWorkspaceFilePreviewLoadedState(input) {
     return {
       content,
       entry: input.target,
+      previewKind,
       status: "text"
     };
   } catch {
@@ -329,9 +350,6 @@ function createWorkspaceFilePreviewLoadedState(input) {
     };
   }
 }
-function resolveWorkspaceFilePreviewName(entry) {
-  return entry.name?.trim() || entry.displayName?.trim() || entry.path.split("/").pop()?.trim() || entry.path;
-}
 function isWorkspaceTextFileTooLarge(sizeBytes) {
   return typeof sizeBytes === "number" && Number.isFinite(sizeBytes) && sizeBytes > workspaceFileTextMaxBytes;
 }
@@ -385,6 +403,20 @@ function formatWorkspacePreviewByteLimit(sizeBytes) {
   }
   return `${mebibytes.toFixed(1)} MiB`;
 }
+function createWorkspaceFilePreviewTarget(entry, previewKind) {
+  const target = {
+    previewKind,
+    name: resolveWorkspaceFilePreviewName(entry),
+    path: entry.path
+  };
+  if (entry.mtimeMs !== void 0) {
+    target.mtimeMs = entry.mtimeMs;
+  }
+  if (entry.sizeBytes !== void 0) {
+    target.sizeBytes = entry.sizeBytes;
+  }
+  return target;
+}
 
 // src/core/workspaceFilePreviewController.ts
 function createWorkspaceFilePreviewController(input) {
@@ -476,21 +508,29 @@ var WorkspaceFilePreviewControllerImpl = class {
       if (!result) {
         this.updateState({
           entry,
+          previewKind: target.previewKind,
           reason: "file_type",
           status: "unsupported"
         });
         return;
       }
+      const resolvedKind = result.kind ?? target.previewKind;
+      const resolvedTarget = {
+        ...target,
+        previewKind: resolvedKind
+      };
+      const preferHostBytes = resolveWorkspaceFileBuiltinRenderKind(resolvedKind) === null;
       const loaded = createWorkspaceFilePreviewLoadedState({
-        bytes: result instanceof Uint8Array || result instanceof ArrayBuffer ? result : result.bytes,
-        contentType: result instanceof Uint8Array || result instanceof ArrayBuffer ? void 0 : result.contentType,
+        bytes: result.bytes,
+        contentType: result.contentType,
         entry: previewEntry,
-        target: result instanceof Uint8Array || result instanceof ArrayBuffer ? target : { ...target, fileKind: result.kind ?? target.fileKind }
+        preferHostBytes,
+        target: resolvedTarget
       });
       if (this.isStale(generation)) {
         return;
       }
-      if (loaded.status === "image" || loaded.status === "video") {
+      if (loaded.status === "image") {
         const previewSizeBytes = loaded.bytes.byteLength;
         const objectUrl = this.objectUrls.create(
           loaded.bytes,
@@ -504,8 +544,29 @@ var WorkspaceFilePreviewControllerImpl = class {
         this.updateState({
           entry,
           objectUrl,
+          previewKind: "image",
           previewSizeBytes,
-          status: loaded.status
+          status: "image"
+        });
+        return;
+      }
+      if (loaded.status === "video") {
+        const previewSizeBytes = loaded.bytes.byteLength;
+        const objectUrl = this.objectUrls.create(
+          loaded.bytes,
+          loaded.contentType
+        );
+        if (this.isStale(generation)) {
+          this.objectUrls.revoke(objectUrl);
+          return;
+        }
+        this.objectUrl = objectUrl;
+        this.updateState({
+          entry,
+          objectUrl,
+          previewKind: "video",
+          previewSizeBytes,
+          status: "video"
         });
         return;
       }
@@ -513,14 +574,27 @@ var WorkspaceFilePreviewControllerImpl = class {
         this.updateState({
           content: loaded.content,
           entry,
-          previewSizeBytes: byteLengthOfPreviewReadResult(result),
+          previewKind: loaded.previewKind,
+          previewSizeBytes: result.bytes.byteLength,
           status: "text"
         });
         return;
       }
+      if (loaded.status === "bytes") {
+        this.updateState({
+          bytes: loaded.bytes,
+          contentType: loaded.contentType,
+          entry,
+          previewKind: loaded.previewKind,
+          previewSizeBytes: loaded.bytes.byteLength,
+          status: "bytes"
+        });
+        return;
+      }
       this.updateState({
         entry,
-        previewSizeBytes: byteLengthOfPreviewReadResult(result),
+        previewKind: target.previewKind,
+        previewSizeBytes: result.bytes.byteLength,
         reason: loaded.reason,
         ...loaded.maxSizeBytes === void 0 ? {} : { maxSizeBytes: loaded.maxSizeBytes },
         status: "readonly"
@@ -529,7 +603,12 @@ var WorkspaceFilePreviewControllerImpl = class {
       if (this.isStale(generation)) {
         return;
       }
-      this.updateState({ entry, error, status: "error" });
+      this.updateState({
+        entry,
+        error,
+        previewKind: target.previewKind,
+        status: "error"
+      });
     } finally {
       if (!this.isStale(generation)) {
         this.abortController = null;
@@ -545,7 +624,6 @@ var WorkspaceFilePreviewControllerImpl = class {
       previewEntry.kind,
       previewEntry.path,
       previewEntry.name ?? "",
-      previewEntry.displayName ?? "",
       previewEntry.sizeBytes ?? "",
       previewEntry.mtimeMs ?? ""
     ].join("\0");
@@ -561,7 +639,9 @@ var WorkspaceFilePreviewControllerImpl = class {
     this.cancelLoad();
     this.revokeObjectUrl();
     const previewEntry = this.input.toPreviewEntry(entry);
-    const readiness = resolveWorkspaceFilePreviewReadiness(previewEntry);
+    const readiness = resolveWorkspaceFilePreviewReadiness(previewEntry, {
+      hasHostRenderer: this.input.hasHostRenderer
+    });
     if (readiness.status === "directory") {
       this.updateState({ entry, status: "directory" });
       this.loadPromise = Promise.resolve();
@@ -581,6 +661,7 @@ var WorkspaceFilePreviewControllerImpl = class {
       if (canRead !== true) {
         this.updateState({
           entry,
+          previewKind: readiness.previewKind,
           reason: "file_type",
           status: "unsupported"
         });
@@ -590,6 +671,7 @@ var WorkspaceFilePreviewControllerImpl = class {
       if (!this.input.read) {
         this.updateState({
           entry,
+          previewKind: readiness.previewKind,
           reason: "reader_unavailable",
           status: "unsupported"
         });
@@ -597,24 +679,13 @@ var WorkspaceFilePreviewControllerImpl = class {
         return this.loadPromise;
       }
       const target = {
-        fileKind: "text",
-        name: previewEntry.name ?? previewEntry.displayName ?? previewEntry.path.split("/").pop() ?? previewEntry.path,
+        previewKind: "text",
+        name: previewEntry.name ?? previewEntry.path.split("/").pop() ?? previewEntry.path,
         path: previewEntry.path,
         ...previewEntry.mtimeMs === void 0 ? {} : { mtimeMs: previewEntry.mtimeMs },
         ...previewEntry.sizeBytes === void 0 ? {} : { sizeBytes: previewEntry.sizeBytes }
       };
-      const abortController2 = new AbortController();
-      this.abortController = abortController2;
-      const generation2 = this.generation;
-      this.updateState({ entry, status: "loading" });
-      this.loadPromise = this.load(
-        entry,
-        previewEntry,
-        target,
-        generation2,
-        abortController2
-      );
-      return this.loadPromise;
+      return this.beginLoad(entry, previewEntry, target);
     }
     if (readiness.status === "readonly") {
       this.updateState({
@@ -629,20 +700,28 @@ var WorkspaceFilePreviewControllerImpl = class {
     if (!this.input.read) {
       this.updateState({
         entry,
+        previewKind: readiness.target.previewKind,
         reason: "reader_unavailable",
         status: "unsupported"
       });
       this.loadPromise = Promise.resolve();
       return this.loadPromise;
     }
+    return this.beginLoad(entry, previewEntry, readiness.target);
+  }
+  beginLoad(entry, previewEntry, target) {
     const abortController = new AbortController();
     this.abortController = abortController;
     const generation = this.generation;
-    this.updateState({ entry, status: "loading" });
+    this.updateState({
+      entry,
+      previewKind: target.previewKind,
+      status: "loading"
+    });
     this.loadPromise = this.load(
       entry,
       previewEntry,
-      readiness.target,
+      target,
       generation,
       abortController
     );
@@ -666,26 +745,25 @@ var browserWorkspaceFilePreviewObjectUrls = {
     URL.revokeObjectURL(objectUrl);
   }
 };
-function byteLengthOfPreviewReadResult(result) {
-  const bytes = result instanceof Uint8Array || result instanceof ArrayBuffer ? result : result.bytes;
-  return bytes.byteLength;
-}
 
 export {
-  workspaceFileVideoHandlerCollisionExtensions,
-  workspaceFileTextMaxBytes,
-  workspaceFilePreviewMaxBytes,
-  resolveWorkspaceFileVisualKind,
+  workspaceFileBrowserVideoExtensions,
   resolveWorkspaceFileExtension,
-  isWorkspaceFileBrowserOpenable,
-  shouldFilterVideoPlayersForOpenWith,
+  resolveWorkspaceFilePreviewName,
+  isWorkspaceFileDirectoryKind,
+  isTextDegradablePreviewKind,
+  resolveWorkspaceFileBuiltinRenderKind,
+  resolveWorkspaceFileVisualKind,
+  classifyWorkspaceFilePreviewKind,
+  resolveWorkspaceFilePreviewTarget,
   resolveWorkspaceImageMimeType,
   resolveWorkspaceVideoMimeType,
-  classifyWorkspaceFilePreviewKind,
-  resolveWorkspaceFileActivationTarget,
+  isWorkspaceFileBrowserHtmlExtension,
+  isWorkspaceFileImageExtension,
+  workspaceFileTextMaxBytes,
+  workspaceFilePreviewMaxBytes,
   resolveWorkspaceFilePreviewReadiness,
   createWorkspaceFilePreviewLoadedState,
-  resolveWorkspaceFilePreviewName,
   isWorkspaceTextFileTooLarge,
   isWorkspacePreviewFileTooLarge,
   decodeWorkspaceTextFile,
@@ -695,4 +773,4 @@ export {
   formatWorkspacePreviewByteLimit,
   createWorkspaceFilePreviewController
 };
-//# sourceMappingURL=chunk-SUQYO7VX.js.map
+//# sourceMappingURL=chunk-SDSS6OA5.js.map