obsidian-dev-utils 92.1.0 → 93.0.0

package/dist/lib/cjs/obsidian/components/plugin-notice-component.d.cts

@@ -9,6 +9,35 @@ import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' }
 import { Notice } from 'obsidian';
 import type { ValueProvider } from '../../value-provider.cjs';
 import { ComponentEx } from './component-ex.cjs';
+/**
+ * How a new notice relates to the plugin's current notice — the one occupying the single per-plugin
+ * slot this component keeps.
+ *
+ * Raw `new Notice(...)` calls always pile up, which is rarely what a plugin wants: usually only the
+ * latest message matters. So the slot exists, and this chooses what a new message does with it.
+ */
+export declare enum PluginNoticeMode {
+    /**
+     * Adds the message to the current notice, so both messages stay visible in a single notice — for a
+     * running account of an operation. The countdown restarts, so an appended message is readable for a
+     * full duration rather than inheriting the remains of the current one.
+     *
+     * Falls back to {@link PluginNoticeMode.Replace} when there is no current notice on screen (it was
+     * never shown, or it has since been dismissed).
+     */
+    Append = "append",
+    /**
+     * Hides the current notice and shows this one in its place, so only the latest message is on screen.
+     * This is the default, and the reason the slot exists.
+     */
+    Replace = "replace",
+    /**
+     * Shows the message as its own notice, leaving the current one alone: both are on screen, piled up
+     * like plain `new Notice(...)` calls. A separate notice never replaces, and is never replaced by, a
+     * slot notice; any number of them coexist. They are still hidden together on unload.
+     */
+    Separate = "separate"
+}
 /**
  * The event passed to {@link PluginNoticeComponentShowNoticeOptions.onCloseClick} when the notice's
  * close (X) button is clicked.
@@ -26,10 +55,14 @@ export interface PluginNoticeCloseClickEvent {
  */
 export interface PluginNoticeComponentDelayedNotice extends Disposable {
     /**
-     * Replaces the notice content, re-applying the plugin-name prefix, the interactive-click guard, and
+     * Replaces this handle's message, re-applying the plugin-name prefix, the interactive-click guard, and
      * the Cancel button. Useful for reporting progress. If the delay has not elapsed yet, the new content
      * becomes what is shown once it does.
      *
+     * Only this handle's own message is rewritten: when the notice was joined rather than opened (see
+     * {@link PluginNoticeComponentShowNoticeAfterDelayParams.mode}), the messages already in it are left
+     * alone.
+     *
      * @param content - The new notice content.
      */
     setContent(content: DocumentFragment | string): void;
@@ -60,6 +93,20 @@ export interface PluginNoticeComponentShowNoticeAfterDelayParams {
      * @default `500`
      */
     readonly delayInMilliseconds?: number;
+    /**
+     * How this notice relates to the plugin's current notice — see {@link PluginNoticeMode}.
+     *
+     * {@link PluginNoticeMode.Separate} is worth considering for a long operation: on the default
+     * {@link PluginNoticeMode.Replace} the progress notice takes the shared slot, so any ordinary notice
+     * raised while the operation runs hides it, and the progress the user was watching does not come back.
+     *
+     * Whichever mode is used, the returned handle owns only ITS message: updating the content rewrites
+     * that message alone, and disposing takes away only that message when the notice was already on
+     * screen (a notice this handle opened is hidden as a whole).
+     *
+     * @default {@link PluginNoticeMode.Replace}
+     */
+    readonly mode?: PluginNoticeMode;
 }
 /**
  * Options for {@link PluginNoticeComponent.showNotice}.
@@ -77,18 +124,17 @@ export interface PluginNoticeComponentShowNoticeOptions {
      */
     readonly isPermanent?: boolean;
     /**
-     * Whether the notice occupies the single per-plugin reusable slot.
-     *
-     * A reusable notice takes the shared slot: the next reusable notice hides it, and it is hidden on unload.
-     * A non-reusable (standalone) notice is not placed in the slot — it never hides, and is never hidden by, a
-     * reusable notice; multiple standalone notices coexist. Standalone notices are still hidden together on unload.
+     * How this notice relates to the plugin's current notice — see {@link PluginNoticeMode}.
      *
-     * A permanent notice must be reusable ({@link PluginNoticeComponentShowNoticeOptions.isPermanent} implies
-     * `isReusable`); passing `isReusable: false` together with `isPermanent: true` throws.
+     * A permanent notice cannot be {@link PluginNoticeMode.Separate} (it needs the shared slot it is
+     * tracked in), and a notice that does not hide on click must be
+     * {@link PluginNoticeMode.Separate} (so a later notice never silently replaces it); either
+     * contradiction throws.
      *
-     * @default `true`
+     * @default {@link PluginNoticeMode.Replace}, or {@link PluginNoticeMode.Separate} when
+     * {@link PluginNoticeComponentShowNoticeOptions.shouldHideOnClick} is `false`
      */
-    readonly isReusable?: boolean;
+    readonly mode?: PluginNoticeMode;
     /**
      * A callback invoked when the user clicks the close (X) button, before the notice is hidden. Call
      * {@link PluginNoticeCloseClickEvent.cancel} on the event to cancel the close and keep the notice
@@ -113,9 +159,10 @@ export interface PluginNoticeComponentShowNoticeOptions {
      * {@link PluginNoticeComponentShowNoticeOptions.shouldShowCloseButton} and
      * {@link PluginNoticeComponentShowNoticeOptions.onCloseClick}).
      *
-     * A `shouldHideOnClick: false` notice is shown with an infinite duration and is standalone (implies
-     * {@link PluginNoticeComponentShowNoticeOptions.isReusable} `= false`), so a later notice never
-     * silently replaces it; passing `isReusable: true` together with `shouldHideOnClick: false` throws.
+     * A `shouldHideOnClick: false` notice is shown with an infinite duration and stands on its own
+     * (implies {@link PluginNoticeMode.Separate}), so a later notice never silently replaces it; passing
+     * any other {@link PluginNoticeComponentShowNoticeOptions.mode} together with `shouldHideOnClick: false`
+     * throws.
      *
      * @default `true`
      */
@@ -151,7 +198,9 @@ interface PluginNoticeComponentConstructorParams {
     readonly pluginName: string;
 }
 /**
- * Manages showing plugin notices. Automatically hides the previous notice when a new one is shown.
+ * Manages showing plugin notices. By default a new notice hides the previous one, so only the latest
+ * message is on screen; {@link PluginNoticeComponentShowNoticeOptions.mode} chooses otherwise — see
+ * {@link PluginNoticeMode}.
  */
 export declare class PluginNoticeComponent extends ComponentEx {
     /**
@@ -221,6 +270,24 @@ export declare class PluginNoticeComponent extends ComponentEx {
      * @param params - The parameters.
      */
     private appendCloseButton;
+    /**
+     * Adds a message to the notice currently in the per-plugin slot, so both messages stay on screen in a
+     * single notice.
+     *
+     * The appended message carries no plugin-name prefix — the notice already opens with one, and
+     * repeating it on every line reads as noise. It is wrapped like any other notice content, so a link or
+     * button inside it still keeps the notice open when clicked.
+     *
+     * Appending restarts the notice's countdown ({@link Notice.setAutoHide}), so the new message gets a
+     * full duration instead of inheriting what was left of the current one — a line appended a moment
+     * before the notice expires would otherwise flash and vanish.
+     *
+     * @param params - The parameters.
+     * @returns The {@link PluginNoticeComponentShownNotice} describing the joined notice, or `null` when
+     * there is nothing on screen to append to — the slot is empty, or its notice has since been dismissed
+     * — and the caller should show a new notice instead.
+     */
+    private appendToCurrentNotice;
     /**
      * Builds the message for a delayed notice: the resolved content, optionally followed by a Cancel
      * button that aborts the provided controller when clicked.
@@ -236,7 +303,7 @@ export declare class PluginNoticeComponent extends ComponentEx {
      * input, etc.) and stops them there, so the element's own handler still runs but the notice stays.
      *
      * @param params - The parameters.
-     * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.
+     * @returns The {@link PluginNoticeComponentNoticeContent} holding the wrapped notice content.
      */
     private buildNoticeContent;
     /**
@@ -272,12 +339,14 @@ export declare class PluginNoticeComponent extends ComponentEx {
     private installUserClickTracking;
     private setPermanentNotice;
     /**
-     * Shows a notice with the given duration. A reusable notice replaces the current reusable notice (and
-     * is optionally registered as this plugin's permanent notice); a standalone notice is tracked
-     * separately, leaving the reusable slot untouched.
+     * Shows a notice with the given duration, placing it according to its {@link PluginNoticeMode}: a
+     * {@link PluginNoticeMode.Replace} notice takes the per-plugin slot (hiding whatever was in it, and
+     * optionally registering as this plugin's permanent notice), an {@link PluginNoticeMode.Append} one
+     * joins the notice already in the slot, and a {@link PluginNoticeMode.Separate} one is tracked on its
+     * own, leaving the slot untouched.
      *
      * @param params - The parameters.
-     * @returns The created notice.
+     * @returns The {@link PluginNoticeComponentShownNotice} describing where the message ended up.
      */
     private showNoticeWithDuration;
     /**

package/dist/lib/cjs/obsidian/demo-vault-helper-settings.cjs

@@ -0,0 +1,120 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  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
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  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 __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_helper_settings_exports = {};
+module.exports = __toCommonJS(demo_vault_helper_settings_exports);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * The `demo-vault-helper` plugin's own settings — the contract between the demo-vault packaging step
+ * and the bootstrap that runs inside the opened vault.
+ *
+ * The helper has to name the plugin the vault demonstrates, and nothing inside the vault reliably says
+ * which one that is: the plugin folders also hold the helper itself, CodeScript Toolkit once the
+ * bootstrap has installed it, and anything a demo note's prerequisites installed, so counting them
+ * guesses (and guesses differently on a re-open). The packaging step, on the other hand, KNOWS — it
+ * reads the plugin's `manifest.json` to name the archive — so it writes the id down here and the
+ * bootstrap simply reads it.
+ *
+ * The marker and the helper binary are written together, by the same `obsidian-dev-utils` version, into
+ * the same archive, so the two can never disagree.
+ *
+ * Kept free of `obsidian` imports on purpose: the packaging step ({@link archivePluginDemoVault}) runs
+ * under Node, where the `obsidian` module does not exist.
+ */
+/**
+ * The `demo-vault-helper` plugin's `data.json`, written into the demo vault at packaging time.
+ */
+export interface DemoVaultHelperSettings {
+    /**
+     * The id of the plugin the vault demonstrates, taken from that plugin's `manifest.json`.
+     */
+    readonly demoedPluginId: string;
+}

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

@@ -126,7 +126,7 @@ __export(demo_vault_helper_exports, {
 module.exports = __toCommonJS(demo_vault_helper_exports);
 var import_obsidian = require('obsidian');
 var import_path = require('../path.cjs');
-var import_type_guards = require('../type-guards.cjs');
+var import_string = require('../string.cjs');
 var import_community_plugins = require('./community-plugins.cjs');
 const CODE_SCRIPT_TOOLKIT_PLUGIN_ID = "fix-require-modules";
 const CODE_SCRIPT_TOOLKIT_MODULES_ROOT = "_assets/CodeScriptToolkit";
@@ -139,6 +139,8 @@ const CODE_SCRIPT_TOOLKIT_SETTINGS = {
 };
 const DEMO_VAULT_HELPER_PLUGIN_ID = "demo-vault-helper";
 const PLUGINS_FOLDER_NAME = "plugins";
+const DATA_JSON_FILE_NAME = "data.json";
+const INVALID_DEMO_VAULT_ERROR_MESSAGE = "Invalid demo vault";
 const OPEN_DEMO_VAULT_COMMAND_NAME = "Open demo vault";
 const SANDBOX_NOTICE_DURATION_IN_MILLISECONDS = 0;
 async function bootstrapDemoVault(params) {
@@ -159,23 +161,17 @@ async function bootstrapDemoVault(params) {
   }
   showSandboxNotice(app, demoedPluginId);
 }
-function buildSandboxNoticeFragment(pluginName, basePath) {
+function buildSandboxNoticeFragment(pluginName) {
   return createFragment((fragment) => {
-    if (pluginName === null) {
-      fragment.appendText("This is a demo vault.");
-    } else {
-      fragment.appendText("This is a demo vault for ");
-      fragment.createEl("b", { text: pluginName });
-      fragment.appendText(".");
-    }
-    fragment.appendText(" It is a temporary sandbox");
-    if (basePath !== null) {
-      fragment.appendText(" at ");
-      fragment.createEl("code", { text: basePath });
-    }
-    fragment.appendText(", cleaned up automatically about a day after you last use it \u2014 copy anything you want to keep into your own vault. Running ");
-    fragment.createEl("b", { text: pluginName === null ? OPEN_DEMO_VAULT_COMMAND_NAME : `${pluginName}: ${OPEN_DEMO_VAULT_COMMAND_NAME}` });
-    fragment.appendText(" again creates a new copy with the latest plugin version, so your notes will not appear in it.");
+    fragment.appendText("This is a demo vault for ");
+    fragment.createEl("b", { text: pluginName });
+    fragment.appendText(".");
+    fragment.createEl("br");
+    fragment.appendText("It is a temporary sandbox, cleaned up automatically about a day after you last use it.");
+    fragment.createEl("br");
+    fragment.appendText("Executing ");
+    fragment.createEl("b", { text: `${pluginName}: ${OPEN_DEMO_VAULT_COMMAND_NAME}` });
+    fragment.appendText(" command again creates a new copy with the latest plugin version, so your notes will not appear in it.");
   });
 }
 async function ensureInvocableScriptsFolder(app) {
@@ -185,27 +181,30 @@ async function ensureInvocableScriptsFolder(app) {
   }
 }
 async function getDemoedPluginId(app) {
-  const pluginsFolderPath = (0, import_path.join)(app.vault.configDir, PLUGINS_FOLDER_NAME);
-  if (!await app.vault.adapter.exists(pluginsFolderPath)) {
-    return null;
+  const settingsPath = (0, import_path.join)(app.vault.configDir, PLUGINS_FOLDER_NAME, DEMO_VAULT_HELPER_PLUGIN_ID, DATA_JSON_FILE_NAME);
+  if (!await app.vault.adapter.exists(settingsPath)) {
+    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE);
   }
-  const listedFiles = await app.vault.adapter.list(pluginsFolderPath);
-  const demoedPluginIds = listedFiles.folders.map((folderPath) => (0, import_path.basename)(folderPath)).filter((pluginId) => pluginId !== DEMO_VAULT_HELPER_PLUGIN_ID);
-  return demoedPluginIds.length === 1 ? (0, import_type_guards.ensureNonNullable)(demoedPluginIds[0]) : null;
-}
-function getVaultBasePath(app) {
-  return isBasePathAdapter(app.vault.adapter) ? app.vault.adapter.getBasePath() : null;
-}
-function isBasePathAdapter(adapter) {
-  return typeof Reflect.get(adapter, "getBasePath") === "function";
+  let parsed;
+  try {
+    parsed = JSON.parse(await app.vault.adapter.read(settingsPath));
+  } catch (error) {
+    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE, { cause: error });
+  }
+  const demoedPluginId = parsed?.demoedPluginId;
+  if (typeof demoedPluginId !== "string" || demoedPluginId === import_string.EMPTY) {
+    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE);
+  }
+  return demoedPluginId;
 }
 function showSandboxNotice(app, demoedPluginId) {
-  const pluginName = demoedPluginId === null ? null : app.plugins.manifests[demoedPluginId]?.name ?? demoedPluginId;
-  const fragment = buildSandboxNoticeFragment(pluginName, getVaultBasePath(app));
+  const pluginName = app.plugins.manifests[demoedPluginId]?.name ?? demoedPluginId;
+  const fragment = buildSandboxNoticeFragment(pluginName);
+  app.setting.close();
   new import_obsidian.Notice(fragment, SANDBOX_NOTICE_DURATION_IN_MILLISECONDS);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   bootstrapDemoVault
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/demo-vault-helper.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Bootstraps a demo vault by installing, configuring, and enabling CodeScript Toolkit.\n *\n * A plugin's demo vault showcases the plugin through notes whose `code-button`s run TypeScript via\n * CodeScript Toolkit. A demo vault that does not itself ship CodeScript Toolkit therefore needs it\n * installed, configured, and enabled before those buttons work. {@link bootstrapDemoVault} does exactly\n * that with no committed CodeScript Toolkit config and no manual setup, so it can be driven from a tiny\n * committed bootstrap plugin (`demo-vault-helper`) that is injected into every demo vault at release\n * time.\n *\n * It writes CodeScript Toolkit's settings BEFORE enabling it, so the plugin loads already configured \u2014\n * no reload. CodeScript Toolkit then runs the vault's `startup.ts` (via its `startupScriptPath`\n * setting), which is where each vault opens its start note and does any plugin-specific setup.\n *\n * It also creates CodeScript Toolkit's invocable-scripts folder if it is missing, so every demo vault\n * has the same layout even when the vault ships no invocable scripts \u2014 the vaults themselves commit no\n * empty folder for it.\n *\n * Finally it raises the sandbox notice explaining that the opened vault is a throwaway copy, so a user\n * who writes their own notes in it is never surprised by them being absent from the next copy.\n */\n\nimport type {\n  App,\n  DataAdapter\n} from 'obsidian';\n\nimport { Notice } from 'obsidian';\n\nimport {\n  basename,\n  join\n} from '../path.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport {\n  configureCommunityPlugin,\n  ConfigureCommunityPluginResult,\n  disableCommunityPlugin,\n  enableCommunityPlugin,\n  installCommunityPlugin\n} from './community-plugins.ts';\n\n/**\n * Parameters for {@link bootstrapDemoVault}.\n */\nexport interface BootstrapDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n}\n\n/**\n * The slice of the desktop vault adapter that knows the vault's absolute path.\n */\ninterface BasePathAdapter {\n  /**\n   * Returns the absolute path of the vault folder.\n   */\n  getBasePath(): string;\n}\n\n/**\n * CodeScript Toolkit's settings, written into its `data.json` before it is enabled.\n */\ninterface CodeScriptToolkitSettings {\n  /**\n   * The YAML frontmatter merged into every `code-button` block's own config, used here to turn the\n   * source viewer on for every button in every demo vault without editing a single note.\n   */\n  readonly defaultCodeButtonConfig: string;\n\n  /**\n   * The folder (under {@link CodeScriptToolkitSettings.modulesRoot}) holding invocable scripts.\n   */\n  readonly invocableScriptsFolder: string;\n\n  /**\n   * The vault-relative folder that `require('/\u2026')` resolves module paths against.\n   */\n  readonly modulesRoot: string;\n\n  /**\n   * Whether CodeScript Toolkit handles `obsidian://` protocol URLs.\n   */\n  readonly shouldHandleProtocolUrls: boolean;\n\n  /**\n   * The path (under {@link CodeScriptToolkitSettings.modulesRoot}) of the script run on load.\n   */\n  readonly startupScriptPath: string;\n}\n\nconst CODE_SCRIPT_TOOLKIT_PLUGIN_ID = 'fix-require-modules';\nconst CODE_SCRIPT_TOOLKIT_MODULES_ROOT = '_assets/CodeScriptToolkit';\nconst CODE_SCRIPT_TOOLKIT_SETTINGS: CodeScriptToolkitSettings = {\n  defaultCodeButtonConfig: '---\\nsourceVisibility: collapsed\\n---',\n  invocableScriptsFolder: 'Invocables',\n  modulesRoot: CODE_SCRIPT_TOOLKIT_MODULES_ROOT,\n  shouldHandleProtocolUrls: true,\n  startupScriptPath: 'startup.ts'\n};\n\nconst DEMO_VAULT_HELPER_PLUGIN_ID = 'demo-vault-helper';\nconst PLUGINS_FOLDER_NAME = 'plugins';\nconst OPEN_DEMO_VAULT_COMMAND_NAME = 'Open demo vault';\n// `0` asks Obsidian to keep the notice up until the user clicks it \u2014 the same treatment Obsidian gives\n// Its own sandbox-vault notice, and what the demo-vault notice is modelled on.\nconst SANDBOX_NOTICE_DURATION_IN_MILLISECONDS = 0;\n\n/**\n * Bootstraps a demo vault so its notes' `code-button`s work with no manual setup: installs CodeScript\n * Toolkit from the community store (if it is not already installed), writes its settings, then enables\n * it \u2014 writing the settings BEFORE enabling so a fresh enable loads it already configured, with no\n * reload. If CodeScript Toolkit is already enabled but the settings just changed, it is reloaded\n * (disabled then enabled) so it re-reads `data.json`; when the settings were already in place, nothing is\n * reloaded (so a routine vault re-open does not re-run CodeScript Toolkit's startup). CodeScript Toolkit\n * then runs the vault's `startup.ts`. Finally it raises the sandbox notice describing the opened vault\n * as a throwaway copy.\n *\n * @param params - The {@link BootstrapDemoVaultParams}.\n * @returns A {@link Promise} that resolves once CodeScript Toolkit is installed, configured, and enabled\n * and the sandbox notice has been shown.\n */\nexport async function bootstrapDemoVault(params: BootstrapDemoVaultParams): Promise<void> {\n  const { app } = params;\n  // Resolved BEFORE CodeScript Toolkit is installed. At release time the vault carries exactly two\n  // Plugin folders \u2014 this helper and the plugin being demonstrated \u2014 so dropping the helper leaves the\n  // Demonstrated one. Reading the folder later would also see CodeScript Toolkit and anything a demo\n  // Note's prerequisites installed, leaving no way to tell which plugin the vault is for.\n  const demoedPluginId = await getDemoedPluginId(app);\n  await installCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n  const result = await configureCommunityPlugin({\n    app,\n    pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,\n    settings: CODE_SCRIPT_TOOLKIT_SETTINGS\n  });\n  await ensureInvocableScriptsFolder(app);\n\n  if (!app.plugins.enabledPlugins.has(CODE_SCRIPT_TOOLKIT_PLUGIN_ID)) {\n    await enableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n  } else if (result === ConfigureCommunityPluginResult.Success) {\n    // Already enabled with stale settings \u2014 reload so CodeScript Toolkit re-reads the freshly written data.json.\n    await disableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n    await enableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n  }\n\n  showSandboxNotice(app, demoedPluginId);\n}\n\n// Builds the sandbox notice content: what this vault is, where it lives, how long it lives, and why\n// Re-running the command produces a vault without the notes just written here.\n//\n// Every claim has to stay true of the opener (`desktop-demo-vault-opener.ts`): it extracts a FRESH copy\n// Into its own folder on every open, and deletes extracted folders older than a day on each later open.\n// So the vault is a temporary sandbox \u2014 it must never be described as a place work can be left.\nfunction buildSandboxNoticeFragment(pluginName: null | string, basePath: null | string): DocumentFragment {\n  return createFragment((fragment) => {\n    if (pluginName === null) {\n      fragment.appendText('This is a demo vault.');\n    } else {\n      fragment.appendText('This is a demo vault for ');\n      fragment.createEl('b', { text: pluginName });\n      fragment.appendText('.');\n    }\n\n    fragment.appendText(' It is a temporary sandbox');\n    if (basePath !== null) {\n      fragment.appendText(' at ');\n      fragment.createEl('code', { text: basePath });\n    }\n    fragment.appendText(', cleaned up automatically about a day after you last use it \u2014 copy anything you want to keep into your own vault. Running ');\n    fragment.createEl('b', { text: pluginName === null ? OPEN_DEMO_VAULT_COMMAND_NAME : `${pluginName}: ${OPEN_DEMO_VAULT_COMMAND_NAME}` });\n    fragment.appendText(' again creates a new copy with the latest plugin version, so your notes will not appear in it.');\n  });\n}\n\n// Creates CodeScript Toolkit's invocable-scripts folder (under `modulesRoot`) if it is missing.\n// Every demo vault then has the same CodeScript Toolkit layout even when it ships no invocable scripts.\n// The committed vault therefore carries no otherwise-empty placeholder folder.\nasync function ensureInvocableScriptsFolder(app: App): Promise<void> {\n  const invocableScriptsFolderPath = join(CODE_SCRIPT_TOOLKIT_MODULES_ROOT, CODE_SCRIPT_TOOLKIT_SETTINGS.invocableScriptsFolder);\n  if (!await app.vault.adapter.exists(invocableScriptsFolderPath)) {\n    await app.vault.adapter.mkdir(invocableScriptsFolderPath);\n  }\n}\n\n// Identifies the plugin the vault demonstrates as the only installed plugin that is not this helper.\n// Call it BEFORE anything else is installed (see `bootstrapDemoVault`). Any other count \u2014 a vault\n// Opened after the plugin folder was hand-edited, or one that ships nothing but the helper \u2014 is\n// Ambiguous, and an ambiguous answer becomes generic notice wording rather than a wrong plugin name.\nasync function getDemoedPluginId(app: App): Promise<null | string> {\n  const pluginsFolderPath = join(app.vault.configDir, PLUGINS_FOLDER_NAME);\n  if (!await app.vault.adapter.exists(pluginsFolderPath)) {\n    return null;\n  }\n\n  const listedFiles = await app.vault.adapter.list(pluginsFolderPath);\n  const demoedPluginIds = listedFiles.folders\n    .map((folderPath) => basename(folderPath))\n    .filter((pluginId) => pluginId !== DEMO_VAULT_HELPER_PLUGIN_ID);\n  return demoedPluginIds.length === 1 ? ensureNonNullable(demoedPluginIds[0]) : null;\n}\n\n// Resolves the vault's absolute path for the notice. Only the desktop adapter knows it: `DataAdapter`\n// Does not declare `getBasePath`, and `FileSystemAdapter` is a desktop-only class that is not guaranteed\n// To exist elsewhere \u2014 so `instanceof` would throw rather than answer. It is reached instead through a\n// Narrow hand-declared shape plus a runtime check (see L9). An adapter without it yields no path, and\n// The notice then omits the sentence naming it rather than rendering `undefined`.\nfunction getVaultBasePath(app: App): null | string {\n  return isBasePathAdapter(app.vault.adapter) ? app.vault.adapter.getBasePath() : null;\n}\n\nfunction isBasePathAdapter(adapter: DataAdapter): adapter is BasePathAdapter & DataAdapter {\n  return typeof Reflect.get(adapter, 'getBasePath') === 'function';\n}\n\n// Tells the user this vault is a sandbox, using Obsidian's own sandbox-vault treatment: an infinite\n// Duration, dismissed by clicking it. Raised last, so it is the newest notice on screen once\n// CodeScript Toolkit's startup script has done its own work.\nfunction showSandboxNotice(app: App, demoedPluginId: null | string): void {\n  const pluginName = demoedPluginId === null ? null : app.plugins.manifests[demoedPluginId]?.name ?? demoedPluginId;\n  const fragment = buildSandboxNoticeFragment(pluginName, getVaultBasePath(app));\n  new Notice(fragment, SANDBOX_NOTICE_DURATION_IN_MILLISECONDS);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/demo-vault-helper.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Bootstraps a demo vault by installing, configuring, and enabling CodeScript Toolkit.\n *\n * A plugin's demo vault showcases the plugin through notes whose `code-button`s run TypeScript via\n * CodeScript Toolkit. A demo vault that does not itself ship CodeScript Toolkit therefore needs it\n * installed, configured, and enabled before those buttons work. {@link bootstrapDemoVault} does exactly\n * that with no committed CodeScript Toolkit config and no manual setup, so it can be driven from a tiny\n * committed bootstrap plugin (`demo-vault-helper`) that is injected into every demo vault at release\n * time.\n *\n * The plugin the vault demonstrates is read from the helper's own `data.json`, written by the packaging\n * step ({@link DemoVaultHelperSettings}); a vault without that marker is refused as not a demo vault.\n *\n * It writes CodeScript Toolkit's settings BEFORE enabling it, so the plugin loads already configured \u2014\n * no reload. CodeScript Toolkit then runs the vault's `startup.ts` (via its `startupScriptPath`\n * setting), which is where each vault opens its start note and does any plugin-specific setup.\n *\n * It also creates CodeScript Toolkit's invocable-scripts folder if it is missing, so every demo vault\n * has the same layout even when the vault ships no invocable scripts \u2014 the vaults themselves commit no\n * empty folder for it.\n *\n * Finally it raises the sandbox notice explaining that the opened vault is a throwaway copy, so a user\n * who writes their own notes in it is never surprised by them being absent from the next copy. Settings\n * is closed first, so the notice lands in the vault's main window rather than in the settings popout.\n */\n\nimport type { App } from 'obsidian';\n\nimport { Notice } from 'obsidian';\n\nimport type { DemoVaultHelperSettings } from './demo-vault-helper-settings.ts';\n\nimport { join } from '../path.ts';\nimport { EMPTY } from '../string.ts';\nimport {\n  configureCommunityPlugin,\n  ConfigureCommunityPluginResult,\n  disableCommunityPlugin,\n  enableCommunityPlugin,\n  installCommunityPlugin\n} from './community-plugins.ts';\n\n/**\n * Parameters for {@link bootstrapDemoVault}.\n */\nexport interface BootstrapDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n}\n\n/**\n * CodeScript Toolkit's settings, written into its `data.json` before it is enabled.\n */\ninterface CodeScriptToolkitSettings {\n  /**\n   * The YAML frontmatter merged into every `code-button` block's own config, used here to turn the\n   * source viewer on for every button in every demo vault without editing a single note.\n   */\n  readonly defaultCodeButtonConfig: string;\n\n  /**\n   * The folder (under {@link CodeScriptToolkitSettings.modulesRoot}) holding invocable scripts.\n   */\n  readonly invocableScriptsFolder: string;\n\n  /**\n   * The vault-relative folder that `require('/\u2026')` resolves module paths against.\n   */\n  readonly modulesRoot: string;\n\n  /**\n   * Whether CodeScript Toolkit handles `obsidian://` protocol URLs.\n   */\n  readonly shouldHandleProtocolUrls: boolean;\n\n  /**\n   * The path (under {@link CodeScriptToolkitSettings.modulesRoot}) of the script run on load.\n   */\n  readonly startupScriptPath: string;\n}\n\nconst CODE_SCRIPT_TOOLKIT_PLUGIN_ID = 'fix-require-modules';\nconst CODE_SCRIPT_TOOLKIT_MODULES_ROOT = '_assets/CodeScriptToolkit';\nconst CODE_SCRIPT_TOOLKIT_SETTINGS: CodeScriptToolkitSettings = {\n  defaultCodeButtonConfig: '---\\nsourceVisibility: collapsed\\n---',\n  invocableScriptsFolder: 'Invocables',\n  modulesRoot: CODE_SCRIPT_TOOLKIT_MODULES_ROOT,\n  shouldHandleProtocolUrls: true,\n  startupScriptPath: 'startup.ts'\n};\n\nconst DEMO_VAULT_HELPER_PLUGIN_ID = 'demo-vault-helper';\nconst PLUGINS_FOLDER_NAME = 'plugins';\nconst DATA_JSON_FILE_NAME = 'data.json';\nconst INVALID_DEMO_VAULT_ERROR_MESSAGE = 'Invalid demo vault';\nconst OPEN_DEMO_VAULT_COMMAND_NAME = 'Open demo vault';\n// `0` asks Obsidian to keep the notice up until the user clicks it \u2014 the same treatment Obsidian gives\n// Its own sandbox-vault notice, and what the demo-vault notice is modelled on.\nconst SANDBOX_NOTICE_DURATION_IN_MILLISECONDS = 0;\n\n/**\n * Bootstraps a demo vault so its notes' `code-button`s work with no manual setup: installs CodeScript\n * Toolkit from the community store (if it is not already installed), writes its settings, then enables\n * it \u2014 writing the settings BEFORE enabling so a fresh enable loads it already configured, with no\n * reload. If CodeScript Toolkit is already enabled but the settings just changed, it is reloaded\n * (disabled then enabled) so it re-reads `data.json`; when the settings were already in place, nothing is\n * reloaded (so a routine vault re-open does not re-run CodeScript Toolkit's startup). CodeScript Toolkit\n * then runs the vault's `startup.ts`. Finally it closes Settings (so the notice cannot be raised inside\n * the settings popout) and raises the sandbox notice describing the opened vault as a throwaway copy.\n *\n * @param params - The {@link BootstrapDemoVaultParams}.\n * @returns A {@link Promise} that resolves once CodeScript Toolkit is installed, configured, and enabled\n * and the sandbox notice has been shown.\n */\nexport async function bootstrapDemoVault(params: BootstrapDemoVaultParams): Promise<void> {\n  const { app } = params;\n  // Resolved first, so a vault that is not a demo vault is refused before anything is installed into it.\n  const demoedPluginId = await getDemoedPluginId(app);\n  await installCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n  const result = await configureCommunityPlugin({\n    app,\n    pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,\n    settings: CODE_SCRIPT_TOOLKIT_SETTINGS\n  });\n  await ensureInvocableScriptsFolder(app);\n\n  if (!app.plugins.enabledPlugins.has(CODE_SCRIPT_TOOLKIT_PLUGIN_ID)) {\n    await enableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n  } else if (result === ConfigureCommunityPluginResult.Success) {\n    // Already enabled with stale settings \u2014 reload so CodeScript Toolkit re-reads the freshly written data.json.\n    await disableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n    await enableCommunityPlugin({ app, pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID });\n  }\n\n  showSandboxNotice(app, demoedPluginId);\n}\n\n// Builds the sandbox notice content: what this vault is, where it lives, how long it lives, and why\n// Re-running the command produces a vault without the notes just written here.\n//\n// Every claim has to stay true of the opener (`desktop-demo-vault-opener.ts`): it extracts a FRESH copy\n// Into its own folder on every open, and deletes extracted folders older than a day on each later open.\n// So the vault is a temporary sandbox \u2014 it must never be described as a place work can be left.\nfunction buildSandboxNoticeFragment(pluginName: string): DocumentFragment {\n  return createFragment((fragment) => {\n    fragment.appendText('This is a demo vault for ');\n    fragment.createEl('b', { text: pluginName });\n    fragment.appendText('.');\n\n    fragment.createEl('br');\n    fragment.appendText('It is a temporary sandbox, cleaned up automatically about a day after you last use it.');\n\n    fragment.createEl('br');\n    fragment.appendText('Executing ');\n    fragment.createEl('b', { text: `${pluginName}: ${OPEN_DEMO_VAULT_COMMAND_NAME}` });\n    fragment.appendText(' command again creates a new copy with the latest plugin version, so your notes will not appear in it.');\n  });\n}\n\n// Creates CodeScript Toolkit's invocable-scripts folder (under `modulesRoot`) if it is missing.\n// Every demo vault then has the same CodeScript Toolkit layout even when it ships no invocable scripts.\n// The committed vault therefore carries no otherwise-empty placeholder folder.\nasync function ensureInvocableScriptsFolder(app: App): Promise<void> {\n  const invocableScriptsFolderPath = join(CODE_SCRIPT_TOOLKIT_MODULES_ROOT, CODE_SCRIPT_TOOLKIT_SETTINGS.invocableScriptsFolder);\n  if (!await app.vault.adapter.exists(invocableScriptsFolderPath)) {\n    await app.vault.adapter.mkdir(invocableScriptsFolderPath);\n  }\n}\n\n// Reads the plugin the vault demonstrates out of this helper's own `data.json`, written by the\n// Packaging step (see `DemoVaultHelperSettings`). A vault without a readable marker was not produced by\n// That step \u2014 hand-assembled, or unpacked from something that is not a demo vault \u2014 so it is refused\n// Rather than bootstrapped against a guess.\nasync function getDemoedPluginId(app: App): Promise<string> {\n  const settingsPath = join(app.vault.configDir, PLUGINS_FOLDER_NAME, DEMO_VAULT_HELPER_PLUGIN_ID, DATA_JSON_FILE_NAME);\n  if (!await app.vault.adapter.exists(settingsPath)) {\n    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE);\n  }\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(await app.vault.adapter.read(settingsPath));\n  } catch (error) {\n    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE, { cause: error });\n  }\n\n  const demoedPluginId = (parsed as null | Partial<DemoVaultHelperSettings>)?.demoedPluginId;\n  if (typeof demoedPluginId !== 'string' || demoedPluginId === EMPTY) {\n    throw new Error(INVALID_DEMO_VAULT_ERROR_MESSAGE);\n  }\n  return demoedPluginId;\n}\n\n// Tells the user this vault is a sandbox, using Obsidian's own sandbox-vault treatment: an infinite\n// Duration, dismissed by clicking it. Raised last, so it is the newest notice on screen once\n// CodeScript Toolkit's startup script has done its own work.\n//\n// A `Notice` is built inside whatever window is active at that moment, and Settings is a POPOUT WINDOW\n// (verified on 1.13.6) that becomes the active one while it is open \u2014 so a notice raised then would be\n// Created in the settings window and vanish with it. Settings is therefore closed first: Obsidian hands\n// The main window back as the popout goes away (synchronously, before the notice is built), and a user\n// Who has just opened a demo vault wants to see the vault rather than a settings window anyway. Closing\n// An already-closed Settings is a no-op, so no open-state probe is needed.\nfunction showSandboxNotice(app: App, demoedPluginId: string): void {\n  const pluginName = app.plugins.manifests[demoedPluginId]?.name ?? demoedPluginId;\n  const fragment = buildSandboxNoticeFragment(pluginName);\n  app.setting.close();\n  new Notice(fragment, SANDBOX_NOTICE_DURATION_IN_MILLISECONDS);\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -11,6 +11,9 @@
  * committed bootstrap plugin (`demo-vault-helper`) that is injected into every demo vault at release
  * time.
  *
+ * The plugin the vault demonstrates is read from the helper's own `data.json`, written by the packaging
+ * step ({@link DemoVaultHelperSettings}); a vault without that marker is refused as not a demo vault.
+ *
  * It writes CodeScript Toolkit's settings BEFORE enabling it, so the plugin loads already configured —
  * no reload. CodeScript Toolkit then runs the vault's `startup.ts` (via its `startupScriptPath`
  * setting), which is where each vault opens its start note and does any plugin-specific setup.
@@ -20,7 +23,8 @@
  * empty folder for it.
  *
  * Finally it raises the sandbox notice explaining that the opened vault is a throwaway copy, so a user
- * who writes their own notes in it is never surprised by them being absent from the next copy.
+ * who writes their own notes in it is never surprised by them being absent from the next copy. Settings
+ * is closed first, so the notice lands in the vault's main window rather than in the settings popout.
  */
 import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
 /**
@@ -39,8 +43,8 @@ export interface BootstrapDemoVaultParams {
  * reload. If CodeScript Toolkit is already enabled but the settings just changed, it is reloaded
  * (disabled then enabled) so it re-reads `data.json`; when the settings were already in place, nothing is
  * reloaded (so a routine vault re-open does not re-run CodeScript Toolkit's startup). CodeScript Toolkit
- * then runs the vault's `startup.ts`. Finally it raises the sandbox notice describing the opened vault
- * as a throwaway copy.
+ * then runs the vault's `startup.ts`. Finally it closes Settings (so the notice cannot be raised inside
+ * the settings popout) and raises the sandbox notice describing the opened vault as a throwaway copy.
  *
  * @param params - The {@link BootstrapDemoVaultParams}.
  * @returns A {@link Promise} that resolves once CodeScript Toolkit is installed, configured, and enabled