@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,372 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var desktop_demo_vault_opener_exports = {};
+__export(desktop_demo_vault_opener_exports, {
+  openDemoVault: () => openDemoVault
+});
+module.exports = __toCommonJS(desktop_demo_vault_opener_exports);
+var import_desktop_zip_extractor = require('@mnaoumov/typescript-lib/desktop-zip-extractor');
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_compare_versions = require('compare-versions');
+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_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";
+const EXTRACTED_VAULTS_SUBFOLDER = "extracted";
+const HTTP_STATUS_OK = 200;
+const ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 864e5;
+async function openDemoVault(params) {
+  var _stack = [];
+  try {
+    const {
+      app,
+      pluginId,
+      pluginName,
+      pluginNoticeComponent,
+      pluginVersion
+    } = params;
+    const progressNotice = __using(_stack, pluginNoticeComponent.showNoticeAfterDelay({
+      content: `Opening demo vault for ${pluginName}\u2026`,
+      delayInMilliseconds: 0,
+      mode: import_plugin_notice_component.PluginNoticeMode.Separate
+    }));
+    const repo = await (0, import_community_plugins.getCommunityPluginRepo)(pluginId);
+    if (!repo) {
+      pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);
+      return;
+    }
+    const currentVersion = pluginVersion;
+    const latestVersion = await (0, import_community_plugins.getLatestReleaseVersion)(repo);
+    let versionToOpen;
+    if ((0, import_compare_versions.compareVersions)(currentVersion, latestVersion) >= 0) {
+      versionToOpen = currentVersion;
+    } else {
+      const chosenVersion = await (0, import_select_option.selectOption)({
+        app,
+        message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,
+        options: [
+          {
+            isCta: true,
+            text: `Open demo vault for latest version (v${latestVersion})`,
+            value: latestVersion
+          },
+          {
+            text: `Open demo vault for current version (v${currentVersion})`,
+            value: currentVersion
+          },
+          {
+            text: "Cancel",
+            value: null
+          }
+        ],
+        title: pluginName
+      });
+      if (chosenVersion === null) {
+        return;
+      }
+      versionToOpen = chosenVersion;
+    }
+    const archive = await resolveDemoVaultArchive({
+      pluginId,
+      pluginName,
+      pluginNoticeComponent,
+      progressNotice,
+      repo,
+      version: versionToOpen
+    });
+    if (!archive) {
+      return;
+    }
+    progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);
+    cleanupOrphanedExtractedVaults();
+    const vaultDirectory = extractDemoVaultToFreshFolder({
+      archive,
+      pluginId,
+      version: versionToOpen
+    });
+    window.electron.ipcRenderer.sendSync("vault-open", vaultDirectory, false);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function cleanupOrphanedExtractedVaults() {
+  const extractedVaultsRoot = (0, import_path.join)((0, import_node_os.tmpdir)(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);
+  if (!(0, import_node_fs.existsSync)(extractedVaultsRoot)) {
+    return;
+  }
+  const now = Date.now();
+  for (const entryName of (0, import_node_fs.readdirSync)(extractedVaultsRoot)) {
+    const entryPath = (0, import_path.join)(extractedVaultsRoot, entryName);
+    try {
+      const stats = (0, import_node_fs.statSync)(entryPath);
+      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {
+        continue;
+      }
+      (0, import_node_fs.rmSync)(entryPath, { force: true, recursive: true });
+    } catch {
+    }
+  }
+}
+function extractDemoVaultArchive(archive, targetDirectory) {
+  const originalFs = window.require('node:original-fs');
+  (0, import_desktop_zip_extractor.extractZipArchive)({
+    archive,
+    fileSystem: originalFs,
+    targetDirectory
+  });
+}
+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}-`));
+  extractDemoVaultArchive(archive, uniqueParentDirectory);
+  return (0, import_path.join)(
+    uniqueParentDirectory,
+    (0, import_demo_vault_naming.getDemoVaultFolderName)({
+      pluginId,
+      version
+    })
+  );
+}
+async function resolveDemoVaultArchive(params) {
+  const {
+    pluginId,
+    pluginName,
+    pluginNoticeComponent,
+    progressNotice,
+    repo,
+    version
+  } = params;
+  const archivesDirectory = (0, import_path.join)((0, import_node_os.tmpdir)(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);
+  const archivePath = (0, import_path.join)(archivesDirectory, `${pluginId}-${version}.zip`);
+  if ((0, import_node_fs.existsSync)(archivePath)) {
+    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}/${(0, import_demo_vault_naming.getDemoVaultArchiveFileName)(pluginId)}`;
+  const response = await (0, import_obsidian.requestUrl)({
+    throw: false,
+    url: assetUrl
+  });
+  if (response.status !== HTTP_STATUS_OK) {
+    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);
+    return null;
+  }
+  const archive = import_node_buffer.Buffer.from(response.arrayBuffer);
+  (0, import_node_fs.mkdirSync)(archivesDirectory, { recursive: true });
+  (0, import_node_fs.writeFileSync)(archivePath, archive);
+  return archive;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDemoVault
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/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 { extractZipArchive } from '@mnaoumov/typescript-lib/desktop-zip-extractor';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { compareVersions } from 'compare-versions';\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';\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\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/desktop-demo-vault-opener.d.cts

@@ -0,0 +1,76 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * 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.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 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.
+ *
+ * **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';
+/**
+ * Parameters for {@link openDemoVault}.
+ */
+export interface OpenDemoVaultParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The plugin id, used to locate the GitHub repository, to name the archive asset, and to name the
+     * cached archive and the extracted vault folder.
+     */
+    readonly pluginId: string;
+    /**
+     * The plugin display name, used to label the notices and the version-choice dialog.
+     */
+    readonly pluginName: string;
+    /**
+     * The notice component used to report progress and problems (plugin not in the registry, missing
+     * archive).
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * The currently installed plugin version, offered as one of the version choices.
+     */
+    readonly pluginVersion: string;
+}
+/**
+ * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.
+ *
+ * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise
+ * the user chooses between the latest and the currently-installed version. A progress notice is shown
+ * immediately. The chosen version's archive is downloaded once (then reused from the archive cache),
+ * but a fresh copy is extracted into its own temporary folder on every open — the vault is never reused
+ * across sessions.
+ *
+ * @param params - The {@link OpenDemoVaultParams}.
+ * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has
+ * been reported as not possible (notice shown) or cancelled by the user.
+ */
+export declare function openDemoVault(params: OpenDemoVaultParams): Promise<void>;