obsidian-dev-utils 90.1.1 → 91.0.0

package/dist/lib/esm/obsidian/attachment-path.mjs

@@ -59,30 +59,28 @@ async function getAttachmentFilePath(params) {
     oldAttachmentPathOrFile,
     shouldSkipDuplicateCheck
   } = params;
+  const extendedFunction = getExtendedFunction(app);
+  if (!extendedFunction) {
+    return getAttachmentFilePathSync({
+      app,
+      notePathOrFile,
+      oldAttachmentPathOrFile,
+      shouldSkipDuplicateCheck
+    });
+  }
   const attachmentPath = getPath(app, oldAttachmentPathOrFile);
   const attachmentFileExtension = extname(attachmentPath);
   const attachmentFileBaseName = basename(attachmentPath, attachmentFileExtension);
   const attachmentFile = getFileOrNull({ app, pathOrFile: attachmentPath });
-  const extendedFunction = app.vault.getAvailablePathForAttachments.extended;
-  if (extendedFunction) {
-    return extendedFunction({
-      attachmentFileBaseName,
-      attachmentFileExtension: attachmentFileExtension.slice(1),
-      attachmentFileStats: attachmentFile?.stat,
-      context: params.context,
-      notePathOrFile,
-      oldAttachmentPathOrFile: params.oldAttachmentPathOrFile,
-      oldNotePathOrFile: params.oldNotePathOrFile,
-      readAttachmentFileContent: attachmentFile ? () => app.vault.readBinary(attachmentFile) : null,
-      shouldSkipDuplicateCheck,
-      shouldSkipMissingAttachmentFolderCreation: true
-    });
-  }
-  return await getAvailablePathForAttachments({
-    app,
+  return await extendedFunction({
     attachmentFileBaseName,
     attachmentFileExtension: attachmentFileExtension.slice(1),
+    attachmentFileStats: attachmentFile?.stat,
+    context: params.context,
     notePathOrFile,
+    oldAttachmentPathOrFile,
+    oldNotePathOrFile: params.oldNotePathOrFile,
+    readAttachmentFileContent: attachmentFile ? () => app.vault.readBinary(attachmentFile) : null,
     shouldSkipDuplicateCheck,
     shouldSkipMissingAttachmentFolderCreation: true
   });
@@ -103,42 +101,32 @@ async function getAttachmentFolderPath(params) {
     })
   );
 }
+function getAttachmentFolderPathSyncOrNull(params) {
+  const {
+    app,
+    notePathOrFile
+  } = params;
+  if (getExtendedFunction(app)) {
+    return null;
+  }
+  return parentFolderPath(getAttachmentFilePathSync({
+    app,
+    notePathOrFile,
+    oldAttachmentPathOrFile: DUMMY_PATH,
+    shouldSkipDuplicateCheck: true
+  }));
+}
 async function getAvailablePathForAttachments(params) {
   const {
     app,
-    attachmentFileExtension,
     notePathOrFile,
-    shouldSkipDuplicateCheck,
     shouldSkipMissingAttachmentFolderCreation
   } = params;
-  let attachmentFolderPath = app.vault.getConfig("attachmentFolderPath");
-  const isCurrentFolder = attachmentFolderPath === "." || attachmentFolderPath === "./";
-  const relativePath = attachmentFolderPath.startsWith("./") ? trimStart({
-    $string: attachmentFolderPath,
-    prefix: "./"
-  }) : null;
-  const noteFileOrNull = notePathOrFile === null ? null : getFile({
-    app,
-    pathOrFile: notePathOrFile,
-    shouldIncludeNonExisting: true
-  });
-  if (isCurrentFolder) {
-    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? "" : "";
-  } else if (relativePath) {
-    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? "" : "") + relativePath;
+  const attachmentFolder = resolveAttachmentFolder({ app, notePathOrFile });
+  if (!attachmentFolder.folder && attachmentFolder.relativePath && !shouldSkipMissingAttachmentFolderCreation) {
+    await app.vault.createFolder(attachmentFolder.path);
   }
-  attachmentFolderPath = normalizeString(normalizeSlashes(attachmentFolderPath));
-  const attachmentFileBaseName = normalizeString(normalizeSlashes(params.attachmentFileBaseName));
-  let folder = getFolderOrNull({ app, isCaseInsensitive: true, pathOrFolder: attachmentFolderPath });
-  if (!folder && relativePath && !shouldSkipMissingAttachmentFolderCreation) {
-    folder = await app.vault.createFolder(attachmentFolderPath);
-  }
-  folder ??= getFolder({ app, pathOrFolder: attachmentFolderPath, shouldIncludeNonExisting: true });
-  const prefix = folder.getParentPrefix();
-  return shouldSkipDuplicateCheck ? makeFileName({
-    fileBaseName: prefix + attachmentFileBaseName,
-    fileExtension: attachmentFileExtension
-  }) : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);
+  return getAvailablePathForAttachmentsSync(params);
 }
 async function hasOwnAttachmentFolder(params) {
   const {
@@ -197,6 +185,42 @@ async function isAtProperAttachmentPath(params) {
   const deduplicationSuffix = currentBaseName.slice(deduplicationPrefix.length);
   return /^\d+$/.test(deduplicationSuffix);
 }
+function getAttachmentFilePathSync(params) {
+  const {
+    app,
+    notePathOrFile,
+    oldAttachmentPathOrFile,
+    shouldSkipDuplicateCheck
+  } = params;
+  const attachmentPath = getPath(app, oldAttachmentPathOrFile);
+  const attachmentFileExtension = extname(attachmentPath);
+  return getAvailablePathForAttachmentsSync({
+    app,
+    attachmentFileBaseName: basename(attachmentPath, attachmentFileExtension),
+    attachmentFileExtension: attachmentFileExtension.slice(1),
+    notePathOrFile,
+    shouldSkipDuplicateCheck
+  });
+}
+function getAvailablePathForAttachmentsSync(params) {
+  const {
+    app,
+    attachmentFileExtension,
+    notePathOrFile,
+    shouldSkipDuplicateCheck
+  } = params;
+  const attachmentFolder = resolveAttachmentFolder({ app, notePathOrFile });
+  const attachmentFileBaseName = normalizeString(normalizeSlashes(params.attachmentFileBaseName));
+  const folder = attachmentFolder.folder ?? getFolder({ app, pathOrFolder: attachmentFolder.path, shouldIncludeNonExisting: true });
+  const prefix = folder.getParentPrefix();
+  return shouldSkipDuplicateCheck ? makeFileName({
+    fileBaseName: prefix + attachmentFileBaseName,
+    fileExtension: attachmentFileExtension
+  }) : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);
+}
+function getExtendedFunction(app) {
+  return app.vault.getAvailablePathForAttachments.extended;
+}
 function normalizeSlashes(path) {
   path = replaceAll({
     $string: path,
@@ -210,13 +234,42 @@ function normalizeSlashes(path) {
   });
   return path || "/";
 }
+function resolveAttachmentFolder(params) {
+  const {
+    app,
+    notePathOrFile
+  } = params;
+  let attachmentFolderPath = app.vault.getConfig("attachmentFolderPath");
+  const isCurrentFolder = attachmentFolderPath === "." || attachmentFolderPath === "./";
+  const relativePath = attachmentFolderPath.startsWith("./") ? trimStart({
+    $string: attachmentFolderPath,
+    prefix: "./"
+  }) : null;
+  const noteFileOrNull = notePathOrFile === null ? null : getFile({
+    app,
+    pathOrFile: notePathOrFile,
+    shouldIncludeNonExisting: true
+  });
+  if (isCurrentFolder) {
+    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? "" : "";
+  } else if (relativePath) {
+    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? "" : "") + relativePath;
+  }
+  attachmentFolderPath = normalizeString(normalizeSlashes(attachmentFolderPath));
+  return {
+    folder: getFolderOrNull({ app, isCaseInsensitive: true, pathOrFolder: attachmentFolderPath }),
+    path: attachmentFolderPath,
+    relativePath
+  };
+}
 export {
   AttachmentPathContext,
   DUMMY_PATH,
   getAttachmentFilePath,
   getAttachmentFolderPath,
+  getAttachmentFolderPathSyncOrNull,
   getAvailablePathForAttachments,
   hasOwnAttachmentFolder,
   isAtProperAttachmentPath
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/attachment-path.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Provides utility functions for working with attachment paths.\n */\n\nimport type {\n  App,\n  FileStats,\n  Vault\n} from 'obsidian';\n\nimport {\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName\n} from '../path.ts';\nimport {\n  normalizeString,\n  replaceAll,\n  trimStart\n} from '../string.ts';\nimport {\n  getFile,\n  getFileOrNull,\n  getFolder,\n  getFolderOrNull,\n  getPath,\n  MARKDOWN_FILE_EXTENSION\n} from './file-system.ts';\n\n/**\n * A context for an attachment path.\n */\nexport enum AttachmentPathContext {\n  /**\n   * A context for a delete note.\n   */\n  DeleteNote = 'DeleteNote',\n\n  /**\n   * A context for a rename note.\n   */\n  RenameNote = 'RenameNote',\n\n  /**\n   * An unknown context.\n   */\n  Unknown = 'Unknown'\n}\n\n/**\n * Options for the get available path for attachments extended function.\n */\nexport interface GetAvailablePathForAttachmentsExtendedFunctionParams {\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n\n  /**\n   * A stats of the attachment file.\n   */\n  readonly attachmentFileStats?: FileStats | undefined;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path or file of the note.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n\n  /**\n   * A path or file of the old attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path or file of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Lazily reads the content of the attachment file.\n   *\n   * The content is read on demand only when a consumer actually needs the bytes (e.g. a template\n   * token that embeds them). For the default templates nothing pulls the bytes, so the potentially\n   * expensive (size-proportional) `readBinary` never runs. Consumers that may call this more than\n   * once should memoize the first call. `null` when there is no attachment file to read.\n   *\n   * @returns A {@link Promise} that resolves to the content of the attachment file.\n   */\n  readonly readAttachmentFileContent: (() => Promise<ArrayBuffer>) | null;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n\n  /**\n   * Should the generated attachment file name be skipped.\n   */\n  readonly shouldSkipGeneratedAttachmentFileName?: boolean;\n\n  /**\n   * Should missing attachment folder creation be skipped.\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;\n}\n\n/**\n * {@link Vault.getAvailablePathForAttachments} extended wrapper.\n */\nexport interface GetAvailablePathForAttachmentsFunctionExtended extends GetAvailablePathForAttachmentsFunction {\n  /**\n   * Get available path for attachments with additional params.\n   *\n   * @param params - Parameters for the get available path for attachments.\n   * @returns A {@link Promise} that resolves to the available path for attachments.\n   */\n  extended(params: GetAvailablePathForAttachmentsExtendedFunctionParams): Promise<string>;\n}\n\ntype GetAvailablePathForAttachmentsFunction = Vault['getAvailablePathForAttachments'];\n\n/**\n * Dummy path.\n */\nexport const DUMMY_PATH = '__DUMMY__';\n\n/**\n * Options for the getAttachmentFilePath function.\n */\nexport interface GetAttachmentFilePathParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n\n  /**\n   * A path of the attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck: boolean;\n}\n\n/**\n * Parameters for {@link getAttachmentFolderPath}.\n */\nexport interface GetAttachmentFolderPathParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The context.\n   *\n   * @default {@link AttachmentPathContext.Unknown}\n   */\n  readonly context?: AttachmentPathContext;\n\n  /**\n   * The path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n}\n\n/**\n * Options for the getAvailablePathForAttachments function.\n */\nexport interface GetAvailablePathForAttachmentsParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n  /**\n   * A file to attach to.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n  /**\n   * Should the duplicate check be skipped.\n   *\n   * @default `false`\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n  /**\n   * Should missing attachment folder creation be skipped.\n   *\n   * @default `false`\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation?: boolean;\n}\n\n/**\n * Parameters for {@link hasOwnAttachmentFolder}.\n */\nexport interface HasOwnAttachmentFolderParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The context.\n   *\n   * @default {@link AttachmentPathContext.Unknown}\n   */\n  readonly context?: AttachmentPathContext;\n\n  /**\n   * The path of the note.\n   */\n  readonly path: string;\n}\n\n/**\n * Parameters for {@link isAtProperAttachmentPath}.\n */\nexport interface IsAtProperAttachmentPathParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or file of the attachment to check.\n   */\n  readonly attachmentPathOrFile: PathOrFile;\n\n  /**\n   * The context.\n   *\n   * @default {@link AttachmentPathContext.Unknown}\n   */\n  readonly context?: AttachmentPathContext;\n\n  /**\n   * The path or file of the note that references the attachment.\n   */\n  readonly notePathOrFile: PathOrFile;\n}\n\n/**\n * Retrieves the file path for an attachment within a note.\n *\n * @param params - Parameters for the get attachment file path function.\n * @returns A {@link Promise} that resolves to the file path of the attachment.\n */\nexport async function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string> {\n  const {\n    app,\n    notePathOrFile,\n    oldAttachmentPathOrFile,\n    shouldSkipDuplicateCheck\n  } = params;\n  const attachmentPath = getPath(app, oldAttachmentPathOrFile);\n  const attachmentFileExtension = extname(attachmentPath);\n  const attachmentFileBaseName = basename(attachmentPath, attachmentFileExtension);\n  const attachmentFile = getFileOrNull({ app, pathOrFile: attachmentPath });\n\n  const extendedFunction = (app.vault.getAvailablePathForAttachments as Partial<GetAvailablePathForAttachmentsFunctionExtended>).extended;\n  if (extendedFunction) {\n    return extendedFunction({\n      attachmentFileBaseName,\n      attachmentFileExtension: attachmentFileExtension.slice(1),\n      attachmentFileStats: attachmentFile?.stat,\n      context: params.context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: params.oldAttachmentPathOrFile,\n      oldNotePathOrFile: params.oldNotePathOrFile,\n      readAttachmentFileContent: attachmentFile ? (): Promise<ArrayBuffer> => app.vault.readBinary(attachmentFile) : null,\n      shouldSkipDuplicateCheck,\n      shouldSkipMissingAttachmentFolderCreation: true\n    });\n  }\n\n  return await getAvailablePathForAttachments({\n    app,\n    attachmentFileBaseName,\n    attachmentFileExtension: attachmentFileExtension.slice(1),\n    notePathOrFile,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation: true\n  });\n}\n\n/**\n * Retrieves the attachment folder path for a given note.\n *\n * @param params - Parameters for the get attachment folder path function.\n * @returns A {@link Promise} that resolves to the attachment folder path.\n */\nexport async function getAttachmentFolderPath(params: GetAttachmentFolderPathParams): Promise<string> {\n  const {\n    app,\n    context = AttachmentPathContext.Unknown,\n    notePathOrFile\n  } = params;\n  return parentFolderPath(\n    await getAttachmentFilePath({\n      app,\n      context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: DUMMY_PATH,\n      shouldSkipDuplicateCheck: true\n    })\n  );\n}\n\n/**\n * Retrieves the available path for attachments.\n *\n * @param params - Parameters for the get available path for attachments function.\n * @returns A {@link Promise} that resolves to the available path for attachments.\n */\nexport async function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string> {\n  const {\n    app,\n    attachmentFileExtension,\n    notePathOrFile,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation\n  } = params;\n  let attachmentFolderPath = app.vault.getConfig('attachmentFolderPath') as string;\n  const isCurrentFolder = attachmentFolderPath === '.' || attachmentFolderPath === './';\n  const relativePath = attachmentFolderPath.startsWith('./')\n    ? trimStart({\n      $string: attachmentFolderPath,\n      prefix: './'\n    })\n    : null;\n\n  // A note that does not exist yet (a rename target, a dummy sibling) still belongs to its own folder.\n  // Materializing it from its path keeps that folder, where a vault lookup would fall back to the root.\n  // Only an explicitly note-less attachment resolves to the vault root.\n  const noteFileOrNull = notePathOrFile === null\n    ? null\n    : getFile({\n      app,\n      pathOrFile: notePathOrFile,\n      shouldIncludeNonExisting: true\n    });\n\n  if (isCurrentFolder) {\n    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? '' : '';\n  } else if (relativePath) {\n    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? '' : '') + relativePath;\n  }\n\n  attachmentFolderPath = normalizeString(normalizeSlashes(attachmentFolderPath));\n  const attachmentFileBaseName = normalizeString(normalizeSlashes(params.attachmentFileBaseName));\n\n  let folder = getFolderOrNull({ app, isCaseInsensitive: true, pathOrFolder: attachmentFolderPath });\n\n  if (!folder && relativePath && !shouldSkipMissingAttachmentFolderCreation) {\n    folder = await app.vault.createFolder(attachmentFolderPath);\n  }\n\n  // A folder that does not exist yet still owns the attachment path.\n  // Resolving it as a non-existing folder stops the answer from collapsing to the vault root.\n  folder ??= getFolder({ app, pathOrFolder: attachmentFolderPath, shouldIncludeNonExisting: true });\n\n  const prefix = folder.getParentPrefix();\n  return shouldSkipDuplicateCheck\n    ? makeFileName({\n      fileBaseName: prefix + attachmentFileBaseName,\n      fileExtension: attachmentFileExtension\n    })\n    : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);\n}\n\n/**\n * Checks whether a note's attachment folder is specific to that note rather than shared with its siblings.\n *\n * The answer is derived by comparing the note's attachment folder with the one a same-folder sibling note\n * would get: they differ only when the folder depends on the note's NAME. Every built-in\n * `attachmentFolderPath` mode \u2014 the vault root, a fixed folder, the note's own folder (`./`), a subfolder of\n * the note's folder (`./sub`) \u2014 is shared by every note in that folder, so it answers `false`; `true` arises\n * from a {@link GetAvailablePathForAttachmentsFunctionExtended.extended} override that derives the folder from the\n * note's name (what an attachment-location plugin produces).\n *\n * This is the distinction a caller needs before sweeping an attachment folder wholesale: only a\n * note-specific folder can be treated as belonging to the note.\n *\n * @param params - Parameters for the has own attachment folder function.\n * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.\n */\nexport async function hasOwnAttachmentFolder(params: HasOwnAttachmentFolderParams): Promise<boolean> {\n  const {\n    app,\n    context = AttachmentPathContext.Unknown,\n    path\n  } = params;\n  const attachmentFolderPath = await getAttachmentFolderPath({\n    app,\n    context,\n    notePathOrFile: path\n  });\n  const dummyAttachmentFolderPath = await getAttachmentFolderPath({\n    app,\n    context,\n    notePathOrFile: join(dirname(path), `${DUMMY_PATH}.${MARKDOWN_FILE_EXTENSION}`)\n  });\n  return attachmentFolderPath !== dummyAttachmentFolderPath;\n}\n\n/**\n * Checks whether an attachment already sits at its proper attachment path.\n *\n * Returns `true` when the attachment's current path is, within its proper attachment folder, either the proper\n * base name or the proper base name plus an Obsidian deduplication suffix (a space followed by digits, e.g.\n * `img 1`) with the same extension. The proper path is computed via {@link getAttachmentFilePath} with\n * {@link GetAttachmentFilePathParams.shouldSkipDuplicateCheck} set to `true` (the target before any\n * deduplication suffix), and the comparison respects the file system case-sensitivity flag\n * (`getDataAdapterEx(app).insensitive`) that `getSafeRenamePath` uses.\n *\n * This lets a caller recognize a deduplication-parked attachment as already-collected, so a \"needs move?\"\n * decision made against the deduplication-free proper path converges instead of re-scheduling the file forever.\n *\n * @param params - Parameters for the is at proper attachment path function.\n * @returns A {@link Promise} that resolves to `true` when the attachment is already at its proper path.\n */\nexport async function isAtProperAttachmentPath(params: IsAtProperAttachmentPathParams): Promise<boolean> {\n  const {\n    app,\n    attachmentPathOrFile,\n    context = AttachmentPathContext.Unknown,\n    notePathOrFile\n  } = params;\n\n  const currentPath = getPath(app, attachmentPathOrFile);\n  const properPath = await getAttachmentFilePath({\n    app,\n    context,\n    notePathOrFile,\n    oldAttachmentPathOrFile: attachmentPathOrFile,\n    shouldSkipDuplicateCheck: true\n  });\n\n  const isInsensitive = getDataAdapterEx(app).insensitive;\n\n  function fold(value: string): string {\n    return isInsensitive ? value.toLowerCase() : value;\n  }\n\n  if (fold(dirname(currentPath)) !== fold(dirname(properPath))) {\n    return false;\n  }\n\n  const currentExtension = extname(currentPath);\n  const properExtension = extname(properPath);\n  if (fold(currentExtension) !== fold(properExtension)) {\n    return false;\n  }\n\n  const currentBaseName = basename(currentPath, currentExtension);\n  const properBaseName = basename(properPath, properExtension);\n\n  if (fold(currentBaseName) === fold(properBaseName)) {\n    return true;\n  }\n\n  const deduplicationPrefix = `${properBaseName} `;\n  if (!fold(currentBaseName).startsWith(fold(deduplicationPrefix))) {\n    return false;\n  }\n\n  const deduplicationSuffix = currentBaseName.slice(deduplicationPrefix.length);\n  return /^\\d+$/.test(deduplicationSuffix);\n}\n\n/**\n * Normalizes a path by combining multiple slashes into a single slash and removing leading and trailing slashes.\n *\n * @param path - Path to normalize.\n * @returns The normalized path.\n */\nfunction normalizeSlashes(path: string): string {\n  path = replaceAll({\n    $string: path,\n    replacer: '/',\n    searchValue: /(?:[\\\\/])+/g\n  });\n  path = replaceAll({\n    $string: path,\n    replacer: '',\n    searchValue: /^\\/+|\\/+$/g\n  });\n  return path || '/';\n}\n"],
  "mappings": "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",
  "names": ["AttachmentPathContext"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/attachment-path.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Provides utility functions for working with attachment paths.\n */\n\nimport type {\n  App,\n  FileStats,\n  TFolder,\n  Vault\n} from 'obsidian';\n\nimport {\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  makeFileName\n} from '../path.ts';\nimport {\n  normalizeString,\n  replaceAll,\n  trimStart\n} from '../string.ts';\nimport {\n  getFile,\n  getFileOrNull,\n  getFolder,\n  getFolderOrNull,\n  getPath,\n  MARKDOWN_FILE_EXTENSION\n} from './file-system.ts';\n\n/**\n * A context for an attachment path.\n */\nexport enum AttachmentPathContext {\n  /**\n   * A context for a delete note.\n   */\n  DeleteNote = 'DeleteNote',\n\n  /**\n   * A context for a rename note.\n   */\n  RenameNote = 'RenameNote',\n\n  /**\n   * An unknown context.\n   */\n  Unknown = 'Unknown'\n}\n\n/**\n * Options for the get available path for attachments extended function.\n */\nexport interface GetAvailablePathForAttachmentsExtendedFunctionParams {\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n\n  /**\n   * A stats of the attachment file.\n   */\n  readonly attachmentFileStats?: FileStats | undefined;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path or file of the note.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n\n  /**\n   * A path or file of the old attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path or file of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Lazily reads the content of the attachment file.\n   *\n   * The content is read on demand only when a consumer actually needs the bytes (e.g. a template\n   * token that embeds them). For the default templates nothing pulls the bytes, so the potentially\n   * expensive (size-proportional) `readBinary` never runs. Consumers that may call this more than\n   * once should memoize the first call. `null` when there is no attachment file to read.\n   *\n   * @returns A {@link Promise} that resolves to the content of the attachment file.\n   */\n  readonly readAttachmentFileContent: (() => Promise<ArrayBuffer>) | null;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n\n  /**\n   * Should the generated attachment file name be skipped.\n   */\n  readonly shouldSkipGeneratedAttachmentFileName?: boolean;\n\n  /**\n   * Should missing attachment folder creation be skipped.\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;\n}\n\n/**\n * {@link Vault.getAvailablePathForAttachments} extended wrapper.\n */\nexport interface GetAvailablePathForAttachmentsFunctionExtended extends GetAvailablePathForAttachmentsFunction {\n  /**\n   * Get available path for attachments with additional params.\n   *\n   * @param params - Parameters for the get available path for attachments.\n   * @returns A {@link Promise} that resolves to the available path for attachments.\n   */\n  extended(params: GetAvailablePathForAttachmentsExtendedFunctionParams): Promise<string>;\n}\n\ntype GetAvailablePathForAttachmentsFunction = Vault['getAvailablePathForAttachments'];\n\n/**\n * Dummy path.\n */\nexport const DUMMY_PATH = '__DUMMY__';\n\n/**\n * Options for the getAttachmentFilePath function.\n */\nexport interface GetAttachmentFilePathParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A context.\n   */\n  readonly context: AttachmentPathContext;\n\n  /**\n   * A path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n\n  /**\n   * A path of the attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * A path of the old note.\n   */\n  readonly oldNotePathOrFile?: PathOrFile | undefined;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck: boolean;\n}\n\n/**\n * Parameters for {@link getAttachmentFolderPath}.\n */\nexport interface GetAttachmentFolderPathParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The context.\n   *\n   * @default {@link AttachmentPathContext.Unknown}\n   */\n  readonly context?: AttachmentPathContext;\n\n  /**\n   * The path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n}\n\n/**\n * Parameters for {@link getAttachmentFolderPathSyncOrNull}.\n */\nexport interface GetAttachmentFolderPathSyncOrNullParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n}\n\n/**\n * Options for the getAvailablePathForAttachments function.\n */\nexport interface GetAvailablePathForAttachmentsParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n  /**\n   * A file to attach to.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n  /**\n   * Should the duplicate check be skipped.\n   *\n   * @default `false`\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n  /**\n   * Should missing attachment folder creation be skipped.\n   *\n   * @default `false`\n   */\n  readonly shouldSkipMissingAttachmentFolderCreation?: boolean;\n}\n\n/**\n * Parameters for {@link hasOwnAttachmentFolder}.\n */\nexport interface HasOwnAttachmentFolderParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The context.\n   *\n   * @default {@link AttachmentPathContext.Unknown}\n   */\n  readonly context?: AttachmentPathContext;\n\n  /**\n   * The path of the note.\n   */\n  readonly path: string;\n}\n\n/**\n * Parameters for {@link isAtProperAttachmentPath}.\n */\nexport interface IsAtProperAttachmentPathParams {\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The path or file of the attachment to check.\n   */\n  readonly attachmentPathOrFile: PathOrFile;\n\n  /**\n   * The context.\n   *\n   * @default {@link AttachmentPathContext.Unknown}\n   */\n  readonly context?: AttachmentPathContext;\n\n  /**\n   * The path or file of the note that references the attachment.\n   */\n  readonly notePathOrFile: PathOrFile;\n}\n\n/**\n * Parameters for {@link getAttachmentFilePathSync}.\n */\ninterface GetAttachmentFilePathSyncParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A path of the note.\n   */\n  readonly notePathOrFile: PathOrFile;\n\n  /**\n   * A path of the attachment.\n   */\n  readonly oldAttachmentPathOrFile: PathOrFile;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck: boolean;\n}\n\n/**\n * Parameters for {@link getAvailablePathForAttachmentsSync}.\n */\ninterface GetAvailablePathForAttachmentsSyncParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A base name of the attachment.\n   */\n  readonly attachmentFileBaseName: string;\n\n  /**\n   * An extension of the attachment.\n   */\n  readonly attachmentFileExtension: string;\n\n  /**\n   * A file to attach to.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n\n  /**\n   * Should the duplicate check be skipped.\n   */\n  readonly shouldSkipDuplicateCheck?: boolean;\n}\n\n/**\n * Parameters for {@link resolveAttachmentFolder}.\n */\ninterface ResolveAttachmentFolderParams {\n  /**\n   * An Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * A file to attach to.\n   */\n  readonly notePathOrFile: null | PathOrFile;\n}\n\n/**\n * The attachment folder a note resolves to, before the attachment file name is appended.\n */\ninterface ResolveAttachmentFolderResult {\n  /**\n   * The attachment folder, or `null` when it does not exist in the vault yet.\n   */\n  readonly folder: null | TFolder;\n\n  /**\n   * The normalized attachment folder path, whether or not the folder exists.\n   */\n  readonly path: string;\n\n  /**\n   * The part of the `attachmentFolderPath` setting that follows `./`, or `null` when the setting is not\n   * relative to the note. Only a relative setting may have its missing folder created.\n   */\n  readonly relativePath: null | string;\n}\n\n/**\n * Retrieves the file path for an attachment within a note.\n *\n * @param params - Parameters for the get attachment file path function.\n * @returns A {@link Promise} that resolves to the file path of the attachment.\n */\nexport async function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string> {\n  const {\n    app,\n    notePathOrFile,\n    oldAttachmentPathOrFile,\n    shouldSkipDuplicateCheck\n  } = params;\n\n  const extendedFunction = getExtendedFunction(app);\n  if (!extendedFunction) {\n    // Nobody overrides the resolution, so it is entirely synchronous.\n    // The same core answers `getAttachmentFolderPathSyncOrNull`, which is what keeps the two in step.\n    return getAttachmentFilePathSync({\n      app,\n      notePathOrFile,\n      oldAttachmentPathOrFile,\n      shouldSkipDuplicateCheck\n    });\n  }\n\n  const attachmentPath = getPath(app, oldAttachmentPathOrFile);\n  const attachmentFileExtension = extname(attachmentPath);\n  const attachmentFileBaseName = basename(attachmentPath, attachmentFileExtension);\n  const attachmentFile = getFileOrNull({ app, pathOrFile: attachmentPath });\n\n  return await extendedFunction({\n    attachmentFileBaseName,\n    attachmentFileExtension: attachmentFileExtension.slice(1),\n    attachmentFileStats: attachmentFile?.stat,\n    context: params.context,\n    notePathOrFile,\n    oldAttachmentPathOrFile,\n    oldNotePathOrFile: params.oldNotePathOrFile,\n    readAttachmentFileContent: attachmentFile ? (): Promise<ArrayBuffer> => app.vault.readBinary(attachmentFile) : null,\n    shouldSkipDuplicateCheck,\n    shouldSkipMissingAttachmentFolderCreation: true\n  });\n}\n\n/**\n * Retrieves the attachment folder path for a given note.\n *\n * @param params - Parameters for the get attachment folder path function.\n * @returns A {@link Promise} that resolves to the attachment folder path.\n */\nexport async function getAttachmentFolderPath(params: GetAttachmentFolderPathParams): Promise<string> {\n  const {\n    app,\n    context = AttachmentPathContext.Unknown,\n    notePathOrFile\n  } = params;\n  return parentFolderPath(\n    await getAttachmentFilePath({\n      app,\n      context,\n      notePathOrFile,\n      oldAttachmentPathOrFile: DUMMY_PATH,\n      shouldSkipDuplicateCheck: true\n    })\n  );\n}\n\n/**\n * Retrieves the attachment folder path for a given note **synchronously**, when that is possible at all.\n *\n * Obsidian builds its file/folder context menus and evaluates a command's `checkCallback` synchronously, so a\n * caller deciding whether to merely *offer* a command cannot await {@link getAttachmentFolderPath}. This is\n * the synchronous twin such a caller can use instead.\n *\n * The answer is `null` when it is not knowable synchronously \u2014 that is, when a plugin installed\n * {@link GetAvailablePathForAttachmentsFunctionExtended.extended} and therefore owns the resolution, which is\n * genuinely asynchronous. `null` means \"ask {@link getAttachmentFolderPath}\", never \"there is no attachment\n * folder\". Otherwise the answer is exact rather than a guess: it is produced by the very same code\n * {@link getAttachmentFolderPath} runs, whose only asynchronous step \u2014 creating a missing attachment folder \u2014\n * is unreachable on this path.\n *\n * There is deliberately no `context` parameter: {@link AttachmentPathContext} only ever reaches an\n * {@link GetAvailablePathForAttachmentsFunctionExtended.extended} override, and this function answers `null`\n * whenever one is installed.\n *\n * @param params - Parameters for the get attachment folder path sync or null function.\n * @returns The attachment folder path, or `null` when it can only be resolved asynchronously.\n */\nexport function getAttachmentFolderPathSyncOrNull(params: GetAttachmentFolderPathSyncOrNullParams): null | string {\n  const {\n    app,\n    notePathOrFile\n  } = params;\n\n  if (getExtendedFunction(app)) {\n    return null;\n  }\n\n  return parentFolderPath(getAttachmentFilePathSync({\n    app,\n    notePathOrFile,\n    oldAttachmentPathOrFile: DUMMY_PATH,\n    shouldSkipDuplicateCheck: true\n  }));\n}\n\n/**\n * Retrieves the available path for attachments.\n *\n * @param params - Parameters for the get available path for attachments function.\n * @returns A {@link Promise} that resolves to the available path for attachments.\n */\nexport async function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string> {\n  const {\n    app,\n    notePathOrFile,\n    shouldSkipMissingAttachmentFolderCreation\n  } = params;\n\n  // Materializing a missing attachment folder is the ONE genuinely asynchronous step in this function.\n  // Everything else lives in the synchronous core, which the synchronous entry points reuse verbatim.\n  const attachmentFolder = resolveAttachmentFolder({ app, notePathOrFile });\n  if (!attachmentFolder.folder && attachmentFolder.relativePath && !shouldSkipMissingAttachmentFolderCreation) {\n    await app.vault.createFolder(attachmentFolder.path);\n  }\n\n  return getAvailablePathForAttachmentsSync(params);\n}\n\n/**\n * Checks whether a note's attachment folder is specific to that note rather than shared with its siblings.\n *\n * The answer is derived by comparing the note's attachment folder with the one a same-folder sibling note\n * would get: they differ only when the folder depends on the note's NAME. Every built-in\n * `attachmentFolderPath` mode \u2014 the vault root, a fixed folder, the note's own folder (`./`), a subfolder of\n * the note's folder (`./sub`) \u2014 is shared by every note in that folder, so it answers `false`; `true` arises\n * from a {@link GetAvailablePathForAttachmentsFunctionExtended.extended} override that derives the folder from the\n * note's name (what an attachment-location plugin produces).\n *\n * This is the distinction a caller needs before sweeping an attachment folder wholesale: only a\n * note-specific folder can be treated as belonging to the note.\n *\n * @param params - Parameters for the has own attachment folder function.\n * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.\n */\nexport async function hasOwnAttachmentFolder(params: HasOwnAttachmentFolderParams): Promise<boolean> {\n  const {\n    app,\n    context = AttachmentPathContext.Unknown,\n    path\n  } = params;\n  const attachmentFolderPath = await getAttachmentFolderPath({\n    app,\n    context,\n    notePathOrFile: path\n  });\n  const dummyAttachmentFolderPath = await getAttachmentFolderPath({\n    app,\n    context,\n    notePathOrFile: join(dirname(path), `${DUMMY_PATH}.${MARKDOWN_FILE_EXTENSION}`)\n  });\n  return attachmentFolderPath !== dummyAttachmentFolderPath;\n}\n\n/**\n * Checks whether an attachment already sits at its proper attachment path.\n *\n * Returns `true` when the attachment's current path is, within its proper attachment folder, either the proper\n * base name or the proper base name plus an Obsidian deduplication suffix (a space followed by digits, e.g.\n * `img 1`) with the same extension. The proper path is computed via {@link getAttachmentFilePath} with\n * {@link GetAttachmentFilePathParams.shouldSkipDuplicateCheck} set to `true` (the target before any\n * deduplication suffix), and the comparison respects the file system case-sensitivity flag\n * (`getDataAdapterEx(app).insensitive`) that `getSafeRenamePath` uses.\n *\n * This lets a caller recognize a deduplication-parked attachment as already-collected, so a \"needs move?\"\n * decision made against the deduplication-free proper path converges instead of re-scheduling the file forever.\n *\n * @param params - Parameters for the is at proper attachment path function.\n * @returns A {@link Promise} that resolves to `true` when the attachment is already at its proper path.\n */\nexport async function isAtProperAttachmentPath(params: IsAtProperAttachmentPathParams): Promise<boolean> {\n  const {\n    app,\n    attachmentPathOrFile,\n    context = AttachmentPathContext.Unknown,\n    notePathOrFile\n  } = params;\n\n  const currentPath = getPath(app, attachmentPathOrFile);\n  const properPath = await getAttachmentFilePath({\n    app,\n    context,\n    notePathOrFile,\n    oldAttachmentPathOrFile: attachmentPathOrFile,\n    shouldSkipDuplicateCheck: true\n  });\n\n  const isInsensitive = getDataAdapterEx(app).insensitive;\n\n  function fold(value: string): string {\n    return isInsensitive ? value.toLowerCase() : value;\n  }\n\n  if (fold(dirname(currentPath)) !== fold(dirname(properPath))) {\n    return false;\n  }\n\n  const currentExtension = extname(currentPath);\n  const properExtension = extname(properPath);\n  if (fold(currentExtension) !== fold(properExtension)) {\n    return false;\n  }\n\n  const currentBaseName = basename(currentPath, currentExtension);\n  const properBaseName = basename(properPath, properExtension);\n\n  if (fold(currentBaseName) === fold(properBaseName)) {\n    return true;\n  }\n\n  const deduplicationPrefix = `${properBaseName} `;\n  if (!fold(currentBaseName).startsWith(fold(deduplicationPrefix))) {\n    return false;\n  }\n\n  const deduplicationSuffix = currentBaseName.slice(deduplicationPrefix.length);\n  return /^\\d+$/.test(deduplicationSuffix);\n}\n\n/**\n * The synchronous core of {@link getAttachmentFilePath}, reached when nobody installed\n * {@link GetAvailablePathForAttachmentsFunctionExtended.extended}.\n *\n * @param params - Parameters for the get attachment file path sync function.\n * @returns The file path of the attachment.\n */\nfunction getAttachmentFilePathSync(params: GetAttachmentFilePathSyncParams): string {\n  const {\n    app,\n    notePathOrFile,\n    oldAttachmentPathOrFile,\n    shouldSkipDuplicateCheck\n  } = params;\n  const attachmentPath = getPath(app, oldAttachmentPathOrFile);\n  const attachmentFileExtension = extname(attachmentPath);\n\n  return getAvailablePathForAttachmentsSync({\n    app,\n    attachmentFileBaseName: basename(attachmentPath, attachmentFileExtension),\n    attachmentFileExtension: attachmentFileExtension.slice(1),\n    notePathOrFile,\n    shouldSkipDuplicateCheck\n  });\n}\n\n/**\n * The synchronous core of {@link getAvailablePathForAttachments}, which cannot create a missing attachment\n * folder. Its caller creates the folder first when that is wanted.\n *\n * @param params - Parameters for the get available path for attachments sync function.\n * @returns The available path for attachments.\n */\nfunction getAvailablePathForAttachmentsSync(params: GetAvailablePathForAttachmentsSyncParams): string {\n  const {\n    app,\n    attachmentFileExtension,\n    notePathOrFile,\n    shouldSkipDuplicateCheck\n  } = params;\n  const attachmentFolder = resolveAttachmentFolder({ app, notePathOrFile });\n  const attachmentFileBaseName = normalizeString(normalizeSlashes(params.attachmentFileBaseName));\n\n  // A folder that does not exist yet still owns the attachment path.\n  // Resolving it as a non-existing folder stops the answer from collapsing to the vault root.\n  const folder = attachmentFolder.folder ?? getFolder({ app, pathOrFolder: attachmentFolder.path, shouldIncludeNonExisting: true });\n\n  const prefix = folder.getParentPrefix();\n  return shouldSkipDuplicateCheck\n    ? makeFileName({\n      fileBaseName: prefix + attachmentFileBaseName,\n      fileExtension: attachmentFileExtension\n    })\n    : app.vault.getAvailablePath(prefix + attachmentFileBaseName, attachmentFileExtension);\n}\n\n/**\n * Reads the {@link GetAvailablePathForAttachmentsFunctionExtended.extended} member an attachment-location\n * plugin installs. Its presence is the synchronous probe for \"somebody else owns the resolution\".\n *\n * @param app - An Obsidian application instance.\n * @returns The extended function, or `undefined` when nobody installed one.\n */\nfunction getExtendedFunction(app: App): GetAvailablePathForAttachmentsFunctionExtended['extended'] | undefined {\n  return (app.vault.getAvailablePathForAttachments as Partial<GetAvailablePathForAttachmentsFunctionExtended>).extended;\n}\n\n/**\n * Normalizes a path by combining multiple slashes into a single slash and removing leading and trailing slashes.\n *\n * @param path - Path to normalize.\n * @returns The normalized path.\n */\nfunction normalizeSlashes(path: string): string {\n  path = replaceAll({\n    $string: path,\n    replacer: '/',\n    searchValue: /(?:[\\\\/])+/g\n  });\n  path = replaceAll({\n    $string: path,\n    replacer: '',\n    searchValue: /^\\/+|\\/+$/g\n  });\n  return path || '/';\n}\n\n/**\n * Resolves the `attachmentFolderPath` setting against a note into a concrete attachment folder.\n *\n * @param params - Parameters for the resolve attachment folder function.\n * @returns The resolved attachment folder.\n */\nfunction resolveAttachmentFolder(params: ResolveAttachmentFolderParams): ResolveAttachmentFolderResult {\n  const {\n    app,\n    notePathOrFile\n  } = params;\n  let attachmentFolderPath = app.vault.getConfig('attachmentFolderPath') as string;\n  const isCurrentFolder = attachmentFolderPath === '.' || attachmentFolderPath === './';\n  const relativePath = attachmentFolderPath.startsWith('./')\n    ? trimStart({\n      $string: attachmentFolderPath,\n      prefix: './'\n    })\n    : null;\n\n  // A note that does not exist yet (a rename target, a dummy sibling) still belongs to its own folder.\n  // Materializing it from its path keeps that folder, where a vault lookup would fall back to the root.\n  // Only an explicitly note-less attachment resolves to the vault root.\n  const noteFileOrNull = notePathOrFile === null\n    ? null\n    : getFile({\n      app,\n      pathOrFile: notePathOrFile,\n      shouldIncludeNonExisting: true\n    });\n\n  if (isCurrentFolder) {\n    attachmentFolderPath = noteFileOrNull ? noteFileOrNull.parent?.path ?? '' : '';\n  } else if (relativePath) {\n    attachmentFolderPath = (noteFileOrNull ? noteFileOrNull.parent?.getParentPrefix() ?? '' : '') + relativePath;\n  }\n\n  attachmentFolderPath = normalizeString(normalizeSlashes(attachmentFolderPath));\n\n  return {\n    folder: getFolderOrNull({ app, isCaseInsensitive: true, pathOrFolder: attachmentFolderPath }),\n    path: attachmentFolderPath,\n    relativePath\n  };\n}\n"],
  "mappings": "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",
  "names": ["AttachmentPathContext"]
}


package/dist/lib/esm/script-utils/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.mjs

@@ -99,10 +99,8 @@ async function installAndEnableHotReload(params) {
   const vaultPath = dirname(obsidianConfigFolder);
   const transport = await getOrLaunchDevInstance(vaultPath);
   await evalInObsidian({
-    // eslint-disable-next-line unicorn/name-replacements -- `args` is declared by `obsidian-integration-testing`; renaming it here would not match the API.
-    args: { pluginName },
-    // eslint-disable-next-line no-shadow, unicorn/name-replacements -- No actual shadowing as the function is executed externally, and `fn` is declared by `obsidian-integration-testing`.
-    async fn({ app, obsidianModule, pluginName: pluginName2 }) {
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    async callback({ app, obsidianModule, pluginName: pluginName2 }) {
       const HOT_RELOAD_PLUGIN_ID = "hot-reload";
       const COMMUNITY_PLUGINS_REGISTRY_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
       const { requestUrl } = obsidianModule;
@@ -126,6 +124,7 @@ async function installAndEnableHotReload(params) {
       }
       await app.plugins.enablePluginAndSave(pluginName2);
     },
+    input: { pluginName },
     shouldSkipPreflightChecks: true,
     transport,
     vaultPath
@@ -198,4 +197,4 @@ function watchDevInstanceAndStopOnClose(transport) {
 export {
   copyToObsidianPluginsFolderPlugin
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an esbuild plugin that automatically copies the build output\n * to the Obsidian plugins folder during development. This plugin helps streamline\n * the development workflow by ensuring that the latest build is always available\n * in the correct Obsidian folder for testing and use.\n */\n\n/* v8 ignore start -- esbuild plugin that copies build output to Obsidian plugins folder; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\nimport type { PluginManifest } from 'obsidian';\nimport type { ObsidianTransport } from 'obsidian-integration-testing';\n\nimport {\n  cp,\n  mkdir\n} from 'node:fs/promises';\nimport process from 'node:process';\nimport {\n  createTransportFromOptions,\n  DesktopCdpTransport,\n  evalInObsidian\n} from 'obsidian-integration-testing';\n\nimport {\n  invokeAsyncSafely,\n  sleep\n} from '../../../async.ts';\nimport { getLibDebugger } from '../../../debug.ts';\nimport {\n  dirname,\n  join,\n  toPosixPath\n} from '../../../path.ts';\n\n/**\n * Parameters for {@link copyToObsidianPluginsFolderPlugin}.\n */\nexport interface CopyToObsidianPluginsFolderPluginParams {\n  /**\n   * The folder where the built files are located.\n   */\n  readonly distFolder: string;\n\n  /**\n   * A boolean indicating whether the build is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the Obsidian plugin.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * The subset of a CDP target descriptor read from the owned instance's `/json` endpoint.\n */\ninterface CdpTarget {\n  /**\n   * The kind of the target, e.g. `page`.\n   */\n  readonly type: string;\n}\n\n/**\n * A single entry in Obsidian's community plugins registry (`community-plugins.json`).\n */\ninterface CommunityPluginRegistryEntry {\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The `owner/name` GitHub repository the plugin is published from.\n   */\n  readonly repo: string;\n}\n\n/**\n * The subset of a GitHub release we read.\n */\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\n/**\n * Parameters for {@link installAndEnableHotReload}.\n */\ninterface InstallAndEnableHotReloadParams {\n  /**\n   * The folder of the Obsidian configuration.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the built Obsidian plugin to enable once HotReload is in place.\n   */\n  readonly pluginName: string;\n}\n\n// The `npm run dev`-owned Obsidian instance: launched on the first rebuild and reused across rebuilds.\n// Its lifetime is tied to the `npm run dev` process in BOTH directions.\n// The instance is closed when the process terminates (see `registerDevInstanceCleanup`).\n// The process stops when the instance is closed (see `watchDevInstanceAndStopOnClose`).\n/**\nModule-level mutable state, held in one object so each mutation names it explicitly.\n */\ninterface ModuleState {\n  devInstanceTransportPromise: Promise<ObsidianTransport> | undefined;\n  isDevInstanceCleanupRegistered: boolean;\n  isDevInstanceDisposed: boolean;\n}\n\nconst moduleState: ModuleState = {\n  devInstanceTransportPromise: undefined,\n  isDevInstanceCleanupRegistered: false,\n  isDevInstanceDisposed: false\n};\n\n/**\n * How often the owned Obsidian instance is probed to detect that it was closed.\n */\nconst DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS = 2000;\n\n/**\n * How many consecutive failed probes are tolerated before the owned instance is considered closed. A\n * single failure can be a transient hiccup (a busy renderer, a momentarily refused connection), so the\n * development build is only stopped once the endpoint stays unreachable.\n */\nconst DEV_INSTANCE_CLOSED_PROBE_COUNT = 3;\n/**\n * Creates an esbuild plugin that copies the build output to the Obsidian plugins folder.\n *\n * @param params - The parameters for the function.\n * @returns An esbuild `Plugin` object.\n */\nexport function copyToObsidianPluginsFolderPlugin(params: CopyToObsidianPluginsFolderPluginParams): Plugin {\n  const {\n    distFolder,\n    isProductionBuild,\n    pluginName\n  } = params;\n  let {\n    obsidianConfigFolder\n  } = params;\n  return {\n    name: 'copy-to-obsidian-plugins-folder',\n    setup(build): void {\n      build.onEnd(async () => {\n        if (isProductionBuild) {\n          return;\n        }\n\n        if (!obsidianConfigFolder) {\n          getLibDebugger('copyToObsidianPluginsFolderPlugin')(\n            'No Obsidian config folder configured. `OBSIDIAN_CONFIG_FOLDER` environment variable is not set in system or in `.env` file. The compiled plugin will not be copied into Obsidian plugins folder.'\n          );\n          return;\n        }\n\n        obsidianConfigFolder = toPosixPath(obsidianConfigFolder);\n\n        const pluginFolder = join(obsidianConfigFolder, 'plugins', pluginName);\n        await mkdir(pluginFolder, { recursive: true });\n        await cp(distFolder, pluginFolder, { recursive: true });\n\n        await installAndEnableHotReload({\n          obsidianConfigFolder,\n          pluginName\n        });\n      });\n    }\n  };\n}\n\n/**\n * Returns the `npm run dev`-owned Obsidian instance for the given vault, launching it on first use and\n * reusing it on subsequent rebuilds.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the owned {@link ObsidianTransport}.\n */\nasync function getOrLaunchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  moduleState.devInstanceTransportPromise ??= launchDevInstance(vaultPath);\n  try {\n    return await moduleState.devInstanceTransportPromise;\n  } catch (error) {\n    // Clear the cache so a later rebuild retries the launch.\n    moduleState.devInstanceTransportPromise = undefined;\n    throw error;\n  }\n}\n\n/**\n * Installs the HotReload plugin from the official community store (if not already installed), loads it\n * (if not already running), and enables the freshly-built plugin \u2014 all through the `npm run dev`-owned\n * Obsidian instance, so HotReload then auto-refreshes the deployed plugin on every rebuild.\n *\n * The install goes through Obsidian's own `installPlugin` (the community-store mechanism), and every step\n * runs against the owned instance over CDP; any failure surfaces (the dev build reports it) rather than\n * being silently swallowed.\n *\n * The first step is leaving restricted mode for real, which the owned instance has only faked so far \u2014\n * without it \"enabled\" and \"loaded\" come apart and none of the vault's plugins, HotReload included, are\n * running. See the comment on the `setEnable` call.\n *\n * The install-if-missing / enable-if-disabled logic below intentionally mirrors the public\n * `installCommunityPlugin` / `enableCommunityPlugin` helpers in `src/obsidian/community-plugins.ts`. It\n * cannot import and call them: the `fn` is serialized (`toString()`) and executed in the renderer, and\n * this build-owned Obsidian instance is bare \u2014 it has no dev-utils `lib` provider wired (that resolver is\n * registered only in the integration-test setup, whose fixture publishes the merged surface on `window`),\n * so the closure has no access to the library surface and must inline the equivalent steps.\n *\n * @param params - The {@link InstallAndEnableHotReloadParams}.\n * @returns A {@link Promise} that resolves once HotReload and the built plugin are installed and enabled.\n */\nasync function installAndEnableHotReload(params: InstallAndEnableHotReloadParams): Promise<void> {\n  const {\n    obsidianConfigFolder,\n    pluginName\n  } = params;\n  const vaultPath = dirname(obsidianConfigFolder);\n  const transport = await getOrLaunchDevInstance(vaultPath);\n  await evalInObsidian({\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is declared by `obsidian-integration-testing`; renaming it here would not match the API.\n    args: { pluginName },\n    // eslint-disable-next-line no-shadow, unicorn/name-replacements -- No actual shadowing as the function is executed externally, and `fn` is declared by `obsidian-integration-testing`.\n    async fn({ app, obsidianModule, pluginName }) {\n      const HOT_RELOAD_PLUGIN_ID = 'hot-reload';\n      const COMMUNITY_PLUGINS_REGISTRY_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json';\n      const { requestUrl } = obsidianModule;\n\n      /*\n       * Genuinely leave restricted mode before touching anything else. The owned instance boots with a\n       * fresh user-data dir, so Obsidian starts restricted and `Plugins.initialize()` returns before\n       * loading a single plugin. The harness then closes the trust modal and writes the\n       * `enable-plugin-<appId>` localStorage flag directly \u2014 deliberately, to avoid a synchronous load \u2014\n       * which leaves `isEnabled()` reporting `true` over a vault where nothing is actually running. Every\n       * `enabledPlugins` reading below (and in the mirrored `community-plugins.ts` helpers) would be\n       * answering about the vault's config file rather than this instance.\n       *\n       * `setEnable(true)` is what Obsidian's own \"Exit restricted mode\" button calls: it re-asserts the\n       * flag and loads everything in `enabledPlugins`. Unconditional on purpose \u2014 the flag is already\n       * `true`, so an `isEnabled()` guard would skip the load that is the whole point. Idempotent and\n       * effectively free once warm (`loadPlugin` returns the live instance), so re-running it on every\n       * rebuild costs nothing.\n       */\n      await app.plugins.setEnable(true);\n\n      if (!Object.hasOwn(app.plugins.manifests, HOT_RELOAD_PLUGIN_ID)) {\n        const registryResponse = await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL);\n        const registryEntries = registryResponse.json as CommunityPluginRegistryEntry[];\n        const entry = registryEntries.find((candidate) => candidate.id === HOT_RELOAD_PLUGIN_ID);\n        if (!entry) {\n          throw new Error(`Plugin '${HOT_RELOAD_PLUGIN_ID}' was not found in the Obsidian community plugins registry.`);\n        }\n\n        const latestReleaseResponse = await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`);\n        const latestRelease = latestReleaseResponse.json as GitHubRelease;\n        const version = latestRelease.tag_name;\n        const manifestResponse = await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`);\n        const manifest = manifestResponse.json as PluginManifest;\n        await app.plugins.installPlugin(entry.repo, version, manifest);\n      }\n\n      /*\n       * Ask whether HotReload is RUNNING, not whether the vault config lists it as enabled. After the\n       * `setEnable` above the two normally agree, but a HotReload that is listed and failed to load would\n       * pass an `enabledPlugins` check while leaving the dev build without auto-refresh.\n       */\n      if (!Object.hasOwn(app.plugins.plugins, HOT_RELOAD_PLUGIN_ID)) {\n        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);\n      }\n\n      await app.plugins.enablePluginAndSave(pluginName);\n    },\n    shouldSkipPreflightChecks: true,\n    transport,\n    vaultPath\n  });\n}\n\n/**\n * Probes the owned Obsidian instance's CDP endpoint to determine whether it is still running.\n *\n * A closed instance stops serving CDP altogether, so an unreachable endpoint \u2014 or one left with no page\n * targets while the app tears itself down \u2014 means the instance is gone.\n *\n * @param cdpUrl - The base CDP URL of the owned instance, e.g. `http://localhost:51888`.\n * @returns A {@link Promise} resolving to `true` while the instance is still serving a page target.\n */\nasync function isDevInstanceRunning(cdpUrl: string): Promise<boolean> {\n  try {\n    // eslint-disable-next-line no-restricted-globals -- We run this outside of Obsidian, so we don't have `requestUrl()`.\n    const response = await fetch(`${cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.some((target) => target.type === 'page');\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Launches a fresh owned Obsidian instance (isolated user-data dir) and opens the given vault.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the launched {@link ObsidianTransport}.\n */\nasync function launchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  const transport = await createTransportFromOptions();\n  try {\n    await transport.registerVault(vaultPath);\n  } catch (error) {\n    transport.disposeSync?.();\n    throw error;\n  }\n  registerDevInstanceCleanup(transport);\n  watchDevInstanceAndStopOnClose(transport);\n  return transport;\n}\n\n/**\n * Registers process-exit and signal handlers (once) that synchronously close the owned Obsidian\n * instance when the `npm run dev` process terminates.\n *\n * These handlers cover an orderly shutdown. A `SIGKILL` (or a Task Manager / IDE stop) runs no handler\n * at all, and no operating system kills the instance just for being our child \u2014 so that case is caught\n * from the other side, by the harness's parent-liveness watchdog: the instance's renderer holds a socket\n * back to this process and destroys its window when the kernel closes it. See `parent-liveness.ts` in\n * `obsidian-integration-testing` (its L33).\n *\n * @param transport - The owned transport to dispose on shutdown.\n */\nfunction registerDevInstanceCleanup(transport: ObsidianTransport): void {\n  if (moduleState.isDevInstanceCleanupRegistered) {\n    return;\n  }\n  moduleState.isDevInstanceCleanupRegistered = true;\n\n  // `exit` covers any `process.exit()`, but a default Ctrl+C terminates WITHOUT firing `exit`, so the signal handlers guarantee the owned Obsidian is killed on shutdown.\n  process.on('exit', disposeDevInstance);\n  for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM'] as const) {\n    process.once(signal, () => {\n      disposeDevInstance();\n      process.exit();\n    });\n  }\n\n  function disposeDevInstance(): void {\n    if (moduleState.isDevInstanceDisposed) {\n      return;\n    }\n    moduleState.isDevInstanceDisposed = true;\n    transport.disposeSync?.();\n  }\n}\n\n/**\n * Watches the `npm run dev`-owned Obsidian instance and stops the development build once the instance is\n * closed.\n *\n * This is the mirror image of {@link registerDevInstanceCleanup}: that one closes the instance when the\n * `npm run dev` process terminates, this one terminates the process when the user closes the instance, so\n * the two never outlive each other. A build watching an Obsidian that is no longer running has nothing\n * left to deploy to.\n *\n * Only a harness-owned instance is watched. When the transport attaches to an already-running Obsidian\n * (the user's own), that instance is not ours to be tied to and closing it leaves the build running.\n *\n * @param transport - The owned transport whose instance to watch.\n */\nfunction watchDevInstanceAndStopOnClose(transport: ObsidianTransport): void {\n  if (!(transport instanceof DesktopCdpTransport)) {\n    return;\n  }\n\n  const endpoint = transport.getOwnedInstanceEndpoint();\n  if (!endpoint) {\n    return;\n  }\n\n  const cdpUrl = `http://${endpoint.host}:${String(endpoint.port)}`;\n  invokeAsyncSafely(stopWhenDevInstanceCloses);\n\n  async function stopWhenDevInstanceCloses(): Promise<void> {\n    let consecutiveFailedProbeCount = 0;\n    while (consecutiveFailedProbeCount < DEV_INSTANCE_CLOSED_PROBE_COUNT) {\n      await sleep({ milliseconds: DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS });\n\n      // The process is already shutting down and killed the instance itself; the probes would just race the teardown.\n      if (moduleState.isDevInstanceDisposed) {\n        return;\n      }\n\n      consecutiveFailedProbeCount = await isDevInstanceRunning(cdpUrl) ? 0 : consecutiveFailedProbeCount + 1;\n    }\n\n    console.warn('The Obsidian instance owned by `npm run dev` was closed. Stopping the development build.');\n    process.exit();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["pluginName"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../../src/script-utils/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an esbuild plugin that automatically copies the build output\n * to the Obsidian plugins folder during development. This plugin helps streamline\n * the development workflow by ensuring that the latest build is always available\n * in the correct Obsidian folder for testing and use.\n */\n\n/* v8 ignore start -- esbuild plugin that copies build output to Obsidian plugins folder; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\nimport type { PluginManifest } from 'obsidian';\nimport type { ObsidianTransport } from 'obsidian-integration-testing';\n\nimport {\n  cp,\n  mkdir\n} from 'node:fs/promises';\nimport process from 'node:process';\nimport {\n  createTransportFromOptions,\n  DesktopCdpTransport,\n  evalInObsidian\n} from 'obsidian-integration-testing';\n\nimport {\n  invokeAsyncSafely,\n  sleep\n} from '../../../async.ts';\nimport { getLibDebugger } from '../../../debug.ts';\nimport {\n  dirname,\n  join,\n  toPosixPath\n} from '../../../path.ts';\n\n/**\n * Parameters for {@link copyToObsidianPluginsFolderPlugin}.\n */\nexport interface CopyToObsidianPluginsFolderPluginParams {\n  /**\n   * The folder where the built files are located.\n   */\n  readonly distFolder: string;\n\n  /**\n   * A boolean indicating whether the build is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the Obsidian plugin.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * The subset of a CDP target descriptor read from the owned instance's `/json` endpoint.\n */\ninterface CdpTarget {\n  /**\n   * The kind of the target, e.g. `page`.\n   */\n  readonly type: string;\n}\n\n/**\n * A single entry in Obsidian's community plugins registry (`community-plugins.json`).\n */\ninterface CommunityPluginRegistryEntry {\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The `owner/name` GitHub repository the plugin is published from.\n   */\n  readonly repo: string;\n}\n\n/**\n * The subset of a GitHub release we read.\n */\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\n/**\n * Parameters for {@link installAndEnableHotReload}.\n */\ninterface InstallAndEnableHotReloadParams {\n  /**\n   * The folder of the Obsidian configuration.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the built Obsidian plugin to enable once HotReload is in place.\n   */\n  readonly pluginName: string;\n}\n\n// The `npm run dev`-owned Obsidian instance: launched on the first rebuild and reused across rebuilds.\n// Its lifetime is tied to the `npm run dev` process in BOTH directions.\n// The instance is closed when the process terminates (see `registerDevInstanceCleanup`).\n// The process stops when the instance is closed (see `watchDevInstanceAndStopOnClose`).\n/**\nModule-level mutable state, held in one object so each mutation names it explicitly.\n */\ninterface ModuleState {\n  devInstanceTransportPromise: Promise<ObsidianTransport> | undefined;\n  isDevInstanceCleanupRegistered: boolean;\n  isDevInstanceDisposed: boolean;\n}\n\nconst moduleState: ModuleState = {\n  devInstanceTransportPromise: undefined,\n  isDevInstanceCleanupRegistered: false,\n  isDevInstanceDisposed: false\n};\n\n/**\n * How often the owned Obsidian instance is probed to detect that it was closed.\n */\nconst DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS = 2000;\n\n/**\n * How many consecutive failed probes are tolerated before the owned instance is considered closed. A\n * single failure can be a transient hiccup (a busy renderer, a momentarily refused connection), so the\n * development build is only stopped once the endpoint stays unreachable.\n */\nconst DEV_INSTANCE_CLOSED_PROBE_COUNT = 3;\n/**\n * Creates an esbuild plugin that copies the build output to the Obsidian plugins folder.\n *\n * @param params - The parameters for the function.\n * @returns An esbuild `Plugin` object.\n */\nexport function copyToObsidianPluginsFolderPlugin(params: CopyToObsidianPluginsFolderPluginParams): Plugin {\n  const {\n    distFolder,\n    isProductionBuild,\n    pluginName\n  } = params;\n  let {\n    obsidianConfigFolder\n  } = params;\n  return {\n    name: 'copy-to-obsidian-plugins-folder',\n    setup(build): void {\n      build.onEnd(async () => {\n        if (isProductionBuild) {\n          return;\n        }\n\n        if (!obsidianConfigFolder) {\n          getLibDebugger('copyToObsidianPluginsFolderPlugin')(\n            'No Obsidian config folder configured. `OBSIDIAN_CONFIG_FOLDER` environment variable is not set in system or in `.env` file. The compiled plugin will not be copied into Obsidian plugins folder.'\n          );\n          return;\n        }\n\n        obsidianConfigFolder = toPosixPath(obsidianConfigFolder);\n\n        const pluginFolder = join(obsidianConfigFolder, 'plugins', pluginName);\n        await mkdir(pluginFolder, { recursive: true });\n        await cp(distFolder, pluginFolder, { recursive: true });\n\n        await installAndEnableHotReload({\n          obsidianConfigFolder,\n          pluginName\n        });\n      });\n    }\n  };\n}\n\n/**\n * Returns the `npm run dev`-owned Obsidian instance for the given vault, launching it on first use and\n * reusing it on subsequent rebuilds.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the owned {@link ObsidianTransport}.\n */\nasync function getOrLaunchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  moduleState.devInstanceTransportPromise ??= launchDevInstance(vaultPath);\n  try {\n    return await moduleState.devInstanceTransportPromise;\n  } catch (error) {\n    // Clear the cache so a later rebuild retries the launch.\n    moduleState.devInstanceTransportPromise = undefined;\n    throw error;\n  }\n}\n\n/**\n * Installs the HotReload plugin from the official community store (if not already installed), loads it\n * (if not already running), and enables the freshly-built plugin \u2014 all through the `npm run dev`-owned\n * Obsidian instance, so HotReload then auto-refreshes the deployed plugin on every rebuild.\n *\n * The install goes through Obsidian's own `installPlugin` (the community-store mechanism), and every step\n * runs against the owned instance over CDP; any failure surfaces (the dev build reports it) rather than\n * being silently swallowed.\n *\n * The first step is leaving restricted mode for real, which the owned instance has only faked so far \u2014\n * without it \"enabled\" and \"loaded\" come apart and none of the vault's plugins, HotReload included, are\n * running. See the comment on the `setEnable` call.\n *\n * The install-if-missing / enable-if-disabled logic below intentionally mirrors the public\n * `installCommunityPlugin` / `enableCommunityPlugin` helpers in `src/obsidian/community-plugins.ts`. It\n * cannot import and call them: the `fn` is serialized (`toString()`) and executed in the renderer, and\n * this build-owned Obsidian instance is bare \u2014 it has no dev-utils `lib` provider wired (that resolver is\n * registered only in the integration-test setup, whose fixture publishes the merged surface on `window`),\n * so the closure has no access to the library surface and must inline the equivalent steps.\n *\n * @param params - The {@link InstallAndEnableHotReloadParams}.\n * @returns A {@link Promise} that resolves once HotReload and the built plugin are installed and enabled.\n */\nasync function installAndEnableHotReload(params: InstallAndEnableHotReloadParams): Promise<void> {\n  const {\n    obsidianConfigFolder,\n    pluginName\n  } = params;\n  const vaultPath = dirname(obsidianConfigFolder);\n  const transport = await getOrLaunchDevInstance(vaultPath);\n  await evalInObsidian({\n    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.\n    async callback({ app, obsidianModule, pluginName }) {\n      const HOT_RELOAD_PLUGIN_ID = 'hot-reload';\n      const COMMUNITY_PLUGINS_REGISTRY_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json';\n      const { requestUrl } = obsidianModule;\n\n      /*\n       * Genuinely leave restricted mode before touching anything else. The owned instance boots with a\n       * fresh user-data dir, so Obsidian starts restricted and `Plugins.initialize()` returns before\n       * loading a single plugin. The harness then closes the trust modal and writes the\n       * `enable-plugin-<appId>` localStorage flag directly \u2014 deliberately, to avoid a synchronous load \u2014\n       * which leaves `isEnabled()` reporting `true` over a vault where nothing is actually running. Every\n       * `enabledPlugins` reading below (and in the mirrored `community-plugins.ts` helpers) would be\n       * answering about the vault's config file rather than this instance.\n       *\n       * `setEnable(true)` is what Obsidian's own \"Exit restricted mode\" button calls: it re-asserts the\n       * flag and loads everything in `enabledPlugins`. Unconditional on purpose \u2014 the flag is already\n       * `true`, so an `isEnabled()` guard would skip the load that is the whole point. Idempotent and\n       * effectively free once warm (`loadPlugin` returns the live instance), so re-running it on every\n       * rebuild costs nothing.\n       */\n      await app.plugins.setEnable(true);\n\n      if (!Object.hasOwn(app.plugins.manifests, HOT_RELOAD_PLUGIN_ID)) {\n        const registryResponse = await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL);\n        const registryEntries = registryResponse.json as CommunityPluginRegistryEntry[];\n        const entry = registryEntries.find((candidate) => candidate.id === HOT_RELOAD_PLUGIN_ID);\n        if (!entry) {\n          throw new Error(`Plugin '${HOT_RELOAD_PLUGIN_ID}' was not found in the Obsidian community plugins registry.`);\n        }\n\n        const latestReleaseResponse = await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`);\n        const latestRelease = latestReleaseResponse.json as GitHubRelease;\n        const version = latestRelease.tag_name;\n        const manifestResponse = await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`);\n        const manifest = manifestResponse.json as PluginManifest;\n        await app.plugins.installPlugin(entry.repo, version, manifest);\n      }\n\n      /*\n       * Ask whether HotReload is RUNNING, not whether the vault config lists it as enabled. After the\n       * `setEnable` above the two normally agree, but a HotReload that is listed and failed to load would\n       * pass an `enabledPlugins` check while leaving the dev build without auto-refresh.\n       */\n      if (!Object.hasOwn(app.plugins.plugins, HOT_RELOAD_PLUGIN_ID)) {\n        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);\n      }\n\n      await app.plugins.enablePluginAndSave(pluginName);\n    },\n    input: { pluginName },\n    shouldSkipPreflightChecks: true,\n    transport,\n    vaultPath\n  });\n}\n\n/**\n * Probes the owned Obsidian instance's CDP endpoint to determine whether it is still running.\n *\n * A closed instance stops serving CDP altogether, so an unreachable endpoint \u2014 or one left with no page\n * targets while the app tears itself down \u2014 means the instance is gone.\n *\n * @param cdpUrl - The base CDP URL of the owned instance, e.g. `http://localhost:51888`.\n * @returns A {@link Promise} resolving to `true` while the instance is still serving a page target.\n */\nasync function isDevInstanceRunning(cdpUrl: string): Promise<boolean> {\n  try {\n    // eslint-disable-next-line no-restricted-globals -- We run this outside of Obsidian, so we don't have `requestUrl()`.\n    const response = await fetch(`${cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.some((target) => target.type === 'page');\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Launches a fresh owned Obsidian instance (isolated user-data dir) and opens the given vault.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the launched {@link ObsidianTransport}.\n */\nasync function launchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  const transport = await createTransportFromOptions();\n  try {\n    await transport.registerVault(vaultPath);\n  } catch (error) {\n    transport.disposeSync?.();\n    throw error;\n  }\n  registerDevInstanceCleanup(transport);\n  watchDevInstanceAndStopOnClose(transport);\n  return transport;\n}\n\n/**\n * Registers process-exit and signal handlers (once) that synchronously close the owned Obsidian\n * instance when the `npm run dev` process terminates.\n *\n * These handlers cover an orderly shutdown. A `SIGKILL` (or a Task Manager / IDE stop) runs no handler\n * at all, and no operating system kills the instance just for being our child \u2014 so that case is caught\n * from the other side, by the harness's parent-liveness watchdog: the instance's renderer holds a socket\n * back to this process and destroys its window when the kernel closes it. See `parent-liveness.ts` in\n * `obsidian-integration-testing` (its L33).\n *\n * @param transport - The owned transport to dispose on shutdown.\n */\nfunction registerDevInstanceCleanup(transport: ObsidianTransport): void {\n  if (moduleState.isDevInstanceCleanupRegistered) {\n    return;\n  }\n  moduleState.isDevInstanceCleanupRegistered = true;\n\n  // `exit` covers any `process.exit()`, but a default Ctrl+C terminates WITHOUT firing `exit`, so the signal handlers guarantee the owned Obsidian is killed on shutdown.\n  process.on('exit', disposeDevInstance);\n  for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM'] as const) {\n    process.once(signal, () => {\n      disposeDevInstance();\n      process.exit();\n    });\n  }\n\n  function disposeDevInstance(): void {\n    if (moduleState.isDevInstanceDisposed) {\n      return;\n    }\n    moduleState.isDevInstanceDisposed = true;\n    transport.disposeSync?.();\n  }\n}\n\n/**\n * Watches the `npm run dev`-owned Obsidian instance and stops the development build once the instance is\n * closed.\n *\n * This is the mirror image of {@link registerDevInstanceCleanup}: that one closes the instance when the\n * `npm run dev` process terminates, this one terminates the process when the user closes the instance, so\n * the two never outlive each other. A build watching an Obsidian that is no longer running has nothing\n * left to deploy to.\n *\n * Only a harness-owned instance is watched. When the transport attaches to an already-running Obsidian\n * (the user's own), that instance is not ours to be tied to and closing it leaves the build running.\n *\n * @param transport - The owned transport whose instance to watch.\n */\nfunction watchDevInstanceAndStopOnClose(transport: ObsidianTransport): void {\n  if (!(transport instanceof DesktopCdpTransport)) {\n    return;\n  }\n\n  const endpoint = transport.getOwnedInstanceEndpoint();\n  if (!endpoint) {\n    return;\n  }\n\n  const cdpUrl = `http://${endpoint.host}:${String(endpoint.port)}`;\n  invokeAsyncSafely(stopWhenDevInstanceCloses);\n\n  async function stopWhenDevInstanceCloses(): Promise<void> {\n    let consecutiveFailedProbeCount = 0;\n    while (consecutiveFailedProbeCount < DEV_INSTANCE_CLOSED_PROBE_COUNT) {\n      await sleep({ milliseconds: DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS });\n\n      // The process is already shutting down and killed the instance itself; the probes would just race the teardown.\n      if (moduleState.isDevInstanceDisposed) {\n        return;\n      }\n\n      consecutiveFailedProbeCount = await isDevInstanceRunning(cdpUrl) ? 0 : consecutiveFailedProbeCount + 1;\n    }\n\n    console.warn('The Obsidian instance owned by `npm run dev` was closed. Stopping the development build.');\n    process.exit();\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["pluginName"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "90.1.1",
+  "version": "91.0.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development.",
   "keywords": [
     "obsidian"
@@ -675,7 +675,7 @@
     "eslint-plugin-json-schema-validator": "^6.3.1",
     "eslint-plugin-n": "$eslint-plugin-n",
     "glob": "^13.0.6",
-    "js-yaml": "4.3.0",
+    "js-yaml": "4.3.1",
     "markdown-it": "^15.0.0",
     "readdir-glob": "^3.0.0",
     "test-exclude": "^8.0.0",
@@ -688,13 +688,13 @@
     "@eslint/config-helpers": "^0.7.0",
     "@eslint/js": "^10.0.1",
     "@lezer/common": "1.5.2",
-    "@obsidian-typings/obsidian-public-latest": "^6.29.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.30.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@tsconfig/strictest": "^2.0.8",
     "@types/babel__core": "^7.20.5",
     "@types/eslint": "^9.6.1",
-    "@types/luxon": "^3.7.3",
-    "@types/node": "^26.1.2",
+    "@types/luxon": "^3.7.4",
+    "@types/node": "^26.2.0",
     "@types/parsimmon": "^1.10.9",
     "@types/path-browserify": "^1.0.3",
     "@types/pug": "^2.0.10",
@@ -710,10 +710,10 @@
     "esbuild": "^0.28.1",
     "esbuild-sass-plugin": "^3.7.0",
     "esbuild-svelte": "^0.9.5",
-    "eslint": "^10.8.0",
+    "eslint": "^10.8.1",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import-x": "^4.17.1",
-    "eslint-plugin-jsdoc": "^63.3.3",
+    "eslint-plugin-jsdoc": "^64.0.1",
     "eslint-plugin-obsidianmd": "^0.4.1",
     "eslint-plugin-perfectionist": "^5.10.1",
     "eslint-plugin-tsdoc": "^0.5.2",
@@ -727,7 +727,7 @@
     "monkey-around": "^3.0.0",
     "obsidian": "^1.13.1",
     "path-browserify": "^1.0.1",
-    "postcss": "^8.5.25",
+    "postcss": "^8.5.26",
     "postcss-modules": "^9.0.1",
     "preact": "^10.29.8",
     "react": "^19.2.8",
@@ -736,7 +736,7 @@
     "remark-wiki-link": "^2.0.1",
     "sass": "^1.102.0",
     "semver": "^7.8.5",
-    "svelte-check": "^4.7.4",
+    "svelte-check": "^4.7.5",
     "svelte-preprocess": "^6.0.5",
     "type-fest": "^5.8.0",
     "typescript": "6.0.3",
@@ -744,7 +744,7 @@
   },
   "devDependencies": {
     "@astrojs/markdown-remark": "^7.2.2",
-    "@astrojs/starlight": "^0.41.6",
+    "@astrojs/starlight": "^0.41.7",
     "@commitlint/cli": "^21.2.1",
     "@commitlint/config-conventional": "^21.2.0",
     "@commitlint/types": "^21.2.0",
@@ -754,7 +754,7 @@
     "@types/adm-zip": "^0.5.8",
     "@typescript-eslint/rule-tester": "^8.66.0",
     "@vitest/coverage-v8": "^4.1.10",
-    "astro": "^7.1.6",
+    "astro": "^7.2.0",
     "better-typescript-lib": "^2.12.0",
     "brace-expansion-upstream": "npm:brace-expansion@^5.0.9",
     "czg": "^1.13.1",
@@ -765,8 +765,8 @@
     "jsdom": "^30.0.1",
     "moment": "^2.30.1",
     "nano-staged": "^1.0.2",
-    "obsidian-integration-testing": "^9.2.1",
-    "obsidian-test-mocks": "^3.11.0",
+    "obsidian-integration-testing": "^10.0.0",
+    "obsidian-test-mocks": "^4.0.0",
     "satori": "^0.29.0",
     "starlight-github-alerts": "^0.4.0",
     "ts-declaration-location": "^1.0.7",
@@ -777,7 +777,7 @@
     "yaml": "^2.9.0"
   },
   "peerDependencies": {
-    "obsidian-integration-testing": "^9.1.1"
+    "obsidian-integration-testing": "^10.0.0"
   },
   "peerDependenciesMeta": {
     "obsidian-integration-testing": {