@mnaoumov/obsidian-lib 10.8.0 → 10.9.0

package/dist/lib/esm/virtual-file.mjs

@@ -0,0 +1,264 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+
+import {
+  EditorState,
+  StateEffect
+} from "@codemirror/state";
+import {
+  CallbackDisposable,
+  MultipleDisposeBehavior
+} from "@mnaoumov/typescript-lib/disposable";
+import { parentFolderPath } from "@obsidian-typings/obsidian-public-latest/implementations";
+import {
+  MarkdownView,
+  normalizePath
+} from "obsidian";
+import { MonkeyAroundComponent } from "./components/monkey-around-component.mjs";
+import { toggleEditorReadOnly } from "./editor.mjs";
+import { getFile } from "./file-system.mjs";
+import {
+  parseMetadata,
+  registerFileCacheForNonExistingFile
+} from "./metadata-cache.mjs";
+import { getObsidianLibState } from "./obsidian-lib-state.mjs";
+async function registerVirtualFile(params) {
+  const { app, content } = params;
+  const path = normalizePath(params.path);
+  if (!path || path === "/" || params.path.split(/[\\/]/).some((part) => part === "." || part === "..") || /^[\\/]|:/.test(params.path)) {
+    throw new Error("A virtual file requires a vault-relative file path");
+  }
+  const reservations = getObsidianLibState("virtualFilePathsV1", /* @__PURE__ */ new Set()).value;
+  const key = path.toLowerCase();
+  if (reservations.has(key) || app.vault.getAbstractFileByPathInsensitive(path)) {
+    throw new Error(`File already exists: ${path}`);
+  }
+  const parent = parentFolderPath(path);
+  if (parent && parent !== "/" && !app.vault.getFolderByPath(parent)) {
+    throw new Error(`Parent folder does not exist: ${parent}`);
+  }
+  reservations.add(key);
+  try {
+    if (await app.vault.adapter.exists(path)) {
+      throw new Error(`File already exists: ${path}`);
+    }
+    const cache = path.endsWith(".md") ? await parseMetadata(app, content) : {};
+    if (app.vault.getAbstractFileByPathInsensitive(path)) {
+      throw new Error(`File already exists: ${path}`);
+    }
+    return installVirtualFile({ app, cache, content, path, reservations });
+  } catch (error) {
+    reservations.delete(key);
+    throw error;
+  }
+}
+function installVirtualFile(params) {
+  const { app, cache, content, path, reservations } = params;
+  const file = getFile({ app, pathOrFile: path, shouldIncludeNonExisting: true });
+  const bytes = new TextEncoder().encode(content);
+  file.stat = { ctime: Date.now(), mtime: Date.now(), size: bytes.byteLength };
+  const url = window.URL.createObjectURL(new Blob([bytes], { type: path.endsWith(".md") ? "text/markdown;charset=utf-8" : "text/plain;charset=utf-8" }));
+  const patches = new MonkeyAroundComponent();
+  patches.load();
+  const metadata = registerFileCacheForNonExistingFile({ app, cache, pathOrFile: file });
+  app.vault.fileMap[path] = file;
+  app.metadataCache.uniqueFileLookup.add(file.name.toLowerCase(), file);
+  patches.registerMethodPatch({ $object: app.vault, methodName: "read", patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? Promise.resolve(content) : fallback() });
+  patches.registerMethodPatch({ $object: app.vault, methodName: "cachedRead", patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? Promise.resolve(content) : fallback() });
+  patches.registerMethodPatch({ $object: app.vault, methodName: "readBinary", patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? Promise.resolve(new Uint8Array(bytes).buffer) : fallback() });
+  patches.registerMethodPatch({ $object: app.vault, methodName: "getResourcePath", patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? url : fallback() });
+  patches.registerMethodPatch({ $object: app.vault.adapter, methodName: "read", patchHandler: ({ fallback, originalArguments: [target] }) => isMatching(target) ? Promise.resolve(content) : fallback() });
+  patches.registerMethodPatch({ $object: app.vault.adapter, methodName: "readBinary", patchHandler: ({ fallback, originalArguments: [target] }) => isMatching(target) ? Promise.resolve(new Uint8Array(bytes).buffer) : fallback() });
+  patches.registerMethodPatch({ $object: app.vault.adapter, methodName: "getResourcePath", patchHandler: ({ fallback, originalArguments: [target] }) => isMatching(target) ? url : fallback() });
+  for (const methodName of ["append", "appendBinary", "modify", "modifyBinary", "process", "delete", "trash"]) {
+    patches.registerMethodPatch({
+      $object: app.vault,
+      methodName,
+      patchHandler: ({ fallback, originalArguments: [target] }) => {
+        assertWritable(target.path);
+        return fallback();
+      }
+    });
+  }
+  patches.registerMethodPatch({
+    $object: app.vault,
+    methodName: "rename",
+    patchHandler: ({ fallback, originalArguments: [target, destination] }) => {
+      assertWritable(target.path);
+      assertWritable(destination);
+      return fallback();
+    }
+  });
+  for (const methodName of ["create", "createBinary", "createFolder"]) {
+    patches.registerMethodPatch({
+      $object: app.vault,
+      methodName,
+      patchHandler: ({ fallback, originalArguments: [target] }) => {
+        assertWritable(target);
+        return fallback();
+      }
+    });
+  }
+  patches.registerMethodPatch({
+    $object: app.vault,
+    methodName: "copy",
+    patchHandler: ({ fallback, originalArguments: [, destination] }) => {
+      assertWritable(destination);
+      return fallback();
+    }
+  });
+  for (const methodName of ["write", "writeBinary", "append", "appendBinary", "process", "remove", "rmdir", "trashLocal", "trashSystem", "mkdir"]) {
+    patches.registerMethodPatch({
+      $object: app.vault.adapter,
+      methodName,
+      patchHandler: ({ fallback, originalArguments: [target] }) => {
+        assertWritable(target);
+        return fallback();
+      }
+    });
+  }
+  patches.registerMethodPatch({
+    $object: app.vault.adapter,
+    methodName: "rename",
+    patchHandler: ({ fallback, originalArguments: [target, destination] }) => {
+      assertWritable(target);
+      assertWritable(destination);
+      return fallback();
+    }
+  });
+  patches.registerMethodPatch({
+    $object: app.vault.adapter,
+    methodName: "copy",
+    patchHandler: ({ fallback, originalArguments: [, destination] }) => {
+      assertWritable(destination);
+      return fallback();
+    }
+  });
+  patches.registerMethodPatch({
+    $object: app.fileManager,
+    methodName: "renameFile",
+    patchHandler: ({ fallback, originalArguments: [target, destination] }) => {
+      assertWritable(target.path);
+      assertWritable(destination);
+      return fallback();
+    }
+  });
+  patches.registerMethodPatch({
+    $object: app.fileManager,
+    methodName: "trashFile",
+    patchHandler: ({ fallback, originalArguments: [target] }) => {
+      assertWritable(target.path);
+      return fallback();
+    }
+  });
+  patches.registerMethodPatch({
+    $object: MarkdownView.prototype,
+    methodName: "setViewData",
+    patchHandler: ({ fallback, originalThis }) => {
+      fallback();
+      if (originalThis.file === file) {
+        protectEditor(originalThis);
+      }
+    }
+  });
+  patches.registerMethodPatch({
+    $object: MarkdownView.prototype,
+    methodName: "onLoadFile",
+    patchHandler: async ({ fallback, originalThis }) => {
+      await fallback();
+      if (originalThis.file === file) {
+        protectEditor(originalThis);
+      }
+    }
+  });
+  patches.registerMethodPatch({
+    $object: MarkdownView.prototype,
+    methodName: "setMode",
+    patchHandler: async ({ fallback, originalThis }) => {
+      const result = await fallback();
+      if (originalThis.file === file) {
+        protectEditor(originalThis);
+      }
+      return result;
+    }
+  });
+  const disposable = new CallbackDisposable({
+    callback: () => {
+      app.workspace.iterateAllLeaves((leaf) => {
+        if ("file" in leaf.view && leaf.view.file === file) {
+          leaf.detach();
+        }
+      });
+      app.metadataCache.uniqueFileLookup.remove(file.name.toLowerCase(), file);
+      if (app.vault.fileMap[path] === file) {
+        Reflect.deleteProperty(app.vault.fileMap, path);
+        metadata[Symbol.dispose]();
+      }
+      patches.unload();
+      window.URL.revokeObjectURL(url);
+      reservations.delete(path.toLowerCase());
+    },
+    multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
+  });
+  return {
+    content,
+    file,
+    [Symbol.dispose]: () => {
+      disposable[Symbol.dispose]();
+    }
+  };
+  function isMatching(target) {
+    return normalizePath(target).toLowerCase() === path.toLowerCase();
+  }
+  function protectEditor(view) {
+    toggleEditorReadOnly(view.editor, true);
+    view.editor.cm.dispatch({
+      effects: StateEffect.appendConfig.of(EditorState.changeFilter.of(() => view.file !== file))
+    });
+  }
+  function assertWritable(target) {
+    const normalized = normalizePath(target).toLowerCase();
+    if (isMatching(target) || path.toLowerCase().startsWith(`${normalized}/`) || normalized === "/") {
+      throw new Error(`Virtual file is read-only: ${path}`);
+    }
+  }
+}
+export {
+  registerVirtualFile
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/virtual-file.ts"],"sourcesContent":["/**\n * @file\n * Disposable, read-only files backed by memory instead of the vault adapter.\n */\n\nimport type {\n  App,\n  TFile\n} from 'obsidian';\n\nimport {\n  EditorState,\n  StateEffect\n} from '@codemirror/state';\nimport {\n  CallbackDisposable,\n  MultipleDisposeBehavior\n} from '@mnaoumov/typescript-lib/disposable';\nimport { parentFolderPath } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  MarkdownView,\n  normalizePath\n} from 'obsidian';\n\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { toggleEditorReadOnly } from './editor.ts';\nimport { getFile } from './file-system.ts';\nimport {\n  parseMetadata,\n  registerFileCacheForNonExistingFile\n} from './metadata-cache.ts';\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\n/**\nParameters for {@link registerVirtualFile}.\n */\nexport interface RegisterVirtualFileParams {\n  /**\n  The app whose resolver and read methods serve the file.\n   */\n  readonly app: App;\n  /**\n  Immutable UTF-8 text, also available synchronously on the registration.\n   */\n  readonly content: string;\n  /**\n  Unoccupied vault-relative file path in an existing folder.\n   */\n  readonly path: string;\n}\n\n/**\nA memory file and its lifetime. Dispose it before its owning plugin unloads.\n */\nexport interface VirtualFile extends Disposable {\n  /**\n  The immutable text; accessing it requires no asynchronous read.\n   */\n  readonly content: string;\n  /**\n  The file accepted by Obsidian's link resolver and file views.\n   */\n  readonly file: TFile;\n}\n\ninterface InstallVirtualFileParams extends RegisterVirtualFileParams {\n  readonly cache: Awaited<ReturnType<typeof parseMetadata>> | Record<string, never>;\n  readonly reservations: Set<string>;\n}\n\n/**\n * Registers immutable text as a file without writing to the adapter.\n *\n * The parent folder must exist. Markdown views are read-only; vault and adapter mutations of the\n * path or its ancestors throw. Raw filesystem access and third-party views are outside this contract.\n * Resource URLs use UTF-8 blobs. Disposing closes views of this file and revokes its URL. No create\n * or delete events are emitted, so indexers and synchronization never treat it as a persisted file.\n *\n * @param params - The app, path and immutable text.\n * @returns The registered file, synchronous content and idempotent disposal callback.\n */\nexport async function registerVirtualFile(params: RegisterVirtualFileParams): Promise<VirtualFile> {\n  const { app, content } = params;\n  const path = normalizePath(params.path);\n  if (!path || path === '/' || params.path.split(/[\\\\/]/).some((part) => part === '.' || part === '..') || /^[\\\\/]|:/.test(params.path)) {\n    throw new Error('A virtual file requires a vault-relative file path');\n  }\n  const reservations = getObsidianLibState('virtualFilePathsV1', new Set<string>()).value;\n  const key = path.toLowerCase();\n  if (reservations.has(key) || app.vault.getAbstractFileByPathInsensitive(path)) {\n    throw new Error(`File already exists: ${path}`);\n  }\n  const parent = parentFolderPath(path);\n  if (parent && parent !== '/' && !app.vault.getFolderByPath(parent)) {\n    throw new Error(`Parent folder does not exist: ${parent}`);\n  }\n  reservations.add(key);\n  try {\n    if (await app.vault.adapter.exists(path)) {\n      throw new Error(`File already exists: ${path}`);\n    }\n    const cache = path.endsWith('.md') ? await parseMetadata(app, content) : {};\n    // Recheck after asynchronous work, before publishing anything to the resolver.\n    if (app.vault.getAbstractFileByPathInsensitive(path)) {\n      throw new Error(`File already exists: ${path}`);\n    }\n    return installVirtualFile({ app, cache, content, path, reservations });\n  } catch (error) {\n    reservations.delete(key);\n    throw error;\n  }\n}\n\nfunction installVirtualFile(params: InstallVirtualFileParams): VirtualFile {\n  const { app, cache, content, path, reservations } = params;\n  const file = getFile({ app, pathOrFile: path, shouldIncludeNonExisting: true });\n  const bytes = new TextEncoder().encode(content);\n  file.stat = { ctime: Date.now(), mtime: Date.now(), size: bytes.byteLength };\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- This is the browser's Blob URL API in Obsidian, not Node's implementation.\n  const url = window.URL.createObjectURL(new Blob([bytes], { type: path.endsWith('.md') ? 'text/markdown;charset=utf-8' : 'text/plain;charset=utf-8' }));\n  const patches = new MonkeyAroundComponent();\n  patches.load();\n  const metadata = registerFileCacheForNonExistingFile({ app, cache, pathOrFile: file });\n  app.vault.fileMap[path] = file;\n  app.metadataCache.uniqueFileLookup.add(file.name.toLowerCase(), file);\n\n  patches.registerMethodPatch({ $object: app.vault, methodName: 'read', patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? Promise.resolve(content) : fallback() });\n  patches.registerMethodPatch({ $object: app.vault, methodName: 'cachedRead', patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? Promise.resolve(content) : fallback() });\n  patches.registerMethodPatch({ $object: app.vault, methodName: 'readBinary', patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? Promise.resolve(new Uint8Array(bytes).buffer) : fallback() });\n  patches.registerMethodPatch({ $object: app.vault, methodName: 'getResourcePath', patchHandler: ({ fallback, originalArguments: [target] }) => target === file ? url : fallback() });\n  patches.registerMethodPatch({ $object: app.vault.adapter, methodName: 'read', patchHandler: ({ fallback, originalArguments: [target] }) => isMatching(target) ? Promise.resolve(content) : fallback() });\n  patches.registerMethodPatch({ $object: app.vault.adapter, methodName: 'readBinary', patchHandler: ({ fallback, originalArguments: [target] }) => isMatching(target) ? Promise.resolve(new Uint8Array(bytes).buffer) : fallback() });\n  patches.registerMethodPatch({ $object: app.vault.adapter, methodName: 'getResourcePath', patchHandler: ({ fallback, originalArguments: [target] }) => isMatching(target) ? url : fallback() });\n\n  for (const methodName of ['append', 'appendBinary', 'modify', 'modifyBinary', 'process', 'delete', 'trash'] as const) {\n    patches.registerMethodPatch({\n      $object: app.vault,\n      methodName,\n      patchHandler: ({ fallback, originalArguments: [target] }) => {\n        assertWritable(target.path);\n        return fallback();\n      }\n    });\n  }\n  patches.registerMethodPatch({\n    $object: app.vault,\n    methodName: 'rename',\n    patchHandler: ({ fallback, originalArguments: [target, destination] }) => {\n      assertWritable(target.path);\n      assertWritable(destination);\n      return fallback();\n    }\n  });\n  for (const methodName of ['create', 'createBinary', 'createFolder'] as const) {\n    patches.registerMethodPatch({\n      $object: app.vault,\n      methodName,\n      patchHandler: ({ fallback, originalArguments: [target] }) => {\n        assertWritable(target);\n        return fallback();\n      }\n    });\n  }\n  patches.registerMethodPatch({\n    $object: app.vault,\n    methodName: 'copy',\n    patchHandler: ({ fallback, originalArguments: [, destination] }) => {\n      assertWritable(destination);\n      return fallback();\n    }\n  });\n  for (const methodName of ['write', 'writeBinary', 'append', 'appendBinary', 'process', 'remove', 'rmdir', 'trashLocal', 'trashSystem', 'mkdir'] as const) {\n    patches.registerMethodPatch({\n      $object: app.vault.adapter,\n      methodName,\n      patchHandler: ({ fallback, originalArguments: [target] }) => {\n        assertWritable(target);\n        return fallback();\n      }\n    });\n  }\n  patches.registerMethodPatch({\n    $object: app.vault.adapter,\n    methodName: 'rename',\n    patchHandler: ({ fallback, originalArguments: [target, destination] }) => {\n      assertWritable(target);\n      assertWritable(destination);\n      return fallback();\n    }\n  });\n  patches.registerMethodPatch({\n    $object: app.vault.adapter,\n    methodName: 'copy',\n    patchHandler: ({ fallback, originalArguments: [, destination] }) => {\n      assertWritable(destination);\n      return fallback();\n    }\n  });\n  patches.registerMethodPatch({\n    $object: app.fileManager,\n    methodName: 'renameFile',\n    patchHandler: ({ fallback, originalArguments: [target, destination] }) => {\n      assertWritable(target.path);\n      assertWritable(destination);\n      return fallback();\n    }\n  });\n  patches.registerMethodPatch({\n    $object: app.fileManager,\n    methodName: 'trashFile',\n    patchHandler: ({ fallback, originalArguments: [target] }) => {\n      assertWritable(target.path);\n      return fallback();\n    }\n  });\n  patches.registerMethodPatch({\n    $object: MarkdownView.prototype,\n    methodName: 'setViewData',\n    patchHandler: ({ fallback, originalThis }) => {\n      fallback();\n      if (originalThis.file === file) {\n        protectEditor(originalThis);\n      }\n    }\n  });\n  patches.registerMethodPatch({\n    $object: MarkdownView.prototype,\n    methodName: 'onLoadFile',\n    patchHandler: async ({ fallback, originalThis }) => {\n      await fallback();\n      if (originalThis.file === file) {\n        protectEditor(originalThis);\n      }\n    }\n  });\n  patches.registerMethodPatch({\n    $object: MarkdownView.prototype,\n    methodName: 'setMode',\n    patchHandler: async ({ fallback, originalThis }) => {\n      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression -- Obsidian returns a boolean despite its void declaration; setState consumes that result.\n      const result = await fallback();\n      if (originalThis.file === file) {\n        protectEditor(originalThis);\n      }\n      return result;\n    }\n  });\n\n  const disposable = new CallbackDisposable({\n    callback: (): void => {\n      app.workspace.iterateAllLeaves((leaf) => {\n        if ('file' in leaf.view && leaf.view.file === file) {\n          leaf.detach();\n        }\n      });\n      app.metadataCache.uniqueFileLookup.remove(file.name.toLowerCase(), file);\n      if (app.vault.fileMap[path] === file) {\n        Reflect.deleteProperty(app.vault.fileMap, path);\n        metadata[Symbol.dispose]();\n      }\n      patches.unload();\n      // eslint-disable-next-line n/no-unsupported-features/node-builtins -- The URL belongs to the browser realm that created it.\n      window.URL.revokeObjectURL(url);\n      reservations.delete(path.toLowerCase());\n    },\n    multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n  });\n  return {\n    content,\n    file,\n    [Symbol.dispose]: (): void => {\n      disposable[Symbol.dispose]();\n    }\n  };\n\n  function isMatching(target: string): boolean {\n    return normalizePath(target).toLowerCase() === path.toLowerCase();\n  }\n\n  function protectEditor(view: MarkdownView): void {\n    toggleEditorReadOnly(view.editor, true);\n    // A virtual file is immutable even to programmatic editor transactions. The ordinary resource\n    // lock permits those for rollback; this registration has no writable buffer to roll back.\n    view.editor.cm.dispatch({\n      effects: StateEffect.appendConfig.of(EditorState.changeFilter.of(() => view.file !== file))\n    });\n  }\n\n  function assertWritable(target: string): void {\n    const normalized = normalizePath(target).toLowerCase();\n    if (isMatching(target) || path.toLowerCase().startsWith(`${normalized}/`) || normalized === '/') {\n      throw new Error(`Virtual file is read-only: ${path}`);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/obsidian-lib",
-  "version": "10.8.0",
+  "version": "10.9.0",
   "description": "Runtime library for Obsidian plugin development: plugin base classes, components, settings, modals, vault and metadata helpers.",
   "keywords": [
     "obsidian",
@@ -390,10 +390,10 @@
     "@commitlint/cli": "^21.2.2",
     "@commitlint/config-conventional": "^21.2.2",
     "@lezer/common": "1.5.2",
-    "@mnaoumov/obsidian-dev-toolkit": "^7.4.0",
-    "@mnaoumov/typescript-dev-toolkit": "^5.4.1",
+    "@mnaoumov/obsidian-dev-toolkit": "^8.2.1",
+    "@mnaoumov/typescript-dev-toolkit": "^6.1.0",
     "@mnaoumov/typescript-test-toolkit": "^1.0.3",
-    "@obsidian-typings/obsidian-public-latest": "^6.57.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.59.0",
     "@resvg/resvg-js": "^2.6.2",
     "@stryker-mutator/core": "^10.1.1",
     "@stryker-mutator/vitest-runner": "^10.1.1",
@@ -437,7 +437,7 @@
     "@codemirror/state": "^6.7.6",
     "@codemirror/view": "^6.43.13",
     "@lezer/common": "^1.5.2",
-    "@obsidian-typings/obsidian-public-latest": "^6.55.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.58.0",
     "obsidian": "^1.14.4",
     "obsidian-integration-testing": "^17.7.4"
   },