@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/esm/release-asset.d.mts

@@ -0,0 +1,190 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Downloads an optional data asset of a plugin release on demand: it asks the user first, verifies an expected SHA-256
+ * before anything is written or exposed, keeps the verified file in a local cache folder and hands back the adapter
+ * resource URL.
+ *
+ * It uses only cross-platform APIs ({@link requestUrlEx}, the vault adapter and `crypto.subtle`), so it works on desktop
+ * and mobile alike.
+ *
+ * Behavior that is part of the contract:
+ *
+ * - A cached file is hashed on every call. When its hash matches, it is reused without asking or downloading. When it
+ *   does not, it is removed and treated as missing, so a corrupt or truncated cache recovers by itself.
+ * - The user is asked only when a download is needed. Declining resolves with `null` and writes nothing.
+ * - Downloaded bytes are verified before they are written. A mismatch throws {@link ReleaseAssetChecksumError} and
+ *   writes nothing.
+ * - The file is written to a temporary sibling and then renamed into place, so an interrupted write never leaves a
+ *   partial file under the cached name.
+ * - An abort (pass the plugin's abort signal, so a plugin unload counts) rejects with the signal's reason. Once the
+ *   download has finished, the signal is checked again before writing, so nothing is written after an unload.
+ * - Concurrent calls for the same cache path share one operation, so the user is asked once.
+ */
+import type { App } from 'obsidian';
+/**
+ * Parameters for {@link ensureReleaseAsset}.
+ */
+export interface EnsureReleaseAssetParams {
+    /**
+     * Aborts the operation. Pass the plugin's abort signal, so an unload stops it.
+     */
+    readonly abortSignal?: AbortSignal | undefined;
+    /**
+     * The Obsidian application instance.
+     */
+    readonly app: App;
+    /**
+     * The vault-relative folder that holds the cached file, typically `${plugin.manifest.dir}/assets`.
+     *
+     * A folder inside the config folder is not synced, so each device downloads the asset once.
+     */
+    readonly cacheFolderPath: string;
+    /**
+     * The name of the cached file. It must not contain a path separator.
+     */
+    readonly fileName: string;
+    /**
+     * The expected SHA-256 of the asset, as 64 hexadecimal digits.
+     */
+    readonly sha256: string;
+    /**
+     * Asks the user whether to download the asset. Defaults to a confirmation modal.
+     *
+     * Pass `() => Promise.resolve(true)` when the user has already agreed, for example through a setting.
+     */
+    readonly shouldDownload?: ((request: ReleaseAssetConsentRequest) => Promise<boolean>) | undefined;
+    /**
+     * The size of the asset in bytes, shown to the user when asking.
+     */
+    readonly sizeInBytes?: number | undefined;
+    /**
+     * The download timeout in milliseconds.
+     */
+    readonly timeoutInMilliseconds?: number | undefined;
+    /**
+     * The URL to download the asset from. Only `http:` and `https:` URLs are accepted.
+     */
+    readonly url: string;
+}
+/**
+ * Parameters for {@link getGitHubReleaseAssetUrl}.
+ */
+export interface GetGitHubReleaseAssetUrlParams {
+    /**
+     * The name of the release asset.
+     */
+    readonly fileName: string;
+    /**
+     * The repository, as `<owner>/<name>`.
+     */
+    readonly repository: string;
+    /**
+     * The release tag, typically the plugin version.
+     */
+    readonly tag: string;
+}
+/**
+ * A verified release asset.
+ */
+export interface ReleaseAsset {
+    /**
+     * The vault-relative path of the cached file.
+     */
+    readonly path: string;
+    /**
+     * The resource URL of the cached file, from the adapter's `getResourcePath`.
+     */
+    readonly resourceUrl: string;
+    /**
+     * Whether the file was already cached, so nothing was downloaded.
+     */
+    readonly wasCached: boolean;
+}
+/**
+ * Parameters for {@link ReleaseAssetChecksumError}.
+ */
+export interface ReleaseAssetChecksumErrorConstructorParams {
+    /**
+     * The SHA-256 of the downloaded bytes.
+     */
+    readonly actualSha256: string;
+    /**
+     * The expected SHA-256.
+     */
+    readonly expectedSha256: string;
+    /**
+     * The URL the asset was downloaded from.
+     */
+    readonly url: string;
+}
+/**
+ * What the user is asked to agree to.
+ */
+export interface ReleaseAssetConsentRequest {
+    /**
+     * The name of the asset.
+     */
+    readonly fileName: string;
+    /**
+     * The size of the asset in bytes, when known.
+     */
+    readonly sizeInBytes?: number | undefined;
+    /**
+     * The URL the asset is downloaded from.
+     */
+    readonly url: string;
+}
+/**
+ * Thrown when downloaded bytes do not match the expected SHA-256. Nothing was written.
+ */
+export declare class ReleaseAssetChecksumError extends Error {
+    /**
+     * The SHA-256 of the downloaded bytes.
+     */
+    readonly actualSha256: string;
+    /**
+     * The expected SHA-256.
+     */
+    readonly expectedSha256: string;
+    /**
+     * The URL the asset was downloaded from.
+     */
+    readonly url: string;
+    /**
+     * Creates the error.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: ReleaseAssetChecksumErrorConstructorParams);
+}
+/**
+ * Computes the SHA-256 of the given bytes.
+ *
+ * @param data - The bytes.
+ * @returns The SHA-256 as 64 lowercase hexadecimal digits.
+ */
+export declare function computeSha256(data: ArrayBuffer): Promise<string>;
+/**
+ * Returns the cached, verified asset, downloading it first, with the user's consent, when it is missing or corrupt.
+ *
+ * @param params - The parameters.
+ * @returns The verified asset, or `null` when the user declined the download.
+ */
+export declare function ensureReleaseAsset(params: EnsureReleaseAssetParams): Promise<null | ReleaseAsset>;
+/**
+ * Formats a byte size for a person to read.
+ *
+ * @param sizeInBytes - The size in bytes.
+ * @returns The formatted size, such as `12.3 MB`.
+ */
+export declare function formatByteSize(sizeInBytes: number): string;
+/**
+ * Builds the download URL of a GitHub release asset.
+ *
+ * @param params - The parameters.
+ * @returns The URL.
+ */
+export declare function getGitHubReleaseAssetUrl(params: GetGitHubReleaseAssetUrlParams): string;

package/dist/lib/esm/release-asset.mjs

@@ -0,0 +1,187 @@
+/*
+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 ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { join } from "@mnaoumov/typescript-lib/path";
+import { t } from "./i18n/i18n.mjs";
+import { confirm } from "./modals/confirm.mjs";
+import { requestUrlEx } from "./request-url.mjs";
+const BYTES_IN_KILOBYTE = 1024;
+const HEX_BYTE_LENGTH = 2;
+const HEX_RADIX = 16;
+const SHA_256_HEX_REG_EXP = /^[0-9a-f]{64}$/i;
+const TEMPORARY_FILE_SUFFIX = ".download";
+class ReleaseAssetChecksumError extends Error {
+  /**
+   * The SHA-256 of the downloaded bytes.
+   */
+  actualSha256;
+  /**
+   * The expected SHA-256.
+   */
+  expectedSha256;
+  /**
+   * The URL the asset was downloaded from.
+   */
+  url;
+  /**
+   * Creates the error.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super(`The asset downloaded from ${params.url} has SHA-256 ${params.actualSha256}, expected ${params.expectedSha256}.`);
+    this.name = "ReleaseAssetChecksumError";
+    this.actualSha256 = params.actualSha256;
+    this.expectedSha256 = params.expectedSha256;
+    this.url = params.url;
+  }
+}
+const inFlightOperations = /* @__PURE__ */ new Map();
+async function computeSha256(data) {
+  const hash = await window.crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, "0")).join("");
+}
+async function ensureReleaseAsset(params) {
+  if (!SHA_256_HEX_REG_EXP.test(params.sha256)) {
+    throw new Error(`Invalid SHA-256: ${params.sha256}`);
+  }
+  if (!params.fileName || /[/\\]/.test(params.fileName) || params.fileName === "." || params.fileName === "..") {
+    throw new Error(`Invalid asset file name: ${params.fileName}`);
+  }
+  const path = join(params.cacheFolderPath, params.fileName);
+  const inFlightOperation = inFlightOperations.get(path);
+  if (inFlightOperation) {
+    return await inFlightOperation;
+  }
+  const operation = ensureReleaseAssetImpl(params, path);
+  inFlightOperations.set(path, operation);
+  try {
+    return await operation;
+  } finally {
+    inFlightOperations.delete(path);
+  }
+}
+function formatByteSize(sizeInBytes) {
+  if (sizeInBytes < BYTES_IN_KILOBYTE) {
+    return `${String(sizeInBytes)} B`;
+  }
+  let size = sizeInBytes / BYTES_IN_KILOBYTE;
+  let unit = "KB";
+  for (const largerUnit of ["MB", "GB"]) {
+    if (size < BYTES_IN_KILOBYTE) {
+      break;
+    }
+    size /= BYTES_IN_KILOBYTE;
+    unit = largerUnit;
+  }
+  return `${size.toFixed(1)} ${unit}`;
+}
+function getGitHubReleaseAssetUrl(params) {
+  return `https://github.com/${params.repository}/releases/download/${encodeURIComponent(params.tag)}/${encodeURIComponent(params.fileName)}`;
+}
+async function ensureReleaseAssetImpl(params, path) {
+  const { abortSignal, app } = params;
+  const adapter = app.vault.adapter;
+  const expectedSha256 = params.sha256.toLowerCase();
+  abortSignal?.throwIfAborted();
+  if (await adapter.exists(path)) {
+    const cachedBytes = await adapter.readBinary(path);
+    if (await computeSha256(cachedBytes) === expectedSha256) {
+      return {
+        path,
+        resourceUrl: adapter.getResourcePath(path),
+        wasCached: true
+      };
+    }
+    await adapter.remove(path);
+  }
+  const consentRequest = {
+    fileName: params.fileName,
+    sizeInBytes: params.sizeInBytes,
+    url: params.url
+  };
+  const isDownloadAllowed = params.shouldDownload ? await params.shouldDownload(consentRequest) : await shouldDownloadWithModal(app, consentRequest);
+  if (!isDownloadAllowed) {
+    return null;
+  }
+  abortSignal?.throwIfAborted();
+  const response = await requestUrlEx({
+    abortSignal,
+    timeoutInMilliseconds: params.timeoutInMilliseconds,
+    url: params.url
+  });
+  const bytes = response.arrayBuffer;
+  const actualSha256 = await computeSha256(bytes);
+  if (actualSha256 !== expectedSha256) {
+    throw new ReleaseAssetChecksumError({ actualSha256, expectedSha256, url: params.url });
+  }
+  abortSignal?.throwIfAborted();
+  if (!await adapter.exists(params.cacheFolderPath)) {
+    await adapter.mkdir(params.cacheFolderPath);
+  }
+  const temporaryPath = `${path}${TEMPORARY_FILE_SUFFIX}`;
+  try {
+    await adapter.writeBinary(temporaryPath, bytes);
+    if (await adapter.exists(path)) {
+      await adapter.remove(path);
+    }
+    await adapter.rename(temporaryPath, path);
+  } catch (error) {
+    if (await adapter.exists(temporaryPath)) {
+      await adapter.remove(temporaryPath);
+    }
+    throw error;
+  }
+  return {
+    path,
+    resourceUrl: adapter.getResourcePath(path),
+    wasCached: false
+  };
+}
+async function shouldDownloadWithModal(app, request) {
+  const host = new URL(request.url).host;
+  const message = request.sizeInBytes === void 0 ? t(($) => $.obsidianLib.releaseAsset.consentMessageUnknownSize, { fileName: request.fileName, host }) : t(($) => $.obsidianLib.releaseAsset.consentMessage, { fileName: request.fileName, host, size: formatByteSize(request.sizeInBytes) });
+  return await confirm({
+    app,
+    message,
+    okButtonText: t(($) => $.obsidianLib.releaseAsset.download),
+    title: t(($) => $.obsidianLib.releaseAsset.consentTitle, { fileName: request.fileName })
+  });
+}
+export {
+  ReleaseAssetChecksumError,
+  computeSha256,
+  ensureReleaseAsset,
+  formatByteSize,
+  getGitHubReleaseAssetUrl
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/release-asset.ts"],"sourcesContent":["/**\n * @file\n *\n * Downloads an optional data asset of a plugin release on demand: it asks the user first, verifies an expected SHA-256\n * before anything is written or exposed, keeps the verified file in a local cache folder and hands back the adapter\n * resource URL.\n *\n * It uses only cross-platform APIs ({@link requestUrlEx}, the vault adapter and `crypto.subtle`), so it works on desktop\n * and mobile alike.\n *\n * Behavior that is part of the contract:\n *\n * - A cached file is hashed on every call. When its hash matches, it is reused without asking or downloading. When it\n *   does not, it is removed and treated as missing, so a corrupt or truncated cache recovers by itself.\n * - The user is asked only when a download is needed. Declining resolves with `null` and writes nothing.\n * - Downloaded bytes are verified before they are written. A mismatch throws {@link ReleaseAssetChecksumError} and\n *   writes nothing.\n * - The file is written to a temporary sibling and then renamed into place, so an interrupted write never leaves a\n *   partial file under the cached name.\n * - An abort (pass the plugin's abort signal, so a plugin unload counts) rejects with the signal's reason. Once the\n *   download has finished, the signal is checked again before writing, so nothing is written after an unload.\n * - Concurrent calls for the same cache path share one operation, so the user is asked once.\n */\n\nimport type { App } from 'obsidian';\n\nimport { join } from '@mnaoumov/typescript-lib/path';\n\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport { requestUrlEx } from './request-url.ts';\n\nconst BYTES_IN_KILOBYTE = 1024;\nconst HEX_BYTE_LENGTH = 2;\nconst HEX_RADIX = 16;\nconst SHA_256_HEX_REG_EXP = /^[0-9a-f]{64}$/i;\nconst TEMPORARY_FILE_SUFFIX = '.download';\n\n/**\n * Parameters for {@link ensureReleaseAsset}.\n */\nexport interface EnsureReleaseAssetParams {\n  /**\n   * Aborts the operation. Pass the plugin's abort signal, so an unload stops it.\n   */\n  readonly abortSignal?: AbortSignal | undefined;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The vault-relative folder that holds the cached file, typically `${plugin.manifest.dir}/assets`.\n   *\n   * A folder inside the config folder is not synced, so each device downloads the asset once.\n   */\n  readonly cacheFolderPath: string;\n\n  /**\n   * The name of the cached file. It must not contain a path separator.\n   */\n  readonly fileName: string;\n\n  /**\n   * The expected SHA-256 of the asset, as 64 hexadecimal digits.\n   */\n  readonly sha256: string;\n\n  /**\n   * Asks the user whether to download the asset. Defaults to a confirmation modal.\n   *\n   * Pass `() => Promise.resolve(true)` when the user has already agreed, for example through a setting.\n   */\n  readonly shouldDownload?: ((request: ReleaseAssetConsentRequest) => Promise<boolean>) | undefined;\n\n  /**\n   * The size of the asset in bytes, shown to the user when asking.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The download timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n\n  /**\n   * The URL to download the asset from. Only `http:` and `https:` URLs are accepted.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link getGitHubReleaseAssetUrl}.\n */\nexport interface GetGitHubReleaseAssetUrlParams {\n  /**\n   * The name of the release asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The repository, as `<owner>/<name>`.\n   */\n  readonly repository: string;\n\n  /**\n   * The release tag, typically the plugin version.\n   */\n  readonly tag: string;\n}\n\n/**\n * A verified release asset.\n */\nexport interface ReleaseAsset {\n  /**\n   * The vault-relative path of the cached file.\n   */\n  readonly path: string;\n\n  /**\n   * The resource URL of the cached file, from the adapter's `getResourcePath`.\n   */\n  readonly resourceUrl: string;\n\n  /**\n   * Whether the file was already cached, so nothing was downloaded.\n   */\n  readonly wasCached: boolean;\n}\n\n/**\n * Parameters for {@link ReleaseAssetChecksumError}.\n */\nexport interface ReleaseAssetChecksumErrorConstructorParams {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * What the user is asked to agree to.\n */\nexport interface ReleaseAssetConsentRequest {\n  /**\n   * The name of the asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The size of the asset in bytes, when known.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The URL the asset is downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * Thrown when downloaded bytes do not match the expected SHA-256. Nothing was written.\n */\nexport class ReleaseAssetChecksumError extends Error {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  public readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  public readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  public readonly url: string;\n\n  /**\n   * Creates the error.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: ReleaseAssetChecksumErrorConstructorParams) {\n    super(`The asset downloaded from ${params.url} has SHA-256 ${params.actualSha256}, expected ${params.expectedSha256}.`);\n    this.name = 'ReleaseAssetChecksumError';\n    this.actualSha256 = params.actualSha256;\n    this.expectedSha256 = params.expectedSha256;\n    this.url = params.url;\n  }\n}\n\nconst inFlightOperations = new Map<string, Promise<null | ReleaseAsset>>();\n\n/**\n * Computes the SHA-256 of the given bytes.\n *\n * @param data - The bytes.\n * @returns The SHA-256 as 64 lowercase hexadecimal digits.\n */\nexport async function computeSha256(data: ArrayBuffer): Promise<string> {\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- This is the Obsidian renderer Web API, not a Node builtin.\n  const hash = await window.crypto.subtle.digest('SHA-256', data);\n  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, '0')).join('');\n}\n\n/**\n * Returns the cached, verified asset, downloading it first, with the user's consent, when it is missing or corrupt.\n *\n * @param params - The parameters.\n * @returns The verified asset, or `null` when the user declined the download.\n */\nexport async function ensureReleaseAsset(params: EnsureReleaseAssetParams): Promise<null | ReleaseAsset> {\n  if (!SHA_256_HEX_REG_EXP.test(params.sha256)) {\n    throw new Error(`Invalid SHA-256: ${params.sha256}`);\n  }\n\n  if (!params.fileName || /[/\\\\]/.test(params.fileName) || params.fileName === '.' || params.fileName === '..') {\n    throw new Error(`Invalid asset file name: ${params.fileName}`);\n  }\n\n  const path = join(params.cacheFolderPath, params.fileName);\n  const inFlightOperation = inFlightOperations.get(path);\n  if (inFlightOperation) {\n    return await inFlightOperation;\n  }\n\n  const operation = ensureReleaseAssetImpl(params, path);\n  inFlightOperations.set(path, operation);\n  try {\n    return await operation;\n  } finally {\n    inFlightOperations.delete(path);\n  }\n}\n\n/**\n * Formats a byte size for a person to read.\n *\n * @param sizeInBytes - The size in bytes.\n * @returns The formatted size, such as `12.3 MB`.\n */\nexport function formatByteSize(sizeInBytes: number): string {\n  if (sizeInBytes < BYTES_IN_KILOBYTE) {\n    return `${String(sizeInBytes)} B`;\n  }\n  let size = sizeInBytes / BYTES_IN_KILOBYTE;\n  let unit = 'KB';\n  for (const largerUnit of ['MB', 'GB']) {\n    if (size < BYTES_IN_KILOBYTE) {\n      break;\n    }\n    size /= BYTES_IN_KILOBYTE;\n    unit = largerUnit;\n  }\n  return `${size.toFixed(1)} ${unit}`;\n}\n\n/**\n * Builds the download URL of a GitHub release asset.\n *\n * @param params - The parameters.\n * @returns The URL.\n */\nexport function getGitHubReleaseAssetUrl(params: GetGitHubReleaseAssetUrlParams): string {\n  return `https://github.com/${params.repository}/releases/download/${encodeURIComponent(params.tag)}/${encodeURIComponent(params.fileName)}`;\n}\n\nasync function ensureReleaseAssetImpl(params: EnsureReleaseAssetParams, path: string): Promise<null | ReleaseAsset> {\n  const { abortSignal, app } = params;\n  const adapter = app.vault.adapter;\n  const expectedSha256 = params.sha256.toLowerCase();\n  abortSignal?.throwIfAborted();\n\n  if (await adapter.exists(path)) {\n    const cachedBytes = await adapter.readBinary(path);\n    if (await computeSha256(cachedBytes) === expectedSha256) {\n      return {\n        path,\n        resourceUrl: adapter.getResourcePath(path),\n        wasCached: true\n      };\n    }\n    await adapter.remove(path);\n  }\n\n  const consentRequest: ReleaseAssetConsentRequest = {\n    fileName: params.fileName,\n    sizeInBytes: params.sizeInBytes,\n    url: params.url\n  };\n  const isDownloadAllowed = params.shouldDownload ? await params.shouldDownload(consentRequest) : await shouldDownloadWithModal(app, consentRequest);\n  if (!isDownloadAllowed) {\n    return null;\n  }\n  abortSignal?.throwIfAborted();\n\n  const response = await requestUrlEx({\n    abortSignal,\n    timeoutInMilliseconds: params.timeoutInMilliseconds,\n    url: params.url\n  });\n  const bytes = response.arrayBuffer;\n  const actualSha256 = await computeSha256(bytes);\n  if (actualSha256 !== expectedSha256) {\n    throw new ReleaseAssetChecksumError({ actualSha256, expectedSha256, url: params.url });\n  }\n  abortSignal?.throwIfAborted();\n\n  if (!await adapter.exists(params.cacheFolderPath)) {\n    await adapter.mkdir(params.cacheFolderPath);\n  }\n\n  const temporaryPath = `${path}${TEMPORARY_FILE_SUFFIX}`;\n  try {\n    await adapter.writeBinary(temporaryPath, bytes);\n    if (await adapter.exists(path)) {\n      await adapter.remove(path);\n    }\n    await adapter.rename(temporaryPath, path);\n  } catch (error) {\n    if (await adapter.exists(temporaryPath)) {\n      await adapter.remove(temporaryPath);\n    }\n    throw error;\n  }\n\n  return {\n    path,\n    resourceUrl: adapter.getResourcePath(path),\n    wasCached: false\n  };\n}\n\nasync function shouldDownloadWithModal(app: App, request: ReleaseAssetConsentRequest): Promise<boolean> {\n  const host = new URL(request.url).host;\n  const message = request.sizeInBytes === undefined\n    ? t(($) => $.obsidianLib.releaseAsset.consentMessageUnknownSize, { fileName: request.fileName, host })\n    : t(($) => $.obsidianLib.releaseAsset.consentMessage, { fileName: request.fileName, host, size: formatByteSize(request.sizeInBytes) });\n  return await confirm({\n    app,\n    message,\n    okButtonText: t(($) => $.obsidianLib.releaseAsset.download),\n    title: t(($) => $.obsidianLib.releaseAsset.consentTitle, { fileName: request.fileName })\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/workspace.d.mts

@@ -38,6 +38,12 @@ export declare function getAllDomWindows(app: App): Window[];
  * (every popout is a {@link WorkspaceWindow} under `floatingSplit`). Prefer this over the global
  * `window`, which only happens to be the main window because plugin code runs in its context.
  *
+ * Before the workspace layout loads, there is no root split yet: Obsidian `1.15.1` loads community
+ * plugins (`app.plugins.initialize()`) before `workspace.loadLayout()` builds `rootSplit`, so a plugin
+ * enabled at startup runs its `onload` while `rootSplit` is still `null`. No popout exists at that
+ * point either, so the global `window`, the window plugin code runs in, is the main window, and that
+ * is what is returned then. `WorkspaceRoot` itself is built with that same `window`.
+ *
  * @param app - The Obsidian app.
  * @returns The app's main window.
  */

package/dist/lib/esm/workspace.mjs

@@ -47,7 +47,8 @@ function getAllDomWindows(app) {
   return getAllContainers(app).map((container) => container.win);
 }
 function getMainWindow(app) {
-  return app.workspace.rootSplit.win;
+  const rootSplit = app.workspace.rootSplit;
+  return rootSplit?.win ?? window;
 }
 function switchToMainWindow(app) {
   return switchToWindow(getMainWindow(app));
@@ -72,4 +73,4 @@ export {
   switchToMainWindow,
   switchToWindow
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/workspace.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides additional utilities for working with the Obsidian {@link Workspace}.\n */\n\nimport type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';\nimport type {\n  App,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `Workspace` to use it in the tsdocs.\n  Workspace,\n  WorkspaceContainer,\n  WorkspaceRoot,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `WorkspaceWindow` to use it in the tsdocs.\n  WorkspaceWindow\n} from 'obsidian';\n\nimport { CallbackDisposable } from '@mnaoumov/typescript-lib/disposable';\n\n/**\n * Waits until the workspace layout is ready.\n *\n * Resolves immediately when the layout is already ready; otherwise resolves once Obsidian fires the\n * layout-ready event.\n *\n * @param app - The Obsidian app.\n * @returns A {@link Promise} that resolves once the workspace layout is ready.\n */\nexport async function ensureLayoutReady(app: App): Promise<void> {\n  await new Promise<void>((resolve) => {\n    app.workspace.onLayoutReady(resolve);\n  });\n}\n\n/**\n * Returns all containers in the workspace.\n *\n * @param app - The Obsidian app.\n * @returns All containers in the workspace.\n */\nexport function getAllContainers(app: App): WorkspaceContainer[] {\n  const containers = new Set<WorkspaceContainer>();\n  app.workspace.iterateAllLeaves((leaf) => {\n    containers.add(leaf.getContainer());\n  });\n  return [...containers];\n}\n\n/**\n * Returns all DOM windows in the workspace.\n *\n * @param app - The Obsidian app.\n * @returns All DOM windows in the workspace.\n */\nexport function getAllDomWindows(app: App): Window[] {\n  return getAllContainers(app).map((container) => container.win);\n}\n\n/**\n * Returns the app's main window — the one the vault opened in, as opposed to any popout window.\n *\n * Read from the root split, which is the one workspace container that always lives in the main window\n * (every popout is a {@link WorkspaceWindow} under `floatingSplit`). Prefer this over the global\n * `window`, which only happens to be the main window because plugin code runs in its context.\n *\n * Before the workspace layout loads, there is no root split yet: Obsidian `1.15.1` loads community\n * plugins (`app.plugins.initialize()`) before `workspace.loadLayout()` builds `rootSplit`, so a plugin\n * enabled at startup runs its `onload` while `rootSplit` is still `null`. No popout exists at that\n * point either, so the global `window`, the window plugin code runs in, is the main window, and that\n * is what is returned then. `WorkspaceRoot` itself is built with that same `window`.\n *\n * @param app - The Obsidian app.\n * @returns The app's main window.\n */\nexport function getMainWindow(app: App): Window {\n  // `obsidian.d.ts` declares `rootSplit` non-null, which is not true before the layout loads.\n  const rootSplit = app.workspace.rootSplit as null | WorkspaceRoot;\n  return rootSplit?.win ?? window;\n}\n\n/**\n * Makes the app's main window the active one until the returned {@link DisposableEx} is disposed.\n *\n * See {@link switchToWindow} for why this is needed and what it changes, and {@link getMainWindow} for\n * what counts as the main window.\n *\n * @param app - The Obsidian app.\n * @returns A {@link DisposableEx} that restores the previously active window when disposed.\n * @example\n * ```ts\n * // Raise a notice in the main window even while the settings window is open.\n * using _mainWindowSwitch = switchToMainWindow(app);\n * new Notice('This vault is a temporary sandbox.');\n * ```\n */\nexport function switchToMainWindow(app: App): DisposableEx {\n  return switchToWindow(getMainWindow(app));\n}\n\n/**\n * Makes the given window the active one until the returned {@link DisposableEx} is disposed.\n *\n * Obsidian tracks the focused window in the `activeWindow` / `activeDocument` globals and updates them\n * whenever a window takes focus — including when a popout such as the settings window opens. UI it\n * creates for \"the current window\" reads those globals at creation time and offers no way to name a\n * window: `new Notice(...)`, for instance, is built inside whatever window `activeWindow` points at,\n * and cannot be moved afterwards. Pointing the globals at the wanted window for exactly that creation,\n * then putting them back, is what this does.\n *\n * Restore is what makes it safe, so always bind it with `using` (or dispose it in a `finally`): leaving\n * the globals pointed at the wrong window would misplace every later window-sensitive Obsidian call.\n *\n * @param win - The window to make active.\n * @returns A {@link DisposableEx} that restores the previously active window when disposed.\n * @example\n * ```ts\n * using _windowSwitch = switchToWindow(otherWindow);\n * new Notice('This notice belongs to the other window.');\n * ```\n */\nexport function switchToWindow(win: Window): DisposableEx {\n  const previousActiveWindow = activeWindow;\n  const previousActiveDocument = activeDocument;\n  window.activeWindow = win;\n  window.activeDocument = win.document;\n\n  return new CallbackDisposable({\n    callback: (): void => {\n      window.activeWindow = previousActiveWindow;\n      window.activeDocument = previousActiveDocument;\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,SAAS,0BAA0B;AAWnC,eAAsB,kBAAkB,KAAyB;AAC/D,QAAM,IAAI,QAAc,CAAC,YAAY;AACnC,QAAI,UAAU,cAAc,OAAO;AAAA,EACrC,CAAC;AACH;AAQO,SAAS,iBAAiB,KAAgC;AAC/D,QAAM,aAAa,oBAAI,IAAwB;AAC/C,MAAI,UAAU,iBAAiB,CAAC,SAAS;AACvC,eAAW,IAAI,KAAK,aAAa,CAAC;AAAA,EACpC,CAAC;AACD,SAAO,CAAC,GAAG,UAAU;AACvB;AAQO,SAAS,iBAAiB,KAAoB;AACnD,SAAO,iBAAiB,GAAG,EAAE,IAAI,CAAC,cAAc,UAAU,GAAG;AAC/D;AAkBO,SAAS,cAAc,KAAkB;AAE9C,QAAM,YAAY,IAAI,UAAU;AAChC,SAAO,WAAW,OAAO;AAC3B;AAiBO,SAAS,mBAAmB,KAAwB;AACzD,SAAO,eAAe,cAAc,GAAG,CAAC;AAC1C;AAuBO,SAAS,eAAe,KAA2B;AACxD,QAAM,uBAAuB;AAC7B,QAAM,yBAAyB;AAC/B,SAAO,eAAe;AACtB,SAAO,iBAAiB,IAAI;AAE5B,SAAO,IAAI,mBAAmB;AAAA,IAC5B,UAAU,MAAY;AACpB,aAAO,eAAe;AACtB,aAAO,iBAAiB;AAAA,IAC1B;AAAA,EACF,CAAC;AACH;","names":[]}