obsidian-dev-utils 98.0.0 → 100.0.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 100.0.0
+
+- feat(attachment-unit-folder)!: own the designation, not just the walker
+
+## 99.0.0
+
+- fix(plugin-suggestion)!: decide the notice after the host settings load
+- fix(vault): complete the operation when there is nothing to write
+- feat(validation): own the Windows reserved-name and trailing-character rules
+- feat(link): scope link editing to an offset range
+- fix(package-manager): collect every signal before picking the manager
+- fix(script-utils): route the remaining npm run hops through the detected package manager
+
 ## 98.0.0
 
 - feat(deps)!: require obsidian-integration-testing ^12 as a peer, so OIT 11 no longer resolves

package/dist/integration-test-plugin/main.js

@@ -10574,6 +10574,7 @@ __export(merged_exports, {
   getCacheSafe: () => getCacheSafe,
   getCanvasReferences: () => getCanvasReferences,
   getCaseInsensitiveFileIndex: () => getCaseInsensitiveFileIndex,
+  getCheckIsAttachmentUnitFolderFunction: () => getCheckIsAttachmentUnitFolderFunction,
   getCodeBlockMarkdownInfo: () => getCodeBlockMarkdownInfo,
   getCommunityPluginRepo: () => getCommunityPluginRepo,
   getDebugController: () => getDebugController,
@@ -10639,6 +10640,7 @@ __export(merged_exports, {
   hasPatchToken: () => hasPatchToken,
   hasSingleOccurrence: () => hasSingleOccurrence,
   hasWikilinkSyntax: () => hasWikilinkSyntax,
+  hasWindowsTrailingChars: () => hasWindowsTrailingChars,
   hoverElement: () => hoverElement3,
   ignoreError: () => ignoreError,
   indent: () => indent,
@@ -10693,6 +10695,7 @@ __export(merged_exports, {
   isNote: () => isNote,
   isParseLinkFrontmatterReference: () => isParseLinkFrontmatterReference,
   isParseLinkReference: () => isParseLinkReference,
+  isReferenceInOffsetRange: () => isReferenceInOffsetRange,
   isResourceLockedForPath: () => isResourceLockedForPath,
   isResourceLockedForPathByAncestor: () => isResourceLockedForPathByAncestor,
   isSpellcheckEnabled: () => isSpellcheckEnabled,
@@ -10700,6 +10703,7 @@ __export(merged_exports, {
   isUrl: () => isUrl,
   isValidRegExp: () => isValidRegExp,
   isValidationMessageHolder: () => isValidationMessageHolder,
+  isWindowsReservedName: () => isWindowsReservedName,
   join: () => join,
   listSafe: () => listSafe,
   lockResourceForPath: () => lockResourceForPath,
@@ -10844,6 +10848,7 @@ __export(merged_exports, {
   trimEnd: () => trimEnd,
   trimMarkdownExtension: () => trimMarkdownExtension,
   trimStart: () => trimStart,
+  trimWindowsTrailingChars: () => trimWindowsTrailingChars,
   typeIntoEditor: () => typeIntoEditor3,
   unescape: () => unescape,
   unescapeAlias: () => unescapeAlias,
@@ -11560,6 +11565,7 @@ __export(attachment_path_exports, {
   getAttachmentFolderPath: () => getAttachmentFolderPath,
   getAttachmentFolderPathSyncOrNull: () => getAttachmentFolderPathSyncOrNull,
   getAvailablePathForAttachments: () => getAvailablePathForAttachments,
+  getCheckIsAttachmentUnitFolderFunction: () => getCheckIsAttachmentUnitFolderFunction,
   hasOwnAttachmentFolder: () => hasOwnAttachmentFolder,
   isAtProperAttachmentPath: () => isAtProperAttachmentPath
 });
@@ -12572,6 +12578,9 @@ async function getAvailablePathForAttachments(params) {
   }
   return getAvailablePathForAttachmentsSync(params);
 }
+function getCheckIsAttachmentUnitFolderFunction(app) {
+  return app.vault.getAvailablePathForAttachments.checkIsAttachmentUnitFolder;
+}
 async function hasOwnAttachmentFolder(params) {
   const {
     app,
@@ -12719,10 +12728,14 @@ function findAttachmentUnitFolderPath(params) {
   if (!parentFolderPath2 || parentFolderPath2 === "." || parentFolderPath2 === "/") {
     return null;
   }
+  const checkIsAttachmentUnitFolder = "checkIsAttachmentUnitFolder" in params ? params.checkIsAttachmentUnitFolder : getCheckIsAttachmentUnitFolderFunction(params.app);
+  if (!checkIsAttachmentUnitFolder) {
+    return null;
+  }
   const segments = parentFolderPath2.split("/").filter(Boolean);
   for (let count = 1; count <= segments.length; count++) {
     const candidate = segments.slice(0, count).join("/");
-    if (params.checkIsAttachmentUnitFolder(candidate)) {
+    if (checkIsAttachmentUnitFolder(candidate)) {
       return candidate;
     }
   }
@@ -13286,6 +13299,7 @@ __export(link_exports, {
 });
 var import_obsidian102 = require("obsidian");
 init_abort_controller();
+init_debug();
 init_object_utils();
 init_obsidian_dev_utils_state();
 init_path();
@@ -13497,6 +13511,7 @@ __export(reference_exports, {
   isCanvasFileNodeReference: () => isCanvasFileNodeReference,
   isCanvasReference: () => isCanvasReference,
   isCanvasTextNodeReference: () => isCanvasTextNodeReference,
+  isReferenceInOffsetRange: () => isReferenceInOffsetRange,
   referenceToFileChange: () => referenceToFileChange,
   sortReferences: () => sortReferences
 });
@@ -13509,6 +13524,12 @@ function isCanvasReference(reference) {
 function isCanvasTextNodeReference(reference) {
   return isCanvasReference(reference) && reference.type === "text";
 }
+function isReferenceInOffsetRange(reference, offsetRange) {
+  if (!isReferenceCache(reference)) {
+    return false;
+  }
+  return offsetRange.startOffset <= reference.position.start.offset && reference.position.end.offset <= offsetRange.endOffset;
+}
 function referenceToFileChange(reference, newContent) {
   if (isFrontmatterLinkCacheWithOffsets(reference)) {
     return {
@@ -13887,6 +13908,9 @@ async function process2(params) {
         if (newContent === null) {
           return false;
         }
+        if (newContent === oldContent) {
+          return true;
+        }
         let isSuccess = true;
         const result = await invokeFileActionSafe({
           app,
@@ -14123,7 +14147,7 @@ async function applyCanvasChanges(params) {
   const canvasData = parseJsonSafe(content3);
   if (!Array.isArray(canvasData.nodes) || !Array.isArray(canvasData.edges)) {
     getLibDebugger("FileChange:applyCanvasChanges")("Not a valid canvas; skipping rewrite", { path });
-    return null;
+    return content3;
   }
   const canvasTextChanges = /* @__PURE__ */ new Map();
   for (const change of changes) {
@@ -14142,7 +14166,7 @@ async function applyCanvasChanges(params) {
         nodeIndex: change.reference.nodeIndex,
         path
       });
-      return null;
+      return content3;
     }
     if (isCanvasFileNodeChange(change)) {
       if (node2.file !== change.oldContent) {
@@ -14153,7 +14177,7 @@ async function applyCanvasChanges(params) {
           path,
           type: "file"
         });
-        return null;
+        return content3;
       }
       node2.file = change.newContent;
     } else if (isCanvasTextNodeChange(change)) {
@@ -14173,7 +14197,7 @@ async function applyCanvasChanges(params) {
         nodeIndex,
         path
       });
-      return null;
+      return content3;
     }
     if (typeof node2.text !== "string") {
       const message = "Node text is not a string";
@@ -14181,7 +14205,7 @@ async function applyCanvasChanges(params) {
         nodeIndex,
         path
       });
-      return null;
+      return content3;
     }
     const contentChanges = canvasTextChangesForNode.map((change) => {
       const newContent = change.reference.originalReference.original.includes(ESCAPED_WIKILINK_DIVIDER) ? change.newContent.replaceAll(UNESCAPED_WIKILINK_DIVIDER_REGEXP, () => ESCAPED_WIKILINK_DIVIDER) : change.newContent;
@@ -25309,12 +25333,16 @@ async function editLinks(params) {
   const {
     app,
     linkConverter,
+    offsetRange,
     pathOrFile,
     shouldEditExternalLinks = false,
     shouldEditFrontmatterExternalLinks = false,
     shouldEditMultiValueFrontmatterExternalLinks = false,
     ...options
   } = params;
+  if (offsetRange !== void 0) {
+    validateOffsetRange(offsetRange);
+  }
   await applyFileChanges({
     app,
     changesProvider: async ({ abortSignal, content: content3 }) => {
@@ -25330,25 +25358,29 @@ async function editLinks(params) {
       if (content3 !== cachedContent) {
         return null;
       }
-      return await getFileChanges({
+      return await getFileChanges(normalizeOptionalProperties({
         abortSignal,
         cache,
         isCanvasFileCache: isCanvasFile(pathOrFile),
         linkConverter,
+        offsetRange,
         shouldIncludeExternalLinks: shouldEditExternalLinks,
         shouldIncludeFrontmatterExternalLinks: shouldEditFrontmatterExternalLinks,
         shouldIncludeMultiValueFrontmatterExternalLinks: shouldEditMultiValueFrontmatterExternalLinks
-      });
+      }));
     },
     pathOrFile,
     ...options
   });
 }
 async function editLinksInContent(params) {
-  const { app, content: content3, linkConverter, shouldEditExternalLinks = false, shouldEditFrontmatterExternalLinks = false, shouldEditMultiValueFrontmatterExternalLinks = false } = params;
+  const { app, content: content3, linkConverter, offsetRange, shouldEditExternalLinks = false, shouldEditFrontmatterExternalLinks = false, shouldEditMultiValueFrontmatterExternalLinks = false } = params;
   let { abortSignal } = params;
   abortSignal ??= abortSignalNever();
   abortSignal.throwIfAborted();
+  if (offsetRange !== void 0) {
+    validateOffsetRange(offsetRange);
+  }
   const newContent = await applyContentChanges({
     abortSignal,
     changesProvider: async () => {
@@ -25358,15 +25390,16 @@ async function editLinksInContent(params) {
         shouldParseMultiValueFrontmatterExternalLinks: shouldEditMultiValueFrontmatterExternalLinks
       });
       abortSignal.throwIfAborted();
-      const changes = await getFileChanges({
+      const changes = await getFileChanges(normalizeOptionalProperties({
         abortSignal,
         cache,
         isCanvasFileCache: false,
         linkConverter,
+        offsetRange,
         shouldIncludeExternalLinks: shouldEditExternalLinks,
         shouldIncludeFrontmatterExternalLinks: shouldEditFrontmatterExternalLinks,
         shouldIncludeMultiValueFrontmatterExternalLinks: shouldEditMultiValueFrontmatterExternalLinks
-      });
+      }));
       abortSignal.throwIfAborted();
       return changes;
     },
@@ -25811,6 +25844,7 @@ async function getFileChanges(params) {
     cache,
     isCanvasFileCache,
     linkConverter,
+    offsetRange,
     shouldIncludeExternalLinks = false,
     shouldIncludeFrontmatterExternalLinks = false,
     shouldIncludeMultiValueFrontmatterExternalLinks = false
@@ -25826,8 +25860,16 @@ async function getFileChanges(params) {
     end: section.position.end.offset,
     start: section.position.start.offset
   }));
+  const getFileChangesDebugger = getLibDebugger("Link:getFileChanges");
   for (const link2 of getLinks({ cache, shouldIncludeExternalLinks, shouldIncludeFrontmatterExternalLinks, shouldIncludeMultiValueFrontmatterExternalLinks })) {
     abortSignal.throwIfAborted();
+    if (offsetRange !== void 0 && !isReferenceInOffsetRange(link2, offsetRange)) {
+      getFileChangesDebugger(
+        isReferenceCache(link2) ? "Skipping a link that is not fully contained in the offset range" : "Skipping a link that carries no position within the content, so it can never be in the offset range",
+        { link: link2.original, offsetRange }
+      );
+      continue;
+    }
     const newContent = await linkConverter(link2, abortSignal);
     abortSignal.throwIfAborted();
     if (newContent === void 0) {
@@ -25954,6 +25996,14 @@ function shouldUseWikilinkStyle(params) {
     }
   }
 }
+function validateOffsetRange(offsetRange) {
+  if (offsetRange.startOffset < 0) {
+    throw new Error(`Invalid offset range: the start offset ${String(offsetRange.startOffset)} must not be negative.`);
+  }
+  if (offsetRange.endOffset < offsetRange.startOffset) {
+    throw new Error(`Invalid offset range: the end offset ${String(offsetRange.endOffset)} must not be less than the start offset ${String(offsetRange.startOffset)}.`);
+  }
+}
 
 // src/obsidian/backlink.ts
 async function renderBacklinksTable(dv, pathOrFiles) {
@@ -28818,8 +28868,10 @@ var PluginSettingsComponentBase = class extends ComponentEx {
   pluginSettingsClass;
   asyncEvents = new AsyncEvents();
   currentState;
+  isLoadedFromFile = false;
   lastSavedState;
   legacySettingsConverters = [];
+  loadedFromFileResolvers = [];
   propertyNames;
   validators = /* @__PURE__ */ new Map();
   /**
@@ -28917,6 +28969,7 @@ var PluginSettingsComponentBase = class extends ComponentEx {
         await this.saveToFileImpl();
       }
     } finally {
+      this.markLoadedFromFile();
       await this.asyncEvents.triggerAsync("loadSettings", this.currentState, isInitialLoad);
     }
   }
@@ -29086,6 +29139,31 @@ var PluginSettingsComponentBase = class extends ComponentEx {
     }
     return result;
   }
+  /**
+   * Waits until the settings have been read from `data.json` at least once.
+   *
+   * Anything that reads a setting from outside this component has to wait for this, because until the first
+   * {@link loadFromFile} completes {@link settings} still holds the DEFAULTS — reading it earlier answers
+   * with a default rather than with what the user actually stored. That window is easy to miss, since it is
+   * empty on a cold start (the workspace layout is not ready yet, so nothing has run) but wide open on a
+   * runtime enable from the Community Plugins tab or a re-enable after an update, where a layout-ready
+   * handler fires immediately while this component's own async load is still in flight.
+   *
+   * Resolves immediately once the settings have loaded, so a caller that arrives late is not stranded
+   * waiting for an event that has already been raised. Later reloads (an external `data.json` change) do
+   * not reset it — the question it answers is whether the settings have EVER been read, not whether the
+   * most recent read has finished.
+   *
+   * @returns A {@link Promise} that resolves once the settings have been loaded from the file.
+   */
+  whenLoadedFromFile() {
+    if (this.isLoadedFromFile) {
+      return noopAsync();
+    }
+    return new Promise((resolve2) => {
+      this.loadedFromFileResolvers.push(resolve2);
+    });
+  }
   /**
    * Gets the transformer.
    *
@@ -29188,6 +29266,13 @@ var PluginSettingsComponentBase = class extends ComponentEx {
     }
     return this.propertyNames.includes(property);
   }
+  markLoadedFromFile() {
+    this.isLoadedFromFile = true;
+    const resolvers = this.loadedFromFileResolvers.splice(0);
+    for (const resolve2 of resolvers) {
+      resolve2();
+    }
+  }
   async rawRecordToSettings(rawRecord) {
     rawRecord = this.getTransformer().transformObjectRecursively(rawRecord);
     await this.onLoadRecord(rawRecord);
@@ -29292,6 +29377,7 @@ var PluginSuggestionComponent = class extends ComponentEx {
   app;
   isSuggestionDeclined;
   pluginNoticeComponent;
+  pluginSettingsComponent;
   reason;
   setSuggestionDeclined;
   suggestedPluginId;
@@ -29305,6 +29391,7 @@ var PluginSuggestionComponent = class extends ComponentEx {
     super();
     this.app = params.app;
     this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
     this.reason = params.reason;
     this.suggestedPluginId = params.suggestedPluginId;
     this.suggestedPluginName = params.suggestedPluginName;
@@ -29357,15 +29444,27 @@ var PluginSuggestionComponent = class extends ComponentEx {
     }));
   }
   /**
-   * Loads the component, showing the suggestion notice once the layout is ready.
+   * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings
+   * have been read from disk.
+   *
+   * Both waits matter, and neither implies the other:
    *
-   * The wait matters: plugins load in an unspecified order, so the suggested plugin may well be enabled
-   * a moment after this one. Checking before the layout is ready would suggest installing something the
-   * user already has.
+   * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be
+   *   enabled a moment after this one. Checking earlier would suggest installing something the user
+   *   already has.
+   * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}
+   *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is
+   *   still in flight here. On a layout that is already ready — a runtime enable from the Community
+   *   Plugins tab, or a re-enable after an update — the layout-ready callback fires immediately, so the
+   *   read would see the default `false` and ask again a user who has already declined.
    */
   onload() {
     this.addChild(
-      new CallbackLayoutReadyComponent(this.app, () => {
+      new CallbackLayoutReadyComponent(this.app, async () => {
+        await this.pluginSettingsComponent.whenLoadedFromFile();
+        if (this.isUnloaded()) {
+          return;
+        }
         this.showSuggestionNotice();
       })
     );
@@ -37106,9 +37205,13 @@ __export(validation_exports, {
   WINDOWS_UNSAFE_PATH_CHARS: () => WINDOWS_UNSAFE_PATH_CHARS,
   getOsAndObsidianUnsafePathCharsRegExp: () => getOsAndObsidianUnsafePathCharsRegExp,
   getOsUnsafePathCharsRegExp: () => getOsUnsafePathCharsRegExp,
-  isValidationMessageHolder: () => isValidationMessageHolder
+  hasWindowsTrailingChars: () => hasWindowsTrailingChars,
+  isValidationMessageHolder: () => isValidationMessageHolder,
+  isWindowsReservedName: () => isWindowsReservedName,
+  trimWindowsTrailingChars: () => trimWindowsTrailingChars
 });
 var import_obsidian154 = require("obsidian");
+init_path();
 init_reg_exp();
 function isValidationMessageHolder(value) {
   return value.validationMessage !== void 0;
@@ -37116,6 +37219,8 @@ function isValidationMessageHolder(value) {
 var OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\]|]/g;
 var WINDOWS_UNSAFE_PATH_CHARS = /[*\\/<>:|?"]/g;
 var UNIX_UNSAFE_PATH_CHARS = /[\0/]/g;
+var WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;
+var WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;
 function getOsAndObsidianUnsafePathCharsRegExp(isWindows) {
   return oneOf([
     getOsUnsafePathCharsRegExp(isWindows),
@@ -37126,6 +37231,16 @@ function getOsUnsafePathCharsRegExp(isWindows) {
   isWindows ??= import_obsidian154.Platform.isWin;
   return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
 }
+function hasWindowsTrailingChars(name) {
+  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);
+}
+function isWindowsReservedName(name) {
+  const trimmedName = trimWindowsTrailingChars(name);
+  return WINDOWS_RESERVED_NAME_REG_EXP.test(basename(trimmedName, extname(trimmedName)));
+}
+function trimWindowsTrailingChars(name) {
+  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, "");
+}
 
 // src/obsidian/plugin/plugin-settings-tab.ts
 init_plugin_context();