@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/attachment-path.d.cts

@@ -0,0 +1,341 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Provides utility functions for working with attachment paths.
+ */
+import type { App, FileStats, Vault } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PathOrFile } from './file-system.cjs';
+/**
+ * A context for an attachment path.
+ */
+export declare enum AttachmentPathContext {
+    /**
+     * A context for a delete note.
+     */
+    DeleteNote = "DeleteNote",
+    /**
+     * A context for a rename note.
+     */
+    RenameNote = "RenameNote",
+    /**
+     * An unknown context.
+     */
+    Unknown = "Unknown"
+}
+/**
+ * Options for the get available path for attachments extended function.
+ */
+export interface GetAvailablePathForAttachmentsExtendedFunctionParams {
+    /**
+     * A base name of the attachment.
+     */
+    readonly attachmentFileBaseName: string;
+    /**
+     * An extension of the attachment.
+     */
+    readonly attachmentFileExtension: string;
+    /**
+     * A stats of the attachment file.
+     */
+    readonly attachmentFileStats?: FileStats | undefined;
+    /**
+     * A context.
+     */
+    readonly context: AttachmentPathContext;
+    /**
+     * A path or file of the note.
+     */
+    readonly notePathOrFile: null | PathOrFile;
+    /**
+     * A path or file of the old attachment.
+     */
+    readonly oldAttachmentPathOrFile: PathOrFile;
+    /**
+     * A path or file of the old note.
+     */
+    readonly oldNotePathOrFile?: PathOrFile | undefined;
+    /**
+     * Lazily reads the content of the attachment file.
+     *
+     * The content is read on demand only when a consumer actually needs the bytes (e.g. a template
+     * token that embeds them). For the default templates nothing pulls the bytes, so the potentially
+     * expensive (size-proportional) `readBinary` never runs. Consumers that may call this more than
+     * once should memoize the first call. `null` when there is no attachment file to read.
+     *
+     * @returns A {@link Promise} that resolves to the content of the attachment file.
+     */
+    readonly readAttachmentFileContent: (() => Promise<ArrayBuffer>) | null;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck?: boolean;
+    /**
+     * Should the generated attachment file name be skipped.
+     */
+    readonly shouldSkipGeneratedAttachmentFileName?: boolean;
+    /**
+     * Should missing attachment folder creation be skipped.
+     */
+    readonly shouldSkipMissingAttachmentFolderCreation: boolean | undefined;
+}
+/**
+ * {@link Vault.getAvailablePathForAttachments} extended wrapper.
+ */
+export interface GetAvailablePathForAttachmentsFunctionExtended extends GetAvailablePathForAttachmentsFunction {
+    /**
+     * Whether a folder path is designated as an attachment unit — a folder that must travel whole rather
+     * than have the linked file relocated out of it.
+     *
+     * Optional: an attachment-location plugin may own the resolution without designating anything, and an
+     * absent member is the same "nobody owns this policy" answer {@link GetAvailablePathForAttachmentsFunctionExtended.extended}
+     * itself gives.
+     *
+     * @param folderPath - The vault-relative path of the folder.
+     * @returns `true` if the folder is designated as an attachment unit, `false` otherwise.
+     */
+    checkIsAttachmentUnitFolder?: (folderPath: string) => boolean;
+    /**
+     * Get available path for attachments with additional params.
+     *
+     * @param params - Parameters for the get available path for attachments.
+     * @returns A {@link Promise} that resolves to the available path for attachments.
+     */
+    extended: (params: GetAvailablePathForAttachmentsExtendedFunctionParams) => Promise<string>;
+}
+type GetAvailablePathForAttachmentsFunction = Vault['getAvailablePathForAttachments'];
+/**
+ * Dummy path.
+ */
+export declare const DUMMY_PATH = "__DUMMY__";
+/**
+ * Options for the getAttachmentFilePath function.
+ */
+export interface GetAttachmentFilePathParams {
+    /**
+     * An Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * A context.
+     */
+    readonly context: AttachmentPathContext;
+    /**
+     * A path of the note.
+     */
+    readonly notePathOrFile: PathOrFile;
+    /**
+     * A path of the attachment.
+     */
+    readonly oldAttachmentPathOrFile: PathOrFile;
+    /**
+     * A path of the old note.
+     */
+    readonly oldNotePathOrFile?: PathOrFile | undefined;
+    /**
+     * Should the duplicate check be skipped.
+     */
+    readonly shouldSkipDuplicateCheck: boolean;
+}
+/**
+ * Parameters for {@link getAttachmentFolderPath}.
+ */
+export interface GetAttachmentFolderPathParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The context.
+     *
+     * @default {@link AttachmentPathContext.Unknown}
+     */
+    readonly context?: AttachmentPathContext;
+    /**
+     * The path of the note.
+     */
+    readonly notePathOrFile: PathOrFile;
+}
+/**
+ * Parameters for {@link getAttachmentFolderPathSyncOrNull}.
+ */
+export interface GetAttachmentFolderPathSyncOrNullParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The path of the note.
+     */
+    readonly notePathOrFile: PathOrFile;
+}
+/**
+ * Options for the getAvailablePathForAttachments function.
+ */
+export interface GetAvailablePathForAttachmentsParams {
+    /**
+     * An Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * A base name of the attachment.
+     */
+    readonly attachmentFileBaseName: string;
+    /**
+     * An extension of the attachment.
+     */
+    readonly attachmentFileExtension: string;
+    /**
+     * A file to attach to.
+     */
+    readonly notePathOrFile: null | PathOrFile;
+    /**
+     * Should the duplicate check be skipped.
+     *
+     * @default `false`
+     */
+    readonly shouldSkipDuplicateCheck?: boolean;
+    /**
+     * Should missing attachment folder creation be skipped.
+     *
+     * @default `false`
+     */
+    readonly shouldSkipMissingAttachmentFolderCreation?: boolean;
+}
+/**
+ * Parameters for {@link hasOwnAttachmentFolder}.
+ */
+export interface HasOwnAttachmentFolderParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The context.
+     *
+     * @default {@link AttachmentPathContext.Unknown}
+     */
+    readonly context?: AttachmentPathContext;
+    /**
+     * The path of the note.
+     */
+    readonly path: string;
+}
+/**
+ * Parameters for {@link isAtProperAttachmentPath}.
+ */
+export interface IsAtProperAttachmentPathParams {
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The path or file of the attachment to check.
+     */
+    readonly attachmentPathOrFile: PathOrFile;
+    /**
+     * The context.
+     *
+     * @default {@link AttachmentPathContext.Unknown}
+     */
+    readonly context?: AttachmentPathContext;
+    /**
+     * The path or file of the note that references the attachment.
+     */
+    readonly notePathOrFile: PathOrFile;
+}
+/**
+ * Retrieves the file path for an attachment within a note.
+ *
+ * @param params - Parameters for the get attachment file path function.
+ * @returns A {@link Promise} that resolves to the file path of the attachment.
+ */
+export declare function getAttachmentFilePath(params: GetAttachmentFilePathParams): Promise<string>;
+/**
+ * Retrieves the attachment folder path for a given note.
+ *
+ * @param params - Parameters for the get attachment folder path function.
+ * @returns A {@link Promise} that resolves to the attachment folder path.
+ */
+export declare function getAttachmentFolderPath(params: GetAttachmentFolderPathParams): Promise<string>;
+/**
+ * Retrieves the attachment folder path for a given note **synchronously**, when that is possible at all.
+ *
+ * Obsidian builds its file/folder context menus and evaluates a command's `checkCallback` synchronously, so a
+ * caller deciding whether to merely *offer* a command cannot await {@link getAttachmentFolderPath}. This is
+ * the synchronous twin such a caller can use instead.
+ *
+ * The answer is `null` when it is not knowable synchronously — that is, when a plugin installed
+ * {@link GetAvailablePathForAttachmentsFunctionExtended.extended} and therefore owns the resolution, which is
+ * genuinely asynchronous. `null` means "ask {@link getAttachmentFolderPath}", never "there is no attachment
+ * folder". Otherwise the answer is exact rather than a guess: it is produced by the very same code
+ * {@link getAttachmentFolderPath} runs, whose only asynchronous step — creating a missing attachment folder —
+ * is unreachable on this path.
+ *
+ * There is deliberately no `context` parameter: {@link AttachmentPathContext} only ever reaches an
+ * {@link GetAvailablePathForAttachmentsFunctionExtended.extended} override, and this function answers `null`
+ * whenever one is installed.
+ *
+ * @param params - Parameters for the get attachment folder path sync or null function.
+ * @returns The attachment folder path, or `null` when it can only be resolved asynchronously.
+ */
+export declare function getAttachmentFolderPathSyncOrNull(params: GetAttachmentFolderPathSyncOrNullParams): null | string;
+/**
+ * Retrieves the available path for attachments.
+ *
+ * @param params - Parameters for the get available path for attachments function.
+ * @returns A {@link Promise} that resolves to the available path for attachments.
+ */
+export declare function getAvailablePathForAttachments(params: GetAvailablePathForAttachmentsParams): Promise<string>;
+/**
+ * Reads the attachment-unit-folder designation an attachment-location plugin published on the vault.
+ *
+ * The designation is one plugin's setting but every relocating plugin's business, so it rides the same seam
+ * that already carries that kind of answer: a member hung off the patched
+ * {@link Vault.getAvailablePathForAttachments}. Reading it here rather than consulting any one plugin's
+ * settings is the point — a folder kept whole by one plugin and torn apart by another is exactly the failure
+ * `findAttachmentUnitFolderPath` exists to prevent.
+ *
+ * `undefined` means nobody published a designation, the same "nobody owns this policy" answer the
+ * {@link GetAvailablePathForAttachmentsFunctionExtended.extended} member gives. It is distinct from a
+ * designation that answers `false` for every folder.
+ *
+ * @param app - An Obsidian application instance.
+ * @returns The designation predicate, or `undefined` when nobody published one.
+ */
+export declare function getCheckIsAttachmentUnitFolderFunction(app: App): GetAvailablePathForAttachmentsFunctionExtended['checkIsAttachmentUnitFolder'];
+/**
+ * Checks whether a note's attachment folder is specific to that note rather than shared with its siblings.
+ *
+ * The answer is derived by comparing the note's attachment folder with the one a same-folder sibling note
+ * would get: they differ only when the folder depends on the note's NAME. Every built-in
+ * `attachmentFolderPath` mode — the vault root, a fixed folder, the note's own folder (`./`), a subfolder of
+ * the note's folder (`./sub`) — is shared by every note in that folder, so it answers `false`; `true` arises
+ * from a {@link GetAvailablePathForAttachmentsFunctionExtended.extended} override that derives the folder from the
+ * note's name (what an attachment-location plugin produces).
+ *
+ * This is the distinction a caller needs before sweeping an attachment folder wholesale: only a
+ * note-specific folder can be treated as belonging to the note.
+ *
+ * @param params - Parameters for the has own attachment folder function.
+ * @returns A {@link Promise} that resolves to a boolean indicating whether the note has its own attachment folder.
+ */
+export declare function hasOwnAttachmentFolder(params: HasOwnAttachmentFolderParams): Promise<boolean>;
+/**
+ * Checks whether an attachment already sits at its proper attachment path.
+ *
+ * Returns `true` when the attachment's current path is, within its proper attachment folder, either the proper
+ * base name or the proper base name plus an Obsidian deduplication suffix (a space followed by digits, e.g.
+ * `img 1`) with the same extension. The proper path is computed via {@link getAttachmentFilePath} with
+ * {@link GetAttachmentFilePathParams.shouldSkipDuplicateCheck} set to `true` (the target before any
+ * deduplication suffix), and the comparison respects the file system case-sensitivity flag
+ * (`getDataAdapterEx(app).insensitive`) that `getSafeRenamePath` uses.
+ *
+ * This lets a caller recognize a deduplication-parked attachment as already-collected, so a "needs move?"
+ * decision made against the deduplication-free proper path converges instead of re-scheduling the file forever.
+ *
+ * @param params - Parameters for the is at proper attachment path function.
+ * @returns A {@link Promise} that resolves to `true` when the attachment is already at its proper path.
+ */
+export declare function isAtProperAttachmentPath(params: IsAtProperAttachmentPathParams): Promise<boolean>;
+export {};

package/dist/lib/cjs/attachment-unit-folder.cjs

@@ -0,0 +1,192 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var attachment_unit_folder_exports = {};
+__export(attachment_unit_folder_exports, {
+  findAttachmentUnitFolderPath: () => findAttachmentUnitFolderPath,
+  rebasePathOntoFolder: () => rebasePathOntoFolder
+});
+module.exports = __toCommonJS(attachment_unit_folder_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_attachment_path = require('./attachment-path.cjs');
+function findAttachmentUnitFolderPath(params) {
+  const parentFolderPath = (0, import_path.dirname)(params.attachmentPath);
+  if (!parentFolderPath || parentFolderPath === "." || parentFolderPath === "/") {
+    return null;
+  }
+  const checkIsAttachmentUnitFolder = "checkIsAttachmentUnitFolder" in params ? params.checkIsAttachmentUnitFolder : (0, import_attachment_path.getCheckIsAttachmentUnitFolderFunction)(params.app);
+  if (!checkIsAttachmentUnitFolder) {
+    return null;
+  }
+  const segments = parentFolderPath.split("/").filter(Boolean);
+  for (let count = 1; count <= segments.length; count++) {
+    const candidate = segments.slice(0, count).join("/");
+    if (checkIsAttachmentUnitFolder(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function rebasePathOntoFolder(params) {
+  const prefix = `${params.oldFolderPath}/`;
+  return params.path.startsWith(prefix) ? `${params.newFolderPath}/${params.path.slice(prefix.length)}` : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findAttachmentUnitFolderPath,
+  rebasePathOntoFolder
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/attachment-unit-folder.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Resolves which folder an attachment belongs to when the user has designated folders that must\n * travel as a single unit.\n *\n * Some formats are really a directory tree rather than a file: a page saved from a browser sits next\n * to a `_files/` folder holding its images and stylesheets, an `.excalidraw` sits next to the images\n * it references. Relocating only the linked file leaves the rest behind and the attachment arrives\n * broken.\n *\n * This lives in the shared library rather than in one plugin because more than one plugin relocates\n * attachments over the same vault. If they each decided separately what one attachment is, a user\n * with both installed would get a folder kept whole by one and torn apart by the other.\n *\n * Which is why the designation itself is read from the vault rather than supplied per caller: pass an\n * {@link App} and {@link findAttachmentUnitFolderPath} walks with whatever an attachment-location\n * plugin published on the patched `Vault.getAvailablePathForAttachments`, so every plugin decides from\n * one answer. The explicit-predicate form remains for a caller that genuinely owns its own patterns.\n */\n\nimport type { App } from 'obsidian';\n\nimport { dirname } from '@mnaoumov/typescript-lib/path';\n\nimport { getCheckIsAttachmentUnitFolderFunction } from './attachment-path.ts';\n\n/**\n * Parameters for {@link findAttachmentUnitFolderPath}, reading the designation published on the vault.\n */\nexport interface FindAttachmentUnitFolderPathFromAppParams {\n  /**\n   * An Obsidian application instance, whose patched `Vault.getAvailablePathForAttachments` carries the\n   * designation.\n   */\n  readonly app: App;\n\n  /**\n   * The vault-relative path of the attachment.\n   */\n  readonly attachmentPath: string;\n}\n\n/**\n * Parameters for {@link findAttachmentUnitFolderPath}.\n *\n * Prefer {@link FindAttachmentUnitFolderPathFromAppParams} \u2014 it is the form that makes every plugin\n * decide from one published answer.\n */\nexport type FindAttachmentUnitFolderPathParams = FindAttachmentUnitFolderPathFromAppParams | FindAttachmentUnitFolderPathWithPredicateParams;\n\n/**\n * Parameters for {@link findAttachmentUnitFolderPath}, walking with a predicate the caller owns.\n */\nexport interface FindAttachmentUnitFolderPathWithPredicateParams {\n  /**\n   * The vault-relative path of the attachment.\n   */\n  readonly attachmentPath: string;\n\n  /**\n   * Whether a folder path is designated as an attachment unit.\n   *\n   * @param folderPath - The vault-relative path of the folder.\n   * @returns `true` if the folder is designated as an attachment unit, `false` otherwise.\n   */\n  readonly checkIsAttachmentUnitFolder: (folderPath: string) => boolean;\n}\n\n/**\n * Parameters for {@link rebasePathOntoFolder}.\n */\nexport interface RebasePathOntoFolderParams {\n  /**\n   * The folder's new path.\n   */\n  readonly newFolderPath: string;\n\n  /**\n   * The folder's old path.\n   */\n  readonly oldFolderPath: string;\n\n  /**\n   * The path to rebase.\n   */\n  readonly path: string;\n}\n\n/**\n * Finds the folder that an attachment must travel with.\n *\n * Returns the **outermost** designated ancestor, not the nearest one. With nested designations,\n * moving the nearest would tear the outer tree in half, which is the failure the whole feature exists\n * to prevent.\n *\n * The vault root is never a unit, however the patterns are written: designating it would make every\n * relocation a no-op at best and a vault-wide move at worst.\n *\n * Passing an {@link App} walks with the designation an attachment-location plugin published on the vault;\n * when nobody published one, nothing is designated and the answer is `null`.\n *\n * @param params - The parameters for finding the attachment unit folder.\n * @returns The unit folder's path, or `null` when the attachment belongs to no unit.\n */\nexport function findAttachmentUnitFolderPath(params: FindAttachmentUnitFolderPathParams): null | string {\n  const parentFolderPath = dirname(params.attachmentPath);\n  if (!parentFolderPath || parentFolderPath === '.' || parentFolderPath === '/') {\n    return null;\n  }\n\n  const checkIsAttachmentUnitFolder = 'checkIsAttachmentUnitFolder' in params\n    ? params.checkIsAttachmentUnitFolder\n    : getCheckIsAttachmentUnitFolderFunction(params.app);\n\n  if (!checkIsAttachmentUnitFolder) {\n    return null;\n  }\n\n  const segments = parentFolderPath.split('/').filter(Boolean);\n  for (let count = 1; count <= segments.length; count++) {\n    const candidate = segments.slice(0, count).join('/');\n    if (checkIsAttachmentUnitFolder(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Rebases a path from one folder onto another.\n *\n * Used to work out where a linked attachment ends up once its whole unit folder has moved, so the\n * link can be pointed at the file's new home rather than at where the folder used to be.\n *\n * @param params - The parameters for rebasing the path.\n * @returns The rebased path, or `null` when the path does not sit inside the old folder.\n */\nexport function rebasePathOntoFolder(params: RebasePathOntoFolderParams): null | string {\n  const prefix = `${params.oldFolderPath}/`;\n  return params.path.startsWith(prefix) ? `${params.newFolderPath}/${params.path.slice(prefix.length)}` : null;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,kBAAwB;AAExB,6BAAuD;AAgFhD,SAAS,6BAA6B,QAA2D;AACtG,QAAM,uBAAmB,qBAAQ,OAAO,cAAc;AACtD,MAAI,CAAC,oBAAoB,qBAAqB,OAAO,qBAAqB,KAAK;AAC7E,WAAO;AAAA,EACT;AAEA,QAAM,8BAA8B,iCAAiC,SACjE,OAAO,kCACP,+DAAuC,OAAO,GAAG;AAErD,MAAI,CAAC,6BAA6B;AAChC,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,iBAAiB,MAAM,GAAG,EAAE,OAAO,OAAO;AAC3D,WAAS,QAAQ,GAAG,SAAS,SAAS,QAAQ,SAAS;AACrD,UAAM,YAAY,SAAS,MAAM,GAAG,KAAK,EAAE,KAAK,GAAG;AACnD,QAAI,4BAA4B,SAAS,GAAG;AAC1C,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AAWO,SAAS,qBAAqB,QAAmD;AACtF,QAAM,SAAS,GAAG,OAAO,aAAa;AACtC,SAAO,OAAO,KAAK,WAAW,MAAM,IAAI,GAAG,OAAO,aAAa,IAAI,OAAO,KAAK,MAAM,OAAO,MAAM,CAAC,KAAK;AAC1G;",
  "names": []
}


package/dist/lib/cjs/attachment-unit-folder.d.cts

@@ -0,0 +1,103 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Resolves which folder an attachment belongs to when the user has designated folders that must
+ * travel as a single unit.
+ *
+ * Some formats are really a directory tree rather than a file: a page saved from a browser sits next
+ * to a `_files/` folder holding its images and stylesheets, an `.excalidraw` sits next to the images
+ * it references. Relocating only the linked file leaves the rest behind and the attachment arrives
+ * broken.
+ *
+ * This lives in the shared library rather than in one plugin because more than one plugin relocates
+ * attachments over the same vault. If they each decided separately what one attachment is, a user
+ * with both installed would get a folder kept whole by one and torn apart by the other.
+ *
+ * Which is why the designation itself is read from the vault rather than supplied per caller: pass an
+ * {@link App} and {@link findAttachmentUnitFolderPath} walks with whatever an attachment-location
+ * plugin published on the patched `Vault.getAvailablePathForAttachments`, so every plugin decides from
+ * one answer. The explicit-predicate form remains for a caller that genuinely owns its own patterns.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Parameters for {@link findAttachmentUnitFolderPath}, reading the designation published on the vault.
+ */
+export interface FindAttachmentUnitFolderPathFromAppParams {
+    /**
+     * An Obsidian application instance, whose patched `Vault.getAvailablePathForAttachments` carries the
+     * designation.
+     */
+    readonly app: App;
+    /**
+     * The vault-relative path of the attachment.
+     */
+    readonly attachmentPath: string;
+}
+/**
+ * Parameters for {@link findAttachmentUnitFolderPath}.
+ *
+ * Prefer {@link FindAttachmentUnitFolderPathFromAppParams} — it is the form that makes every plugin
+ * decide from one published answer.
+ */
+export type FindAttachmentUnitFolderPathParams = FindAttachmentUnitFolderPathFromAppParams | FindAttachmentUnitFolderPathWithPredicateParams;
+/**
+ * Parameters for {@link findAttachmentUnitFolderPath}, walking with a predicate the caller owns.
+ */
+export interface FindAttachmentUnitFolderPathWithPredicateParams {
+    /**
+     * The vault-relative path of the attachment.
+     */
+    readonly attachmentPath: string;
+    /**
+     * Whether a folder path is designated as an attachment unit.
+     *
+     * @param folderPath - The vault-relative path of the folder.
+     * @returns `true` if the folder is designated as an attachment unit, `false` otherwise.
+     */
+    readonly checkIsAttachmentUnitFolder: (folderPath: string) => boolean;
+}
+/**
+ * Parameters for {@link rebasePathOntoFolder}.
+ */
+export interface RebasePathOntoFolderParams {
+    /**
+     * The folder's new path.
+     */
+    readonly newFolderPath: string;
+    /**
+     * The folder's old path.
+     */
+    readonly oldFolderPath: string;
+    /**
+     * The path to rebase.
+     */
+    readonly path: string;
+}
+/**
+ * Finds the folder that an attachment must travel with.
+ *
+ * Returns the **outermost** designated ancestor, not the nearest one. With nested designations,
+ * moving the nearest would tear the outer tree in half, which is the failure the whole feature exists
+ * to prevent.
+ *
+ * The vault root is never a unit, however the patterns are written: designating it would make every
+ * relocation a no-op at best and a vault-wide move at worst.
+ *
+ * Passing an {@link App} walks with the designation an attachment-location plugin published on the vault;
+ * when nobody published one, nothing is designated and the answer is `null`.
+ *
+ * @param params - The parameters for finding the attachment unit folder.
+ * @returns The unit folder's path, or `null` when the attachment belongs to no unit.
+ */
+export declare function findAttachmentUnitFolderPath(params: FindAttachmentUnitFolderPathParams): null | string;
+/**
+ * Rebases a path from one folder onto another.
+ *
+ * Used to work out where a linked attachment ends up once its whole unit folder has moved, so the
+ * link can be pointed at the file's new home rather than at where the folder used to be.
+ *
+ * @param params - The parameters for rebasing the path.
+ * @returns The rebased path, or `null` when the path does not sit inside the old folder.
+ */
+export declare function rebasePathOntoFolder(params: RebasePathOntoFolderParams): null | string;