obsidian-dev-utils 96.6.0 → 98.0.0

package/dist/lib/cjs/obsidian/demo-vault-naming.cjs

@@ -0,0 +1,167 @@
+/*
+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'
+  };
+
+  // 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;
+  globalThisRecord['__name'] ??= keepName;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // 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
+      }
+    );
+  }
+
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  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 demo_vault_naming_exports = {};
+__export(demo_vault_naming_exports, {
+  getDemoVaultArchiveFileName: () => getDemoVaultArchiveFileName,
+  getDemoVaultFolderName: () => getDemoVaultFolderName
+});
+module.exports = __toCommonJS(demo_vault_naming_exports);
+function getDemoVaultArchiveFileName(pluginId) {
+  return `${getDemoVaultBaseName(pluginId)}.zip`;
+}
+function getDemoVaultFolderName(params) {
+  const {
+    pluginId,
+    version
+  } = params;
+  return `${getDemoVaultBaseName(pluginId)}-${version}`;
+}
+function getDemoVaultBaseName(pluginId) {
+  return `${pluginId}-demo-vault`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDemoVaultArchiveFileName,
+  getDemoVaultFolderName
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/demo-vault-naming.d.cts

@@ -0,0 +1,54 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * The names a plugin's demo-vault release artifact carries — the one contract between the release-time
+ * packaging step and the runtime opener.
+ *
+ * The two live far apart: `script-utils/demo-vault.ts` runs under Node at release time and WRITES the
+ * archive, while `desktop-demo-vault-opener.ts` runs inside Obsidian and DOWNLOADS it by name. They used
+ * to agree by a comment on each side saying the other must be changed too, which is exactly the sort of
+ * pairing that survives until the day it does not. Both now derive every shared name from here.
+ *
+ * Kept free of `obsidian` and `node:` imports on purpose: the packaging step runs under Node, where the
+ * `obsidian` module does not exist, and the opener sits in the generated barrels, which must stay safe to
+ * evaluate on mobile.
+ */
+/**
+ * Parameters for {@link getDemoVaultFolderName}.
+ */
+export interface GetDemoVaultFolderNameParams {
+    /**
+     * The plugin id the vault demonstrates, from that plugin's `manifest.json`.
+     */
+    readonly pluginId: string;
+    /**
+     * The plugin version the vault ships with.
+     */
+    readonly version: string;
+}
+/**
+ * The file name of the demo-vault archive attached to a plugin's GitHub release.
+ *
+ * Carries the plugin id so several plugins' demo vaults never collide, and deliberately NOT the version:
+ * a release asset is already namespaced by its release tag (`…/releases/download/<version>/…`), so the
+ * version bought no disambiguation while making the asset name change on every release — which is what
+ * broke the Community directory's finding overrides, whose fingerprint includes the name. The version
+ * lives inside the archive instead, as {@link getDemoVaultFolderName} and on the README's heading.
+ *
+ * @param pluginId - The plugin id the vault demonstrates.
+ * @returns The archive file name, e.g. `my-plugin-demo-vault.zip`.
+ */
+export declare function getDemoVaultArchiveFileName(pluginId: string): string;
+/**
+ * The name of the demo vault's own folder — the archive's single top-level entry, and the folder the
+ * opener extracts it to.
+ *
+ * One name serves both because they are the same folder seen twice: a user who unzips the archive by hand
+ * gets a self-describing, version-distinct folder rather than an anonymous one, and a user who runs the
+ * `Open demo vault` command sees that same name in Obsidian's vault switcher.
+ *
+ * @param params - The {@link GetDemoVaultFolderNameParams}.
+ * @returns The folder name, e.g. `my-plugin-demo-vault-1.2.3`.
+ */
+export declare function getDemoVaultFolderName(params: GetDemoVaultFolderNameParams): string;

package/dist/lib/cjs/obsidian/desktop-demo-vault-opener.cjs

@@ -123,11 +123,9 @@ function keepName($unknown) {
 })();
 
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
@@ -145,14 +143,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __using = (stack, value, async) => {
   if (value != null) {
@@ -205,9 +195,11 @@ var import_node_buffer = require('node:buffer');
 var import_node_fs = require('node:fs');
 var import_node_os = require('node:os');
 var import_obsidian = require('obsidian');
+var import_desktop_zip_extractor = require('../desktop-zip-extractor.cjs');
 var import_path = require('../path.cjs');
 var import_community_plugins = require('./community-plugins.cjs');
 var import_plugin_notice_component = require('./components/plugin-notice-component.cjs');
+var import_demo_vault_naming = require('./demo-vault-naming.cjs');
 var import_select_option = require('./modals/select-option.cjs');
 const DEMO_VAULTS_CACHE_FOLDER = "obsidian-demo-vaults";
 const ARCHIVES_SUBFOLDER = "archives";
@@ -278,7 +270,7 @@ async function openDemoVault(params) {
     }
     progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);
     cleanupOrphanedExtractedVaults();
-    const vaultDirectory = await extractDemoVaultToFreshFolder({
+    const vaultDirectory = extractDemoVaultToFreshFolder({
       archive,
       pluginId,
       version: versionToOpen
@@ -308,20 +300,27 @@ function cleanupOrphanedExtractedVaults() {
     }
   }
 }
-async function extractDemoVaultArchive(archive, targetDirectory) {
-  const { default: AdmZip } = await import("adm-zip");
+function extractDemoVaultArchive(archive, targetDirectory) {
   const originalFs = window.require('node:original-fs');
-  const zip = new AdmZip(archive, { fs: originalFs });
-  zip.extractAllTo(targetDirectory, true);
+  (0, import_desktop_zip_extractor.extractZipArchive)({
+    archive,
+    fileSystem: originalFs,
+    targetDirectory
+  });
 }
-async function extractDemoVaultToFreshFolder(params) {
+function extractDemoVaultToFreshFolder(params) {
   const { archive, pluginId, version } = params;
   const extractedVaultsRoot = (0, import_path.join)((0, import_node_os.tmpdir)(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);
   (0, import_node_fs.mkdirSync)(extractedVaultsRoot, { recursive: true });
   const uniqueParentDirectory = (0, import_node_fs.mkdtempSync)((0, import_path.join)(extractedVaultsRoot, `${pluginId}-${version}-`));
-  const vaultDirectory = (0, import_path.join)(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);
-  await extractDemoVaultArchive(archive, vaultDirectory);
-  return vaultDirectory;
+  extractDemoVaultArchive(archive, uniqueParentDirectory);
+  return (0, import_path.join)(
+    uniqueParentDirectory,
+    (0, import_demo_vault_naming.getDemoVaultFolderName)({
+      pluginId,
+      version
+    })
+  );
 }
 async function resolveDemoVaultArchive(params) {
   const {
@@ -338,7 +337,7 @@ async function resolveDemoVaultArchive(params) {
     return (0, import_node_fs.readFileSync)(archivePath);
   }
   progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);
-  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${pluginId}-demo-vault-${version}.zip`;
+  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${(0, import_demo_vault_naming.getDemoVaultArchiveFileName)(pluginId)}`;
   const response = await (0, import_obsidian.requestUrl)({
     throw: false,
     url: assetUrl
@@ -356,4 +355,4 @@ async function resolveDemoVaultArchive(params) {
 0 && (module.exports = {
   openDemoVault
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `<plugin-id>-demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, and opens it as a\n * vault in a new window. When the installed plugin version is behind the latest release, the user is\n * offered a choice between the two versions.\n *\n * A progress notice is shown immediately (download + extraction can take a while, so the user must see\n * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp\n * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a\n * previous session's edits never leak into a new one. The extracted vault folder is named\n * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned\n * extracted folders left over from earlier sessions are cleaned up (best-effort) on each open.\n *\n * **`adm-zip` is loaded lazily, and must stay that way.** The `node:` imports below are safe to merely\n * evaluate on mobile \u2014 `require` hands back `undefined` there and nothing reads it at load time \u2014 but\n * `adm-zip`'s zip-crypto method opens with a top-level `const { randomFillSync } = require('crypto')`,\n * which throws the moment the module is initialized. Because the generated barrels re-export this module,\n * a static `import AdmZip from 'adm-zip'` therefore killed the whole library's load on Android (see the\n * mobile-load check in `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on\n * exactly that). Any future dependency that touches a platform-only API while initializing has to be\n * deferred the same way.\n */\n\nimport type { App } from 'obsidian';\n\nimport { compareVersions } from 'compare-versions';\n/* eslint-disable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { Buffer } from 'node:buffer';\nimport {\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  rmSync,\n  statSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\n/* eslint-enable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport { join } from '../path.ts';\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { PluginNoticeMode } from './components/plugin-notice-component.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The plugin id, used to locate the GitHub repository, to name the archive asset, and to name the\n   * cached archive and the extracted vault folder.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin display name, used to label the notices and the version-choice dialog.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The notice component used to report progress and problems (plugin not in the registry, missing\n   * archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The currently installed plugin version, offered as one of the version choices.\n   */\n  readonly pluginVersion: string;\n}\n\ninterface ExtractDemoVaultToFreshFolderParams {\n  readonly archive: Buffer;\n  readonly pluginId: string;\n  readonly version: string;\n}\n\ninterface ResolveDemoVaultArchiveParams {\n  readonly pluginId: string;\n  readonly pluginName: string;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly progressNotice: PluginNoticeComponentDelayedNotice;\n  readonly repo: string;\n  readonly version: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst ARCHIVES_SUBFOLDER = 'archives';\nconst EXTRACTED_VAULTS_SUBFOLDER = 'extracted';\nconst HTTP_STATUS_OK = 200;\n// One day in milliseconds (24 * 60 * 60 * 1000).\nconst ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 86_400_000;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. A progress notice is shown\n * immediately. The chosen version's archive is downloaded once (then reused from the archive cache),\n * but a fresh copy is extracted into its own temporary folder on every open \u2014 the vault is never reused\n * across sessions.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    pluginVersion\n  } = params;\n\n  // Shown immediately (`delayInMilliseconds: 0`): resolving the release, downloading and extracting can\n  // Each take a while, so the user must see progress the moment the command is invoked.\n  //\n  // Kept out of the shared slot (`Separate`), because this very function raises ordinary notices while\n  // The operation is still running \u2014 \"not in the registry\", \"no demo vault for this version\" \u2014 and a\n  // Slot notice would hide the progress notice rather than appear beside it.\n  using progressNotice = pluginNoticeComponent.showNoticeAfterDelay({\n    content: `Opening demo vault for ${pluginName}\u2026`,\n    delayInMilliseconds: 0,\n    mode: PluginNoticeMode.Separate\n  });\n\n  const repo = await getCommunityPluginRepo(pluginId);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = pluginVersion;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: pluginName\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const archive = await resolveDemoVaultArchive({\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version: versionToOpen\n  });\n  if (!archive) {\n    return;\n  }\n\n  progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);\n  cleanupOrphanedExtractedVaults();\n  const vaultDirectory = await extractDemoVaultToFreshFolder({\n    archive,\n    pluginId,\n    version: versionToOpen\n  });\n\n  window.electron.ipcRenderer.sendSync('vault-open', vaultDirectory, false);\n}\n\n/**\n * Removes extracted demo-vault folders left over from earlier sessions (best-effort).\n *\n * Every open extracts a fresh copy into its own folder and never deletes it afterwards (the vault stays\n * open in its window), so these accumulate. This drops folders older than\n * {@link ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS}. A folder whose vault is still open in another\n * window is locked on Windows and cannot be removed \u2014 the removal is wrapped so such a folder is simply\n * skipped and retried on a later open.\n */\nfunction cleanupOrphanedExtractedVaults(): void {\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  if (!existsSync(extractedVaultsRoot)) {\n    return;\n  }\n\n  const now = Date.now();\n  for (const entryName of readdirSync(extractedVaultsRoot)) {\n    const entryPath = join(extractedVaultsRoot, entryName);\n    try {\n      const stats = statSync(entryPath);\n      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {\n        continue;\n      }\n      rmSync(entryPath, { force: true, recursive: true });\n    } catch {\n      // Best-effort cleanup: an orphan whose vault is still open (locked on Windows) cannot be removed; skip it and retry on a later open.\n    }\n  }\n}\n\n/**\n * Extracts a downloaded demo-vault archive to disk.\n *\n * Electron's asar layer intercepts `fs` operations on any path containing `.asar` and throws `ENOENT`\n * when `chmod`-ing an `.asar` file (it treats it as an archive root rather than a plain file). A demo\n * vault may ship such a file (e.g. `_assets/CodeScriptToolkit/module.asar` demonstrating the ASAR\n * require feature), and adm-zip `chmod`s every extracted file, so extraction would otherwise crash.\n * Hand adm-zip Electron's `original-fs` \u2014 the real `fs` with asar interception disabled \u2014 so the\n * `.asar` file is treated as a plain file and `chmod` succeeds. It is a desktop-only Electron module\n * with no bundled types, so it is loaded via `window.require` and typed as `node:fs`'s shape.\n *\n * `adm-zip` is imported here rather than at the top of the module: it initializes a Node-only dependency\n * (`require('crypto')`), so a static import would break the library's load on mobile even though this\n * function only ever runs on desktop. See the module's `@file` note.\n *\n * @param archive - The raw zip archive bytes.\n * @param targetDirectory - The directory to extract into.\n * @returns A {@link Promise} that resolves once the archive has been extracted.\n */\nasync function extractDemoVaultArchive(archive: Buffer, targetDirectory: string): Promise<void> {\n  const { default: AdmZip } = await import('adm-zip');\n  const originalFs = window.require('node:original-fs') as typeof import('node:fs');\n  const zip = new AdmZip(archive, { fs: originalFs });\n  zip.extractAllTo(targetDirectory, true);\n}\n\n/**\n * Extracts the archive into a fresh, uniquely-named temporary folder and returns the vault path.\n *\n * A unique parent folder (`mkdtempSync`) guarantees a brand-new extraction every time \u2014 the demo vault\n * is never reused across opens, so a previous session's edits never leak in. Inside it, the vault folder\n * is named `<plugin-id>-<version>.demo-vault` so Obsidian's vault switcher shows a friendly name (its\n * basename) rather than the random temp id.\n *\n * @param params - The {@link ExtractDemoVaultToFreshFolderParams}.\n * @returns A {@link Promise} resolving to the absolute path of the freshly extracted vault folder.\n */\nasync function extractDemoVaultToFreshFolder(params: ExtractDemoVaultToFreshFolderParams): Promise<string> {\n  const { archive, pluginId, version } = params;\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  mkdirSync(extractedVaultsRoot, { recursive: true });\n  const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));\n  const vaultDirectory = join(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);\n  await extractDemoVaultArchive(archive, vaultDirectory);\n  return vaultDirectory;\n}\n\n/**\n * Resolves the demo-vault archive bytes for a version, downloading and caching them on first use.\n *\n * Only the archive is cached (keyed by plugin id + version); the extracted vault is not. A cache hit is\n * returned without any network request; a miss downloads the release asset, writes it to the archive\n * cache, and returns the freshly downloaded bytes.\n *\n * @param params - The {@link ResolveDemoVaultArchiveParams}.\n * @returns A {@link Promise} resolving to the archive bytes, or `null` when no archive is available for\n * the version (a notice has been shown).\n */\nasync function resolveDemoVaultArchive(params: ResolveDemoVaultArchiveParams): Promise<Buffer | null> {\n  const {\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version\n  } = params;\n\n  const archivesDirectory = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);\n  const archivePath = join(archivesDirectory, `${pluginId}-${version}.zip`);\n  if (existsSync(archivePath)) {\n    return readFileSync(archivePath);\n  }\n\n  progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${pluginId}-demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);\n    return null;\n  }\n\n  const archive = Buffer.from(response.arrayBuffer);\n  mkdirSync(archivesDirectory, { recursive: true });\n  writeFileSync(archivePath, archive);\n  return archive;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `<plugin-id>-demo-vault.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`; every name shared with it comes from\n * `demo-vault-naming.ts`). This resolves the plugin's repository from Obsidian's community registry,\n * downloads the archive for the chosen version, and opens it as a vault in a new window. When the\n * installed plugin version is behind the latest release, the user is offered a choice between the two\n * versions.\n *\n * A progress notice is shown immediately (download + extraction can take a while, so the user must see\n * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp\n * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a\n * previous session's edits never leak into a new one. The vault folder is the archive's own single\n * top-level folder, `<plugin-id>-demo-vault-<version>`, which reads nicely in Obsidian's vault switcher\n * and is the same name a hand-unzipped archive produces. Orphaned extracted folders left over from\n * earlier sessions are cleaned up (best-effort) on each open.\n *\n * **Nothing here may touch a platform-only API while the module INITIALIZES.** The `node:` imports below\n * are safe to merely evaluate on mobile \u2014 `require` hands back `undefined` there and nothing reads it at\n * load time \u2014 and because the generated barrels re-export this module, that is a load-bearing property of\n * the whole library rather than a detail of this file. It was learned the hard way: this module once\n * imported `adm-zip`, whose zip-crypto method opens with a top-level\n * `const { randomFillSync } = require('crypto')`, and a static `import AdmZip from 'adm-zip'` therefore\n * killed the library's load on Android (see the mobile-load check in\n * `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on exactly that). Extraction\n * now goes through `desktop-zip-extractor.ts`, which needs no dependency at all \u2014 but any future\n * dependency that initializes against a platform-only API still has to be deferred behind a call-time\n * `import()`.\n */\n\nimport type { App } from 'obsidian';\n\nimport { compareVersions } from 'compare-versions';\n/* eslint-disable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { Buffer } from 'node:buffer';\nimport {\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  rmSync,\n  statSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\n/* eslint-enable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport { extractZipArchive } from '../desktop-zip-extractor.ts';\nimport { join } from '../path.ts';\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { PluginNoticeMode } from './components/plugin-notice-component.ts';\nimport {\n  getDemoVaultArchiveFileName,\n  getDemoVaultFolderName\n} from './demo-vault-naming.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The plugin id, used to locate the GitHub repository, to name the archive asset, and to name the\n   * cached archive and the extracted vault folder.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin display name, used to label the notices and the version-choice dialog.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The notice component used to report progress and problems (plugin not in the registry, missing\n   * archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The currently installed plugin version, offered as one of the version choices.\n   */\n  readonly pluginVersion: string;\n}\n\ninterface ExtractDemoVaultToFreshFolderParams {\n  readonly archive: Buffer;\n  readonly pluginId: string;\n  readonly version: string;\n}\n\ninterface ResolveDemoVaultArchiveParams {\n  readonly pluginId: string;\n  readonly pluginName: string;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly progressNotice: PluginNoticeComponentDelayedNotice;\n  readonly repo: string;\n  readonly version: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst ARCHIVES_SUBFOLDER = 'archives';\nconst EXTRACTED_VAULTS_SUBFOLDER = 'extracted';\nconst HTTP_STATUS_OK = 200;\n// One day in milliseconds (24 * 60 * 60 * 1000).\nconst ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 86_400_000;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. A progress notice is shown\n * immediately. The chosen version's archive is downloaded once (then reused from the archive cache),\n * but a fresh copy is extracted into its own temporary folder on every open \u2014 the vault is never reused\n * across sessions.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    pluginVersion\n  } = params;\n\n  // Shown immediately (`delayInMilliseconds: 0`): resolving the release, downloading and extracting can\n  // Each take a while, so the user must see progress the moment the command is invoked.\n  //\n  // Kept out of the shared slot (`Separate`), because this very function raises ordinary notices while\n  // The operation is still running \u2014 \"not in the registry\", \"no demo vault for this version\" \u2014 and a\n  // Slot notice would hide the progress notice rather than appear beside it.\n  using progressNotice = pluginNoticeComponent.showNoticeAfterDelay({\n    content: `Opening demo vault for ${pluginName}\u2026`,\n    delayInMilliseconds: 0,\n    mode: PluginNoticeMode.Separate\n  });\n\n  const repo = await getCommunityPluginRepo(pluginId);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = pluginVersion;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: pluginName\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const archive = await resolveDemoVaultArchive({\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version: versionToOpen\n  });\n  if (!archive) {\n    return;\n  }\n\n  progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);\n  cleanupOrphanedExtractedVaults();\n  const vaultDirectory = extractDemoVaultToFreshFolder({\n    archive,\n    pluginId,\n    version: versionToOpen\n  });\n\n  window.electron.ipcRenderer.sendSync('vault-open', vaultDirectory, false);\n}\n\n/**\n * Removes extracted demo-vault folders left over from earlier sessions (best-effort).\n *\n * Every open extracts a fresh copy into its own folder and never deletes it afterwards (the vault stays\n * open in its window), so these accumulate. This drops folders older than\n * {@link ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS}. A folder whose vault is still open in another\n * window is locked on Windows and cannot be removed \u2014 the removal is wrapped so such a folder is simply\n * skipped and retried on a later open.\n */\nfunction cleanupOrphanedExtractedVaults(): void {\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  if (!existsSync(extractedVaultsRoot)) {\n    return;\n  }\n\n  const now = Date.now();\n  for (const entryName of readdirSync(extractedVaultsRoot)) {\n    const entryPath = join(extractedVaultsRoot, entryName);\n    try {\n      const stats = statSync(entryPath);\n      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {\n        continue;\n      }\n      rmSync(entryPath, { force: true, recursive: true });\n    } catch {\n      // Best-effort cleanup: an orphan whose vault is still open (locked on Windows) cannot be removed; skip it and retry on a later open.\n    }\n  }\n}\n\n/**\n * Extracts a downloaded demo-vault archive to disk.\n *\n * Extraction is written with Electron's `original-fs` \u2014 the real `fs` with asar interception disabled \u2014\n * rather than with `node:fs`. A demo vault may ship a file that merely LOOKS like an Electron archive\n * (e.g. `_assets/CodeScriptToolkit/module.asar` demonstrating the ASAR require feature), and Electron's\n * asar layer intercepts `fs` operations on any path containing `.asar`, treating it as an archive root\n * rather than a plain file. That already cost one production bug when the extractor `chmod`-ed such a\n * file and got `ENOENT`; nothing `chmod`s any more, but writing those bytes through the copy that has no\n * asar layer costs nothing and keeps the whole class of failure off this path. `original-fs` is a desktop-only\n * Electron module with no bundled types, so it is loaded via `window.require` and typed as `node:fs`'s\n * shape.\n *\n * @param archive - The raw zip archive bytes.\n * @param targetDirectory - The directory to extract into.\n */\nfunction extractDemoVaultArchive(archive: Buffer, targetDirectory: string): void {\n  const originalFs = window.require('node:original-fs') as typeof import('node:fs');\n  extractZipArchive({\n    archive,\n    fileSystem: originalFs,\n    targetDirectory\n  });\n}\n\n/**\n * Extracts the archive into a fresh, uniquely-named temporary folder and returns the vault path.\n *\n * A unique parent folder (`mkdtempSync`) guarantees a brand-new extraction every time \u2014 the demo vault\n * is never reused across opens, so a previous session's edits never leak in. The archive is extracted\n * into that parent and the vault is the single `<plugin-id>-demo-vault-<version>` folder it contains, so\n * Obsidian's vault switcher shows a friendly name (its basename) rather than the random temp id.\n *\n * That folder is not searched for: {@link getDemoVaultFolderName} names it on both sides, so the path is\n * known before a byte is written. Which keeps the extractor free of any read \u2014 deliberate, because\n * Electron's asar layer intercepts `fs` reads on any path containing `.asar`, and a demo vault may\n * legitimately ship such a file.\n *\n * @param params - The {@link ExtractDemoVaultToFreshFolderParams}.\n * @returns The absolute path of the freshly extracted vault folder.\n */\nfunction extractDemoVaultToFreshFolder(params: ExtractDemoVaultToFreshFolderParams): string {\n  const { archive, pluginId, version } = params;\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  mkdirSync(extractedVaultsRoot, { recursive: true });\n  const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));\n  extractDemoVaultArchive(archive, uniqueParentDirectory);\n  return join(\n    uniqueParentDirectory,\n    getDemoVaultFolderName({\n      pluginId,\n      version\n    })\n  );\n}\n\n/**\n * Resolves the demo-vault archive bytes for a version, downloading and caching them on first use.\n *\n * Only the archive is cached (keyed by plugin id + version); the extracted vault is not. A cache hit is\n * returned without any network request; a miss downloads the release asset, writes it to the archive\n * cache, and returns the freshly downloaded bytes.\n *\n * @param params - The {@link ResolveDemoVaultArchiveParams}.\n * @returns A {@link Promise} resolving to the archive bytes, or `null` when no archive is available for\n * the version (a notice has been shown).\n */\nasync function resolveDemoVaultArchive(params: ResolveDemoVaultArchiveParams): Promise<Buffer | null> {\n  const {\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version\n  } = params;\n\n  const archivesDirectory = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);\n  const archivePath = join(archivesDirectory, `${pluginId}-${version}.zip`);\n  if (existsSync(archivePath)) {\n    return readFileSync(archivePath);\n  }\n\n  progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${getDemoVaultArchiveFileName(pluginId)}`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);\n    return null;\n  }\n\n  const archive = Buffer.from(response.arrayBuffer);\n  mkdirSync(archivesDirectory, { recursive: true });\n  writeFileSync(archivePath, archive);\n  return archive;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/obsidian/desktop-demo-vault-opener.d.cts

@@ -4,27 +4,32 @@
  *
  * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).
  *
- * A plugin can attach a `<plugin-id>-demo-vault-<version>.zip` archive to each GitHub release (see
- * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository
- * from Obsidian's community registry, downloads the archive for the chosen version, and opens it as a
- * vault in a new window. When the installed plugin version is behind the latest release, the user is
- * offered a choice between the two versions.
+ * A plugin can attach a `<plugin-id>-demo-vault.zip` archive to each GitHub release (see
+ * `archivePluginDemoVault` in `script-utils/demo-vault.ts`; every name shared with it comes from
+ * `demo-vault-naming.ts`). This resolves the plugin's repository from Obsidian's community registry,
+ * downloads the archive for the chosen version, and opens it as a vault in a new window. When the
+ * installed plugin version is behind the latest release, the user is offered a choice between the two
+ * versions.
  *
  * A progress notice is shown immediately (download + extraction can take a while, so the user must see
  * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp
  * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a
- * previous session's edits never leak into a new one. The extracted vault folder is named
- * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned
- * extracted folders left over from earlier sessions are cleaned up (best-effort) on each open.
+ * previous session's edits never leak into a new one. The vault folder is the archive's own single
+ * top-level folder, `<plugin-id>-demo-vault-<version>`, which reads nicely in Obsidian's vault switcher
+ * and is the same name a hand-unzipped archive produces. Orphaned extracted folders left over from
+ * earlier sessions are cleaned up (best-effort) on each open.
  *
- * **`adm-zip` is loaded lazily, and must stay that way.** The `node:` imports below are safe to merely
- * evaluate on mobile — `require` hands back `undefined` there and nothing reads it at load time — but
- * `adm-zip`'s zip-crypto method opens with a top-level `const { randomFillSync } = require('crypto')`,
- * which throws the moment the module is initialized. Because the generated barrels re-export this module,
- * a static `import AdmZip from 'adm-zip'` therefore killed the whole library's load on Android (see the
- * mobile-load check in `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on
- * exactly that). Any future dependency that touches a platform-only API while initializing has to be
- * deferred the same way.
+ * **Nothing here may touch a platform-only API while the module INITIALIZES.** The `node:` imports below
+ * are safe to merely evaluate on mobile — `require` hands back `undefined` there and nothing reads it at
+ * load time — and because the generated barrels re-export this module, that is a load-bearing property of
+ * the whole library rather than a detail of this file. It was learned the hard way: this module once
+ * imported `adm-zip`, whose zip-crypto method opens with a top-level
+ * `const { randomFillSync } = require('crypto')`, and a static `import AdmZip from 'adm-zip'` therefore
+ * killed the library's load on Android (see the mobile-load check in
+ * `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on exactly that). Extraction
+ * now goes through `desktop-zip-extractor.ts`, which needs no dependency at all — but any future
+ * dependency that initializes against a platform-only API still has to be deferred behind a call-time
+ * `import()`.
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
 import type { PluginNoticeComponent } from './components/plugin-notice-component.cjs';