@latentic/live-markdown 0.3.0 → 0.4.0

package/dist/imageInsert.js

@@ -0,0 +1,111 @@
+import "./chunk-V6TY7KAL.js";
+async function insertImageBlob(opts) {
+  const alt = opts.alt ?? defaultAltFromMime(opts.blob.type);
+  const filename = buildImageFilename(opts.blob.type);
+  if (opts.saveBytes) {
+    try {
+      const bytes = new Uint8Array(await opts.blob.arrayBuffer());
+      await opts.saveBytes(`images/${filename}`, bytes);
+      return {
+        markdownReference: `images/${filename}`,
+        alt
+      };
+    } catch (error) {
+      return {
+        markdownReference: await blobToDataUrl(opts.blob),
+        alt,
+        warning: error instanceof Error ? `Saved as inline data URL: ${error.message}` : "Saved as inline data URL \u2014 workspace write unavailable"
+      };
+    }
+  }
+  return {
+    markdownReference: await blobToDataUrl(opts.blob),
+    alt,
+    warning: "Saved as inline data URL \u2014 no file storage configured"
+  };
+}
+function buildImageMarkdown(result) {
+  return `![${result.alt}](${result.markdownReference})`;
+}
+function extractImageBlobs(items) {
+  if (!items) return [];
+  const blobs = [];
+  for (let i = 0; i < items.length; i += 1) {
+    const item = items[i];
+    if (item.kind === "file" && item.type.startsWith("image/")) {
+      const blob = item.getAsFile();
+      if (blob) {
+        blobs.push(blob);
+      }
+    }
+  }
+  return blobs;
+}
+function extractImageFiles(files) {
+  if (!files) return [];
+  const out = [];
+  for (let i = 0; i < files.length; i += 1) {
+    const file = files[i];
+    if (file.type.startsWith("image/")) {
+      out.push(file);
+    }
+  }
+  return out;
+}
+function defaultAltFromMime(mime) {
+  const sub = mime.split("/")[1] ?? "image";
+  return `pasted-${sub}`;
+}
+function buildImageFilename(mime) {
+  const ext = extensionForMime(mime);
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `pasted-${ts}-${suffix}.${ext}`;
+}
+function extensionForMime(mime) {
+  switch (mime) {
+    case "image/png":
+      return "png";
+    case "image/jpeg":
+    case "image/jpg":
+      return "jpg";
+    case "image/gif":
+      return "gif";
+    case "image/webp":
+      return "webp";
+    case "image/svg+xml":
+      return "svg";
+    case "image/bmp":
+      return "bmp";
+    default:
+      return "bin";
+  }
+}
+async function blobToDataUrl(blob) {
+  const buffer = new Uint8Array(await blob.arrayBuffer());
+  const base64 = bytesToBase64(buffer);
+  const mime = blob.type || "application/octet-stream";
+  return `data:${mime};base64,${base64}`;
+}
+function bytesToBase64(bytes) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    const chunk = 32768;
+    for (let i = 0; i < bytes.length; i += chunk) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+  }
+  const buffer = globalThis.Buffer;
+  if (buffer && typeof buffer.from === "function") {
+    return buffer.from(bytes).toString("base64");
+  }
+  throw new Error("No base64 encoder available in this environment");
+}
+export {
+  buildImageMarkdown,
+  extractImageBlobs,
+  extractImageFiles,
+  insertImageBlob
+};
+//# sourceMappingURL=imageInsert.js.map

package/dist/imageInsert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/imageInsert.ts"],"sourcesContent":["/**\n * Image-insertion pipeline. Used by both paste-from-clipboard and\n * drag-and-drop. Both produce a `Blob`; this module turns the blob\n * into a markdown-reference-able path:\n *\n *   * When a `saveBytes` writer is injected (a desktop host): writes\n *     the bytes to `images/<timestamp>-<hash>.<ext>` and returns the\n *     relative path. The markdown reference is portable across\n *     machines because it's a real on-disk file.\n *   * Otherwise (plain browser, or the write fails): falls back to a\n *     data URL embedded directly in the markdown. The markdown file\n *     bloats but the image stays visible through page reload without\n *     needing a binary file API.\n *\n * The writer is injected rather than imported so this module stays\n * environment-agnostic — the editor reads it off a CM6 facet\n * ({@link saveImageBytesFacet}) the host wires up.\n *\n * Returned `markdownReference` is what the caller drops into\n * `![alt](…)`. `warning` is set in the data-URL fallback case so\n * the caller can surface a note to the user.\n */\nexport interface ImageInsertOptions {\n  blob: Blob;\n  /**\n   * Persist the bytes at a workspace-relative path. `null`/omitted ⇒\n   * inline as a data URL (browser fallback).\n   */\n  saveBytes?: ((relPath: string, bytes: Uint8Array) => Promise<void>) | null;\n  /**\n   * Alt text the user typed (currently always synthesized as\n   * \"pasted-image\" or \"dropped-image\"; in phase 3d the inline\n   * rename UI lets the user edit it post-insert).\n   */\n  alt?: string;\n}\n\nexport interface ImageInsertResult {\n  markdownReference: string;\n  alt: string;\n  warning?: string;\n}\n\n/**\n * Save the blob and return the markdown reference. Errors are\n * structured (the caller decides whether to retry with a fallback\n * or surface a notification).\n */\nexport async function insertImageBlob(opts: ImageInsertOptions): Promise<ImageInsertResult> {\n  const alt = opts.alt ?? defaultAltFromMime(opts.blob.type);\n  const filename = buildImageFilename(opts.blob.type);\n\n  // Try the on-disk pipeline first. Falls back to a data URL when no\n  // writer is injected (plain browser) or the write fails for a\n  // recoverable reason.\n  if (opts.saveBytes) {\n    try {\n      const bytes = new Uint8Array(await opts.blob.arrayBuffer());\n      await opts.saveBytes(`images/${filename}`, bytes);\n      return {\n        markdownReference: `images/${filename}`,\n        alt,\n      };\n    } catch (error) {\n      return {\n        markdownReference: await blobToDataUrl(opts.blob),\n        alt,\n        warning:\n          error instanceof Error\n            ? `Saved as inline data URL: ${error.message}`\n            : \"Saved as inline data URL — workspace write unavailable\",\n      };\n    }\n  }\n\n  return {\n    markdownReference: await blobToDataUrl(opts.blob),\n    alt,\n    warning: \"Saved as inline data URL — no file storage configured\",\n  };\n}\n\n/**\n * Build a markdown image insertion string from the result. Keeps\n * the call site (handlePaste / handleDrop) tidy.\n */\nexport function buildImageMarkdown(result: ImageInsertResult): string {\n  return `![${result.alt}](${result.markdownReference})`;\n}\n\n/**\n * Scan a DataTransferItemList for image blobs. Returns every\n * image found, in order. Empty array when nothing matches —\n * caller treats that as \"fall through to text paste\".\n */\nexport function extractImageBlobs(items: DataTransferItemList | null | undefined): Blob[] {\n  if (!items) return [];\n  const blobs: Blob[] = [];\n  for (let i = 0; i < items.length; i += 1) {\n    const item = items[i];\n    if (item.kind === \"file\" && item.type.startsWith(\"image/\")) {\n      const blob = item.getAsFile();\n      if (blob) {\n        blobs.push(blob);\n      }\n    }\n  }\n  return blobs;\n}\n\n/**\n * Scan a FileList (drag-and-drop's `dataTransfer.files`) for\n * image files. Drag-drop and paste use different shapes; this\n * keeps the two paths symmetrical at the call site.\n */\nexport function extractImageFiles(files: FileList | null | undefined): File[] {\n  if (!files) return [];\n  const out: File[] = [];\n  for (let i = 0; i < files.length; i += 1) {\n    const file = files[i];\n    if (file.type.startsWith(\"image/\")) {\n      out.push(file);\n    }\n  }\n  return out;\n}\n\nfunction defaultAltFromMime(mime: string): string {\n  const sub = mime.split(\"/\")[1] ?? \"image\";\n  return `pasted-${sub}`;\n}\n\nfunction buildImageFilename(mime: string): string {\n  const ext = extensionForMime(mime);\n  // Timestamp first so files sort chronologically; short suffix\n  // disambiguates within-tick collisions (multi-image drops).\n  const ts = new Date().toISOString().replace(/[:.]/g, \"-\");\n  const suffix = Math.random().toString(36).slice(2, 8);\n  return `pasted-${ts}-${suffix}.${ext}`;\n}\n\nfunction extensionForMime(mime: string): string {\n  switch (mime) {\n    case \"image/png\":\n      return \"png\";\n    case \"image/jpeg\":\n    case \"image/jpg\":\n      return \"jpg\";\n    case \"image/gif\":\n      return \"gif\";\n    case \"image/webp\":\n      return \"webp\";\n    case \"image/svg+xml\":\n      return \"svg\";\n    case \"image/bmp\":\n      return \"bmp\";\n    default:\n      return \"bin\";\n  }\n}\n\nasync function blobToDataUrl(blob: Blob): Promise<string> {\n  // Built-in `FileReader.readAsDataURL` is the conventional path\n  // but it isn't available in node test environments. Building\n  // the data URL by hand from the byte buffer keeps the helper\n  // testable AND avoids an extra async hop in production.\n  const buffer = new Uint8Array(await blob.arrayBuffer());\n  const base64 = bytesToBase64(buffer);\n  const mime = blob.type || \"application/octet-stream\";\n  return `data:${mime};base64,${base64}`;\n}\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  // Browser path — `btoa` over the string built from char codes.\n  if (typeof btoa === \"function\") {\n    let binary = \"\";\n    const chunk = 0x8000;\n    for (let i = 0; i < bytes.length; i += chunk) {\n      // String.fromCharCode handles small slices; chunking\n      // avoids the \"Maximum call stack size exceeded\" issue with\n      // the spread operator on multi-MB images.\n      binary += String.fromCharCode(...bytes.subarray(i, i + chunk));\n    }\n    return btoa(binary);\n  }\n  // Node path — Buffer is available in vitest's node environment.\n  // We use `globalThis` to avoid pulling in a Node type\n  // declaration on the browser side.\n  const buffer = (globalThis as unknown as { Buffer?: { from: (b: Uint8Array) => { toString: (enc: string) => string } } }).Buffer;\n  if (buffer && typeof buffer.from === \"function\") {\n    return buffer.from(bytes).toString(\"base64\");\n  }\n  throw new Error(\"No base64 encoder available in this environment\");\n}\n"],"mappings":"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","names":[]}

package/dist/imageSrcResolver.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Display-time resolution of image `src` values for the editor — the
+ * environment-agnostic pieces.
+ *
+ * Markdown stores image references **workspace-relative and portable** (e.g.
+ * `images/pasted-….png`), which is what lands on disk and survives moving the
+ * folder between machines. A WebView, though, can't load a bare relative path
+ * against its app origin, so a host that streams local files needs to map the
+ * reference onto its own asset protocol.
+ *
+ * This module provides the host-independent parts: the POSIX path helpers
+ * (`computeFileDir` / `joinPath` / …), the `hasUriScheme` guard, and
+ * `defaultResolveImageSrc` (render as-is — the browser/SSR default). A desktop
+ * host composes these with its file API (e.g. Tauri `convertFileSrc`) to build
+ * its own resolver and injects it via the editor's `resolveImageSrc` prop. The
+ * stored markdown reference is never rewritten — only the rendered `<img src>`.
+ *
+ * Paths are treated as POSIX (`/`), matching the macOS/Linux workspace folders
+ * this targets. Windows-style drive paths are passed through unresolved.
+ */
+interface ImageResolveContext {
+    /** Absolute OS directory of the markdown file being edited, or null. */
+    fileDir: string | null;
+}
+/**
+ * True when `src` already carries a URI scheme, a protocol-relative `//`, or a
+ * bare fragment — i.e. it's directly loadable and needs no path resolution. A
+ * host's display-src resolver uses this to decide whether to map a relative
+ * workspace path onto its own asset protocol.
+ */
+declare function hasUriScheme(src: string): boolean;
+/**
+ * Environment-agnostic default for the editor's `resolveImageSrcFacet`: render
+ * the reference as-is. Data URLs and absolute/schemed URLs load directly; a
+ * relative ref resolves against the page origin (or shows broken if no backing
+ * file). A desktop host overrides the facet with its own resolver, which maps
+ * relative paths onto a local asset protocol.
+ */
+declare function defaultResolveImageSrc(rawSrc: string, _ctx: ImageResolveContext): string;
+/**
+ * The directory a relative image reference resolves against: the folder
+ * containing the active markdown file. Falls back to the workspace root when
+ * the file path is unknown, and to null when there's no workspace.
+ */
+declare function computeFileDir(workspaceRoot: string | null | undefined, filePath: string | null | undefined): string | null;
+declare function isAbsolutePath(p: string): boolean;
+/** POSIX `dirname`: the parent of a path, with trailing slashes ignored. */
+declare function dirnamePath(p: string): string;
+/**
+ * Join `rel` onto `dir`, normalizing `.` and `..` segments. Absolute-ness is
+ * inherited from `dir`; `..` never escapes above an absolute root.
+ */
+declare function joinPath(dir: string, rel: string): string;
+
+export { type ImageResolveContext, computeFileDir, defaultResolveImageSrc, dirnamePath, hasUriScheme, isAbsolutePath, joinPath };

package/dist/imageSrcResolver.js

@@ -0,0 +1,49 @@
+import "./chunk-V6TY7KAL.js";
+const HAS_SCHEME = /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i;
+function hasUriScheme(src) {
+  return HAS_SCHEME.test(src.trim());
+}
+function defaultResolveImageSrc(rawSrc, _ctx) {
+  return rawSrc.trim();
+}
+function computeFileDir(workspaceRoot, filePath) {
+  if (!workspaceRoot) return null;
+  if (!filePath) return workspaceRoot;
+  return dirnamePath(joinPath(workspaceRoot, filePath));
+}
+function isAbsolutePath(p) {
+  return p.startsWith("/");
+}
+function dirnamePath(p) {
+  const trimmed = p.replace(/\/+$/, "");
+  const idx = trimmed.lastIndexOf("/");
+  if (idx < 0) return ".";
+  if (idx === 0) return "/";
+  return trimmed.slice(0, idx);
+}
+function joinPath(dir, rel) {
+  const isAbs = isAbsolutePath(dir);
+  const out = [];
+  for (const part of `${dir}/${rel}`.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (out.length && out[out.length - 1] !== "..") {
+        out.pop();
+      } else if (!isAbs) {
+        out.push("..");
+      }
+      continue;
+    }
+    out.push(part);
+  }
+  return (isAbs ? "/" : "") + out.join("/");
+}
+export {
+  computeFileDir,
+  defaultResolveImageSrc,
+  dirnamePath,
+  hasUriScheme,
+  isAbsolutePath,
+  joinPath
+};
+//# sourceMappingURL=imageSrcResolver.js.map

package/dist/imageSrcResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/imageSrcResolver.ts"],"sourcesContent":["/**\n * Display-time resolution of image `src` values for the editor — the\n * environment-agnostic pieces.\n *\n * Markdown stores image references **workspace-relative and portable** (e.g.\n * `images/pasted-….png`), which is what lands on disk and survives moving the\n * folder between machines. A WebView, though, can't load a bare relative path\n * against its app origin, so a host that streams local files needs to map the\n * reference onto its own asset protocol.\n *\n * This module provides the host-independent parts: the POSIX path helpers\n * (`computeFileDir` / `joinPath` / …), the `hasUriScheme` guard, and\n * `defaultResolveImageSrc` (render as-is — the browser/SSR default). A desktop\n * host composes these with its file API (e.g. Tauri `convertFileSrc`) to build\n * its own resolver and injects it via the editor's `resolveImageSrc` prop. The\n * stored markdown reference is never rewritten — only the rendered `<img src>`.\n *\n * Paths are treated as POSIX (`/`), matching the macOS/Linux workspace folders\n * this targets. Windows-style drive paths are passed through unresolved.\n */\nexport interface ImageResolveContext {\n  /** Absolute OS directory of the markdown file being edited, or null. */\n  fileDir: string | null;\n}\n\n// Anything that already carries a scheme (`data:`, `http(s):`, `asset:`,\n// `blob:`, `file:`, `tauri:`, `mailto:` …), a protocol-relative `//`, or a bare\n// fragment `#` is \"already resolvable\" — no path resolution applies.\nconst HAS_SCHEME = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/|#)/i;\n\n/**\n * True when `src` already carries a URI scheme, a protocol-relative `//`, or a\n * bare fragment — i.e. it's directly loadable and needs no path resolution. A\n * host's display-src resolver uses this to decide whether to map a relative\n * workspace path onto its own asset protocol.\n */\nexport function hasUriScheme(src: string): boolean {\n  return HAS_SCHEME.test(src.trim());\n}\n\n/**\n * Environment-agnostic default for the editor's `resolveImageSrcFacet`: render\n * the reference as-is. Data URLs and absolute/schemed URLs load directly; a\n * relative ref resolves against the page origin (or shows broken if no backing\n * file). A desktop host overrides the facet with its own resolver, which maps\n * relative paths onto a local asset protocol.\n */\nexport function defaultResolveImageSrc(rawSrc: string, _ctx: ImageResolveContext): string {\n  return rawSrc.trim();\n}\n\n/**\n * The directory a relative image reference resolves against: the folder\n * containing the active markdown file. Falls back to the workspace root when\n * the file path is unknown, and to null when there's no workspace.\n */\nexport function computeFileDir(\n  workspaceRoot: string | null | undefined,\n  filePath: string | null | undefined,\n): string | null {\n  if (!workspaceRoot) return null;\n  if (!filePath) return workspaceRoot;\n  return dirnamePath(joinPath(workspaceRoot, filePath));\n}\n\nexport function isAbsolutePath(p: string): boolean {\n  return p.startsWith(\"/\");\n}\n\n/** POSIX `dirname`: the parent of a path, with trailing slashes ignored. */\nexport function dirnamePath(p: string): string {\n  const trimmed = p.replace(/\\/+$/, \"\");\n  const idx = trimmed.lastIndexOf(\"/\");\n  if (idx < 0) return \".\";\n  if (idx === 0) return \"/\";\n  return trimmed.slice(0, idx);\n}\n\n/**\n * Join `rel` onto `dir`, normalizing `.` and `..` segments. Absolute-ness is\n * inherited from `dir`; `..` never escapes above an absolute root.\n */\nexport function joinPath(dir: string, rel: string): string {\n  const isAbs = isAbsolutePath(dir);\n  const out: string[] = [];\n  for (const part of `${dir}/${rel}`.split(\"/\")) {\n    if (part === \"\" || part === \".\") continue;\n    if (part === \"..\") {\n      if (out.length && out[out.length - 1] !== \"..\") {\n        out.pop();\n      } else if (!isAbs) {\n        out.push(\"..\");\n      }\n      continue;\n    }\n    out.push(part);\n  }\n  return (isAbs ? \"/\" : \"\") + out.join(\"/\");\n}\n"],"mappings":";AA4BA,MAAM,aAAa;AAQZ,SAAS,aAAa,KAAsB;AACjD,SAAO,WAAW,KAAK,IAAI,KAAK,CAAC;AACnC;AASO,SAAS,uBAAuB,QAAgB,MAAmC;AACxF,SAAO,OAAO,KAAK;AACrB;AAOO,SAAS,eACd,eACA,UACe;AACf,MAAI,CAAC,cAAe,QAAO;AAC3B,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO,YAAY,SAAS,eAAe,QAAQ,CAAC;AACtD;AAEO,SAAS,eAAe,GAAoB;AACjD,SAAO,EAAE,WAAW,GAAG;AACzB;AAGO,SAAS,YAAY,GAAmB;AAC7C,QAAM,UAAU,EAAE,QAAQ,QAAQ,EAAE;AACpC,QAAM,MAAM,QAAQ,YAAY,GAAG;AACnC,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,QAAQ,EAAG,QAAO;AACtB,SAAO,QAAQ,MAAM,GAAG,GAAG;AAC7B;AAMO,SAAS,SAAS,KAAa,KAAqB;AACzD,QAAM,QAAQ,eAAe,GAAG;AAChC,QAAM,MAAgB,CAAC;AACvB,aAAW,QAAQ,GAAG,GAAG,IAAI,GAAG,GAAG,MAAM,GAAG,GAAG;AAC7C,QAAI,SAAS,MAAM,SAAS,IAAK;AACjC,QAAI,SAAS,MAAM;AACjB,UAAI,IAAI,UAAU,IAAI,IAAI,SAAS,CAAC,MAAM,MAAM;AAC9C,YAAI,IAAI;AAAA,MACV,WAAW,CAAC,OAAO;AACjB,YAAI,KAAK,IAAI;AAAA,MACf;AACA;AAAA,IACF;AACA,QAAI,KAAK,IAAI;AAAA,EACf;AACA,UAAQ,QAAQ,MAAM,MAAM,IAAI,KAAK,GAAG;AAC1C;","names":[]}