@mnaoumov/obsidian-dev-toolkit 2.1.0 → 3.0.0

package/dist/lib/cjs/test-runners/wdio-obsidian.d.cts

@@ -0,0 +1,199 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * End-to-end tests with `wdio-obsidian-service`: WebdriverIO drives a sandboxed copy of Obsidian, downloaded per
+ * version into a cache, with the plugin installed into a copy of the test vault.
+ *
+ * {@link defineWdioObsidianConfig} derives the `wdio.conf.mts` from the project's layout, and
+ * {@link testEndToEndWithWdioObsidian} is the `test:e2e` script: a production build, then `wdio run`.
+ *
+ * The config is typed structurally rather than through `@wdio/types`, so this module costs a project that does not
+ * use WebdriverIO nothing, and the returned object is assignable to `WebdriverIO.Config` in one that does.
+ */
+/**
+ * The per-test timeout {@link defineWdioObsidianConfig} gives mocha by default, in milliseconds. Obsidian is
+ * started once per spec file, which a single test's budget has to absorb.
+ */
+export declare const DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS = 60000;
+/**
+ * The config files {@link testEndToEndWithWdioObsidian} looks for, in order.
+ */
+export declare const WDIO_CONFIG_FILE_NAMES: readonly string[];
+/**
+ * Options for {@link defineWdioObsidianConfig}.
+ */
+export interface DefineWdioObsidianConfigOptions {
+    /**
+     * The Obsidian app versions to test, one capability each: a version such as `1.8.10`, `latest`, `latest-beta`, or
+     * `earliest` (the `minAppVersion` of `manifest.json`). Defaults to `['latest']`; `['earliest', 'latest']` tests
+     * both ends of the supported range.
+     */
+    readonly appVersions?: readonly string[];
+    /**
+     * The folder Obsidian versions are downloaded into, relative to the project root. Defaults to `.obsidian-cache`,
+     * which belongs in `.gitignore`.
+     */
+    readonly cacheFolder?: string;
+    /**
+     * The Obsidian installer (Electron) version, `earliest` or `latest` compatible with each app version, or an exact
+     * one. Defaults to the service's own choice.
+     */
+    readonly installerVersion?: string;
+    /**
+     * How many Obsidian instances run in parallel. Defaults to WebdriverIO's.
+     */
+    readonly maxInstances?: number;
+    /**
+     * The folder holding the built plugin (`main.js`, `manifest.json`, `styles.css`), relative to the project root.
+     * Defaults to `dist/build`, where the production build writes it.
+     */
+    readonly pluginFolder?: string;
+    /**
+     * The spec files, relative to the project root. Defaults to {@link DEFAULT_END_TO_END_SPECS}.
+     */
+    readonly specs?: readonly string[];
+    /**
+     * The per-test timeout, in milliseconds. Defaults to {@link DEFAULT_WDIO_OBSIDIAN_TEST_TIMEOUT_IN_MILLISECONDS}.
+     */
+    readonly testTimeoutInMilliseconds?: number;
+    /**
+     * The vault every test starts from, relative to the project root. The service opens a COPY of it, so the tests
+     * never change the folder. Defaults to the plugin's demo vault (`demo-vault`) when the project has one, and to an
+     * empty vault otherwise; `false` forces the empty vault.
+     */
+    readonly vault?: false | string;
+}
+/**
+ * Options for {@link testEndToEndWithWdioObsidian}.
+ */
+export interface TestEndToEndWithWdioObsidianOptions {
+    /**
+     * The WebdriverIO config file, relative to the project root. Defaults to the first of
+     * {@link WDIO_CONFIG_FILE_NAMES} that exists.
+     */
+    readonly configPath?: string;
+    /**
+     * Whether to run the production build first, so the tests load the current `dist/build`. Defaults to `true`.
+     */
+    readonly shouldBuild?: boolean;
+}
+/**
+ * A `wdio-obsidian-service` capability: one Obsidian version to run the specs against.
+ */
+export interface WdioObsidianCapability {
+    /**
+     * Always `obsidian`, which is what routes the capability to the service.
+     */
+    'browserName': 'obsidian';
+    /**
+     * The Obsidian app version.
+     */
+    'browserVersion': string;
+    /**
+     * The service's own options for this capability.
+     */
+    'wdio:obsidianOptions': WdioObsidianCapabilityOptions;
+}
+/**
+ * The `wdio:obsidianOptions` of a {@link WdioObsidianCapability}.
+ */
+export interface WdioObsidianCapabilityOptions {
+    /**
+     * The Obsidian installer version.
+     */
+    readonly installerVersion?: string;
+    /**
+     * The plugin folders to install into the vault.
+     */
+    readonly plugins: string[];
+    /**
+     * The vault to open a copy of.
+     */
+    readonly vault?: string;
+}
+/**
+ * The WebdriverIO configuration {@link defineWdioObsidianConfig} returns. Every field is plain data, so a project
+ * changes any of them by spreading the result: `{ ...defineWdioObsidianConfig(), logLevel: 'info' }`.
+ */
+export interface WdioObsidianConfig {
+    /**
+     * Where Obsidian versions are downloaded.
+     */
+    cacheDir: string;
+    /**
+     * One capability per Obsidian version.
+     */
+    capabilities: WdioObsidianCapability[];
+    /**
+     * The test framework.
+     */
+    framework: 'mocha';
+    /**
+     * WebdriverIO's log level.
+     */
+    logLevel: 'debug' | 'error' | 'info' | 'silent' | 'trace' | 'warn';
+    /**
+     * How many Obsidian instances run in parallel.
+     */
+    maxInstances?: number;
+    /**
+     * Mocha's options.
+     */
+    mochaOpts: WdioObsidianMochaOptions;
+    /**
+     * The reporters. `obsidian` is the spec reporter, naming the Obsidian version instead of Chromium's.
+     */
+    reporters: string[];
+    /**
+     * Where the specs run.
+     */
+    runner: 'local';
+    /**
+     * The services. `obsidian` is `wdio-obsidian-service`.
+     */
+    services: string[];
+    /**
+     * The spec files.
+     */
+    specs: string[];
+}
+/**
+ * The `mochaOpts` of a {@link WdioObsidianConfig}.
+ */
+export interface WdioObsidianMochaOptions {
+    /**
+     * The per-test timeout, in milliseconds.
+     */
+    readonly timeout: number;
+    /**
+     * The interface the specs are written in.
+     */
+    readonly ui: 'bdd';
+}
+/**
+ * Builds the WebdriverIO configuration for end-to-end tests with `wdio-obsidian-service`, derived from the plugin's
+ * layout: the production build in `dist/build` is the plugin under test, the demo vault (when there is one) is the
+ * vault, and the specs live in `e2e/`.
+ *
+ * `wdio.conf.mts`:
+ *
+ * ```ts
+ * import { defineWdioObsidianConfig } from '@mnaoumov/obsidian-dev-toolkit/test-runners/wdio-obsidian';
+ *
+ * export const config: WebdriverIO.Config = defineWdioObsidianConfig({ appVersions: ['earliest', 'latest'] });
+ * ```
+ *
+ * @param options - The {@link DefineWdioObsidianConfigOptions}.
+ * @returns The configuration, to export as `config`.
+ */
+export declare function defineWdioObsidianConfig(options?: DefineWdioObsidianConfigOptions): WdioObsidianConfig;
+/**
+ * Runs the end-to-end tests with `wdio-obsidian-service`: the production build, then `wdio run <config>`. It is the
+ * body of a plugin's `test:e2e` script.
+ *
+ * @param options - The {@link TestEndToEndWithWdioObsidianOptions}.
+ * @returns A {@link Promise} that resolves once the tests pass.
+ * @throws When a package is missing, no config file is found, the build fails or a test fails.
+ */
+export declare function testEndToEndWithWdioObsidian(options?: TestEndToEndWithWdioObsidianOptions): Promise<void>;

package/dist/lib/esm/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.d.mts

@@ -8,27 +8,11 @@
  * in the correct Obsidian folder for testing and use.
  */
 import type { Plugin } from 'esbuild';
+import type { DeployToObsidianPluginsFolderParams } from '../obsidian-plugins-folder-deployment.mjs';
 /**
  * Parameters for {@link copyToObsidianPluginsFolderPlugin}.
  */
-export interface CopyToObsidianPluginsFolderPluginParams {
-    /**
-     * The folder where the built files are located.
-     */
-    readonly distFolder: string;
-    /**
-     * A boolean indicating whether the build is a production build.
-     */
-    readonly isProductionBuild: boolean;
-    /**
-     * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.
-     */
-    readonly obsidianConfigFolder: string;
-    /**
-     * The name of the Obsidian plugin.
-     */
-    readonly pluginName: string;
-}
+export type CopyToObsidianPluginsFolderPluginParams = DeployToObsidianPluginsFolderParams;
 /**
  * Creates an esbuild plugin that copies the build output to the Obsidian plugins folder.
  *

package/dist/lib/esm/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.mjs

@@ -2,208 +2,19 @@
 THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
-(function () {
-function ensureBrowserProcess() {
-  const browserProcess = {
-    browser: true,
-    cwd() {
-      return "/";
-    },
-    env: {},
-    platform: "android"
-  };
-  const existingProcess = globalThis.process;
-  if (!existingProcess) {
-    globalThis.process = browserProcess;
-    return;
-  }
-  if (existingProcess.versions?.node) {
-    return;
-  }
-  const existingProcessRecord = existingProcess;
-  for (const [key, value] of Object.entries(browserProcess)) {
-    existingProcessRecord[key] ??= value;
-  }
-  existingProcessRecord["browser"] = true;
-}
-
-ensureBrowserProcess();
-})();
 
-import {
-  invokeAsyncSafely,
-  sleep
-} from "@mnaoumov/typescript-lib/async";
-import { getLibDebugger } from "@mnaoumov/typescript-lib/debug";
-import {
-  dirname,
-  join,
-  toPosixPath
-} from "@mnaoumov/typescript-lib/path";
-import {
-  cp,
-  mkdir
-} from "node:fs/promises";
-import process from "node:process";
-import {
-  createTransportFromOptions,
-  DesktopCdpTransport,
-  evalInObsidian
-} from "obsidian-integration-testing";
-const moduleState = {
-  devInstanceTransportPromise: void 0,
-  isDevInstanceCleanupRegistered: false,
-  isDevInstanceDisposed: false
-};
-const DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS = 2e3;
-const DEV_INSTANCE_CLOSED_PROBE_COUNT = 3;
+import { deployToObsidianPluginsFolder } from "../obsidian-plugins-folder-deployment.mjs";
 function copyToObsidianPluginsFolderPlugin(params) {
-  const {
-    distFolder,
-    isProductionBuild,
-    pluginName
-  } = params;
-  let {
-    obsidianConfigFolder
-  } = params;
   return {
     name: "copy-to-obsidian-plugins-folder",
     setup(build) {
       build.onEnd(async () => {
-        if (isProductionBuild) {
-          return;
-        }
-        if (!obsidianConfigFolder) {
-          getLibDebugger("copyToObsidianPluginsFolderPlugin")(
-            "No Obsidian config folder configured. `OBSIDIAN_CONFIG_FOLDER` environment variable is not set in system or in `.env` file. The compiled plugin will not be copied into Obsidian plugins folder."
-          );
-          return;
-        }
-        obsidianConfigFolder = toPosixPath(obsidianConfigFolder);
-        const pluginFolder = join(obsidianConfigFolder, "plugins", pluginName);
-        await mkdir(pluginFolder, { recursive: true });
-        await cp(distFolder, pluginFolder, { recursive: true });
-        await installAndEnableHotReload({
-          obsidianConfigFolder,
-          pluginName
-        });
+        await deployToObsidianPluginsFolder(params);
       });
     }
   };
 }
-async function getOrLaunchDevInstance(vaultPath) {
-  moduleState.devInstanceTransportPromise ??= launchDevInstance(vaultPath);
-  try {
-    return await moduleState.devInstanceTransportPromise;
-  } catch (error) {
-    moduleState.devInstanceTransportPromise = void 0;
-    throw error;
-  }
-}
-async function installAndEnableHotReload(params) {
-  const {
-    obsidianConfigFolder,
-    pluginName
-  } = params;
-  const vaultPath = dirname(obsidianConfigFolder);
-  const transport = await getOrLaunchDevInstance(vaultPath);
-  await evalInObsidian({
-    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
-    async callback({ app, obsidianModule, pluginName: pluginName2 }) {
-      const HOT_RELOAD_PLUGIN_ID = "hot-reload";
-      const COMMUNITY_PLUGINS_REGISTRY_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
-      const { requestUrl } = obsidianModule;
-      await app.plugins.setEnable(true);
-      if (!Object.hasOwn(app.plugins.manifests, HOT_RELOAD_PLUGIN_ID)) {
-        const registryResponse = await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL);
-        const registryEntries = registryResponse.json;
-        const entry = registryEntries.find((candidate) => candidate.id === HOT_RELOAD_PLUGIN_ID);
-        if (!entry) {
-          throw new Error(`Plugin '${HOT_RELOAD_PLUGIN_ID}' was not found in the Obsidian community plugins registry.`);
-        }
-        const latestReleaseResponse = await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`);
-        const latestRelease = latestReleaseResponse.json;
-        const version = latestRelease.tag_name;
-        const manifestResponse = await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`);
-        const manifest = manifestResponse.json;
-        await app.plugins.installPlugin(entry.repo, version, manifest);
-      }
-      if (!Object.hasOwn(app.plugins.plugins, HOT_RELOAD_PLUGIN_ID)) {
-        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);
-      }
-      await app.plugins.enablePluginAndSave(pluginName2);
-    },
-    input: { pluginName },
-    shouldSkipPreflightChecks: true,
-    transport,
-    vaultPath
-  });
-}
-async function isDevInstanceRunning(cdpUrl) {
-  try {
-    const response = await fetch(`${cdpUrl}/json`);
-    const targets = await response.json();
-    return targets.some((target) => target.type === "page");
-  } catch {
-    return false;
-  }
-}
-async function launchDevInstance(vaultPath) {
-  const transport = await createTransportFromOptions();
-  try {
-    await transport.registerVault(vaultPath);
-  } catch (error) {
-    transport.disposeSync?.();
-    throw error;
-  }
-  registerDevInstanceCleanup(transport);
-  watchDevInstanceAndStopOnClose(transport);
-  return transport;
-}
-function registerDevInstanceCleanup(transport) {
-  if (moduleState.isDevInstanceCleanupRegistered) {
-    return;
-  }
-  moduleState.isDevInstanceCleanupRegistered = true;
-  process.on("exit", disposeDevInstance);
-  for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
-    process.once(signal, () => {
-      disposeDevInstance();
-      process.exit();
-    });
-  }
-  function disposeDevInstance() {
-    if (moduleState.isDevInstanceDisposed) {
-      return;
-    }
-    moduleState.isDevInstanceDisposed = true;
-    transport.disposeSync?.();
-  }
-}
-function watchDevInstanceAndStopOnClose(transport) {
-  if (!(transport instanceof DesktopCdpTransport)) {
-    return;
-  }
-  const endpoint = transport.getOwnedInstanceEndpoint();
-  if (!endpoint) {
-    return;
-  }
-  const cdpUrl = `http://${endpoint.host}:${String(endpoint.port)}`;
-  invokeAsyncSafely(stopWhenDevInstanceCloses);
-  async function stopWhenDevInstanceCloses() {
-    let consecutiveFailedProbeCount = 0;
-    while (consecutiveFailedProbeCount < DEV_INSTANCE_CLOSED_PROBE_COUNT) {
-      await sleep({ milliseconds: DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS });
-      if (moduleState.isDevInstanceDisposed) {
-        return;
-      }
-      consecutiveFailedProbeCount = await isDevInstanceRunning(cdpUrl) ? 0 : consecutiveFailedProbeCount + 1;
-    }
-    console.warn("The Obsidian instance owned by `npm run dev` was closed. Stopping the development build.");
-    process.exit();
-  }
-}
 export {
   copyToObsidianPluginsFolderPlugin
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/bundlers/esbuild-impl/copy-to-obsidian-plugins-folder-plugin.ts"],"sourcesContent":["/**\n * @file\n *\n * This module defines an esbuild plugin that automatically copies the build output\n * to the Obsidian plugins folder during development. This plugin helps streamline\n * the development workflow by ensuring that the latest build is always available\n * in the correct Obsidian folder for testing and use.\n */\n\n/* v8 ignore start -- esbuild plugin that copies build output to Obsidian plugins folder; requires a live esbuild context. */\n\nimport type { Plugin } from 'esbuild';\nimport type { PluginManifest } from 'obsidian';\nimport type { ObsidianTransport } from 'obsidian-integration-testing';\n\nimport {\n  invokeAsyncSafely,\n  sleep\n} from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport {\n  dirname,\n  join,\n  toPosixPath\n} from '@mnaoumov/typescript-lib/path';\nimport {\n  cp,\n  mkdir\n} from 'node:fs/promises';\nimport process from 'node:process';\nimport {\n  createTransportFromOptions,\n  DesktopCdpTransport,\n  evalInObsidian\n} from 'obsidian-integration-testing';\n\n/**\n * Parameters for {@link copyToObsidianPluginsFolderPlugin}.\n */\nexport interface CopyToObsidianPluginsFolderPluginParams {\n  /**\n   * The folder where the built files are located.\n   */\n  readonly distFolder: string;\n\n  /**\n   * A boolean indicating whether the build is a production build.\n   */\n  readonly isProductionBuild: boolean;\n\n  /**\n   * The folder of the Obsidian configuration. If not provided, the plugin will not copy files.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the Obsidian plugin.\n   */\n  readonly pluginName: string;\n}\n\n/**\n * The subset of a CDP target descriptor read from the owned instance's `/json` endpoint.\n */\ninterface CdpTarget {\n  /**\n   * The kind of the target, e.g. `page`.\n   */\n  readonly type: string;\n}\n\n/**\n * A single entry in Obsidian's community plugins registry (`community-plugins.json`).\n */\ninterface CommunityPluginRegistryEntry {\n  /**\n   * The plugin id.\n   */\n  readonly id: string;\n\n  /**\n   * The `owner/name` GitHub repository the plugin is published from.\n   */\n  readonly repo: string;\n}\n\n/**\n * The subset of a GitHub release we read.\n */\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\n/**\n * Parameters for {@link installAndEnableHotReload}.\n */\ninterface InstallAndEnableHotReloadParams {\n  /**\n   * The folder of the Obsidian configuration.\n   */\n  readonly obsidianConfigFolder: string;\n\n  /**\n   * The name of the built Obsidian plugin to enable once HotReload is in place.\n   */\n  readonly pluginName: string;\n}\n\n// The `npm run dev`-owned Obsidian instance: launched on the first rebuild and reused across rebuilds.\n// Its lifetime is tied to the `npm run dev` process in BOTH directions.\n// The instance is closed when the process terminates (see `registerDevInstanceCleanup`).\n// The process stops when the instance is closed (see `watchDevInstanceAndStopOnClose`).\n/**\nModule-level mutable state, held in one object so each mutation names it explicitly.\n */\ninterface ModuleState {\n  devInstanceTransportPromise: Promise<ObsidianTransport> | undefined;\n  isDevInstanceCleanupRegistered: boolean;\n  isDevInstanceDisposed: boolean;\n}\n\nconst moduleState: ModuleState = {\n  devInstanceTransportPromise: undefined,\n  isDevInstanceCleanupRegistered: false,\n  isDevInstanceDisposed: false\n};\n\n/**\n * How often the owned Obsidian instance is probed to detect that it was closed.\n */\nconst DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS = 2000;\n\n/**\n * How many consecutive failed probes are tolerated before the owned instance is considered closed. A\n * single failure can be a transient hiccup (a busy renderer, a momentarily refused connection), so the\n * development build is only stopped once the endpoint stays unreachable.\n */\nconst DEV_INSTANCE_CLOSED_PROBE_COUNT = 3;\n/**\n * Creates an esbuild plugin that copies the build output to the Obsidian plugins folder.\n *\n * @param params - The parameters for the function.\n * @returns An esbuild `Plugin` object.\n */\nexport function copyToObsidianPluginsFolderPlugin(params: CopyToObsidianPluginsFolderPluginParams): Plugin {\n  const {\n    distFolder,\n    isProductionBuild,\n    pluginName\n  } = params;\n  let {\n    obsidianConfigFolder\n  } = params;\n  return {\n    name: 'copy-to-obsidian-plugins-folder',\n    setup(build): void {\n      build.onEnd(async () => {\n        if (isProductionBuild) {\n          return;\n        }\n\n        if (!obsidianConfigFolder) {\n          getLibDebugger('copyToObsidianPluginsFolderPlugin')(\n            'No Obsidian config folder configured. `OBSIDIAN_CONFIG_FOLDER` environment variable is not set in system or in `.env` file. The compiled plugin will not be copied into Obsidian plugins folder.'\n          );\n          return;\n        }\n\n        obsidianConfigFolder = toPosixPath(obsidianConfigFolder);\n\n        const pluginFolder = join(obsidianConfigFolder, 'plugins', pluginName);\n        await mkdir(pluginFolder, { recursive: true });\n        await cp(distFolder, pluginFolder, { recursive: true });\n\n        await installAndEnableHotReload({\n          obsidianConfigFolder,\n          pluginName\n        });\n      });\n    }\n  };\n}\n\n/**\n * Returns the `npm run dev`-owned Obsidian instance for the given vault, launching it on first use and\n * reusing it on subsequent rebuilds.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the owned {@link ObsidianTransport}.\n */\nasync function getOrLaunchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  moduleState.devInstanceTransportPromise ??= launchDevInstance(vaultPath);\n  try {\n    return await moduleState.devInstanceTransportPromise;\n  } catch (error) {\n    // Clear the cache so a later rebuild retries the launch.\n    moduleState.devInstanceTransportPromise = undefined;\n    throw error;\n  }\n}\n\n/**\n * Installs the HotReload plugin from the official community store (if not already installed), loads it\n * (if not already running), and enables the freshly-built plugin — all through the `npm run dev`-owned\n * Obsidian instance, so HotReload then auto-refreshes the deployed plugin on every rebuild.\n *\n * The install goes through Obsidian's own `installPlugin` (the community-store mechanism), and every step\n * runs against the owned instance over CDP; any failure surfaces (the dev build reports it) rather than\n * being silently swallowed.\n *\n * The first step is leaving restricted mode for real, which the owned instance has only faked so far —\n * without it \"enabled\" and \"loaded\" come apart and none of the vault's plugins, HotReload included, are\n * running. See the comment on the `setEnable` call.\n *\n * The install-if-missing / enable-if-disabled logic below intentionally mirrors the public\n * `installCommunityPlugin` / `enableCommunityPlugin` helpers in `src/obsidian/community-plugins.ts`. It\n * cannot import and call them: the `fn` is serialized (`toString()`) and executed in the renderer, and\n * this build-owned Obsidian instance is bare — it has no dev-utils `lib` provider wired (that resolver is\n * registered only in the integration-test setup, whose fixture publishes the merged surface on `window`),\n * so the closure has no access to the library surface and must inline the equivalent steps.\n *\n * @param params - The {@link InstallAndEnableHotReloadParams}.\n * @returns A {@link Promise} that resolves once HotReload and the built plugin are installed and enabled.\n */\nasync function installAndEnableHotReload(params: InstallAndEnableHotReloadParams): Promise<void> {\n  const {\n    obsidianConfigFolder,\n    pluginName\n  } = params;\n  const vaultPath = dirname(obsidianConfigFolder);\n  const transport = await getOrLaunchDevInstance(vaultPath);\n  await evalInObsidian({\n    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.\n    async callback({ app, obsidianModule, pluginName }) {\n      const HOT_RELOAD_PLUGIN_ID = 'hot-reload';\n      const COMMUNITY_PLUGINS_REGISTRY_URL = 'https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json';\n      const { requestUrl } = obsidianModule;\n\n      /*\n       * Genuinely leave restricted mode before touching anything else. The owned instance boots with a\n       * fresh user-data dir, so Obsidian starts restricted and `Plugins.initialize()` returns before\n       * loading a single plugin. The harness then closes the trust modal and writes the\n       * `enable-plugin-<appId>` localStorage flag directly — deliberately, to avoid a synchronous load —\n       * which leaves `isEnabled()` reporting `true` over a vault where nothing is actually running. Every\n       * `enabledPlugins` reading below (and in the mirrored `community-plugins.ts` helpers) would be\n       * answering about the vault's config file rather than this instance.\n       *\n       * `setEnable(true)` is what Obsidian's own \"Exit restricted mode\" button calls: it re-asserts the\n       * flag and loads everything in `enabledPlugins`. Unconditional on purpose — the flag is already\n       * `true`, so an `isEnabled()` guard would skip the load that is the whole point. Idempotent and\n       * effectively free once warm (`loadPlugin` returns the live instance), so re-running it on every\n       * rebuild costs nothing.\n       */\n      await app.plugins.setEnable(true);\n\n      if (!Object.hasOwn(app.plugins.manifests, HOT_RELOAD_PLUGIN_ID)) {\n        const registryResponse = await requestUrl(COMMUNITY_PLUGINS_REGISTRY_URL);\n        const registryEntries = registryResponse.json as CommunityPluginRegistryEntry[];\n        const entry = registryEntries.find((candidate) => candidate.id === HOT_RELOAD_PLUGIN_ID);\n        if (!entry) {\n          throw new Error(`Plugin '${HOT_RELOAD_PLUGIN_ID}' was not found in the Obsidian community plugins registry.`);\n        }\n\n        const latestReleaseResponse = await requestUrl(`https://api.github.com/repos/${entry.repo}/releases/latest`);\n        const latestRelease = latestReleaseResponse.json as GitHubRelease;\n        const version = latestRelease.tag_name;\n        const manifestResponse = await requestUrl(`https://github.com/${entry.repo}/releases/download/${version}/manifest.json`);\n        const manifest = manifestResponse.json as PluginManifest;\n        await app.plugins.installPlugin(entry.repo, version, manifest);\n      }\n\n      /*\n       * Ask whether HotReload is RUNNING, not whether the vault config lists it as enabled. After the\n       * `setEnable` above the two normally agree, but a HotReload that is listed and failed to load would\n       * pass an `enabledPlugins` check while leaving the dev build without auto-refresh.\n       */\n      if (!Object.hasOwn(app.plugins.plugins, HOT_RELOAD_PLUGIN_ID)) {\n        await app.plugins.enablePluginAndSave(HOT_RELOAD_PLUGIN_ID);\n      }\n\n      await app.plugins.enablePluginAndSave(pluginName);\n    },\n    input: { pluginName },\n    shouldSkipPreflightChecks: true,\n    transport,\n    vaultPath\n  });\n}\n\n/**\n * Probes the owned Obsidian instance's CDP endpoint to determine whether it is still running.\n *\n * A closed instance stops serving CDP altogether, so an unreachable endpoint — or one left with no page\n * targets while the app tears itself down — means the instance is gone.\n *\n * @param cdpUrl - The base CDP URL of the owned instance, e.g. `http://localhost:51888`.\n * @returns A {@link Promise} resolving to `true` while the instance is still serving a page target.\n */\nasync function isDevInstanceRunning(cdpUrl: string): Promise<boolean> {\n  try {\n    // eslint-disable-next-line no-restricted-globals -- We run this outside of Obsidian, so we don't have `requestUrl()`.\n    const response = await fetch(`${cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.some((target) => target.type === 'page');\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Launches a fresh owned Obsidian instance (isolated user-data dir) and opens the given vault.\n *\n * @param vaultPath - The absolute path to the vault folder to open.\n * @returns A {@link Promise} resolving to the launched {@link ObsidianTransport}.\n */\nasync function launchDevInstance(vaultPath: string): Promise<ObsidianTransport> {\n  const transport = await createTransportFromOptions();\n  try {\n    await transport.registerVault(vaultPath);\n  } catch (error) {\n    transport.disposeSync?.();\n    throw error;\n  }\n  registerDevInstanceCleanup(transport);\n  watchDevInstanceAndStopOnClose(transport);\n  return transport;\n}\n\n/**\n * Registers process-exit and signal handlers (once) that synchronously close the owned Obsidian\n * instance when the `npm run dev` process terminates.\n *\n * These handlers cover an orderly shutdown. A `SIGKILL` (or a Task Manager / IDE stop) runs no handler\n * at all, and no operating system kills the instance just for being our child — so that case is caught\n * from the other side, by the harness's parent-liveness watchdog: the instance's renderer holds a socket\n * back to this process and destroys its window when the kernel closes it. See `parent-liveness.ts` in\n * `obsidian-integration-testing`.\n *\n * @param transport - The owned transport to dispose on shutdown.\n */\nfunction registerDevInstanceCleanup(transport: ObsidianTransport): void {\n  if (moduleState.isDevInstanceCleanupRegistered) {\n    return;\n  }\n  moduleState.isDevInstanceCleanupRegistered = true;\n\n  // `exit` covers any `process.exit()`, but a default Ctrl+C terminates WITHOUT firing `exit`, so the signal handlers guarantee the owned Obsidian is killed on shutdown.\n  process.on('exit', disposeDevInstance);\n  for (const signal of ['SIGHUP', 'SIGINT', 'SIGTERM'] as const) {\n    process.once(signal, () => {\n      disposeDevInstance();\n      process.exit();\n    });\n  }\n\n  function disposeDevInstance(): void {\n    if (moduleState.isDevInstanceDisposed) {\n      return;\n    }\n    moduleState.isDevInstanceDisposed = true;\n    transport.disposeSync?.();\n  }\n}\n\n/**\n * Watches the `npm run dev`-owned Obsidian instance and stops the development build once the instance is\n * closed.\n *\n * This is the mirror image of {@link registerDevInstanceCleanup}: that one closes the instance when the\n * `npm run dev` process terminates, this one terminates the process when the user closes the instance, so\n * the two never outlive each other. A build watching an Obsidian that is no longer running has nothing\n * left to deploy to.\n *\n * Only a harness-owned instance is watched. When the transport attaches to an already-running Obsidian\n * (the user's own), that instance is not ours to be tied to and closing it leaves the build running.\n *\n * @param transport - The owned transport whose instance to watch.\n */\nfunction watchDevInstanceAndStopOnClose(transport: ObsidianTransport): void {\n  if (!(transport instanceof DesktopCdpTransport)) {\n    return;\n  }\n\n  const endpoint = transport.getOwnedInstanceEndpoint();\n  if (!endpoint) {\n    return;\n  }\n\n  const cdpUrl = `http://${endpoint.host}:${String(endpoint.port)}`;\n  invokeAsyncSafely(stopWhenDevInstanceCloses);\n\n  async function stopWhenDevInstanceCloses(): Promise<void> {\n    let consecutiveFailedProbeCount = 0;\n    while (consecutiveFailedProbeCount < DEV_INSTANCE_CLOSED_PROBE_COUNT) {\n      await sleep({ milliseconds: DEV_INSTANCE_PROBE_INTERVAL_IN_MILLISECONDS });\n\n      // The process is already shutting down and killed the instance itself; the probes would just race the teardown.\n      if (moduleState.isDevInstanceDisposed) {\n        return;\n      }\n\n      consecutiveFailedProbeCount = await isDevInstanceRunning(cdpUrl) ? 0 : consecutiveFailedProbeCount + 1;\n    }\n\n    console.warn('The Obsidian instance owned by `npm run dev` was closed. Stopping the development build.');\n    process.exit();\n  }\n}\n\n/* v8 ignore stop */\n"],"mappings":"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","names":["pluginName"]}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/bundlers/esbuild-impl/feature-options.d.mts

@@ -0,0 +1,60 @@
+/// <reference path="../../library-references.d.mts" />
+/**
+ * @file
+ *
+ * What the {@link ObsidianPluginFeatureOptions} add to the esbuild build: the JSX runtime, the framework's
+ * compile-time constants, the `.wasm` loader, the Solid and Vue plugins, and the stylesheet options of the Sass plugin
+ * that loads every stylesheet.
+ */
+import type { BuildOptions, Plugin } from 'esbuild';
+import type { SassPluginOptions } from 'esbuild-sass-plugin';
+import type { ObsidianPluginFeatureOptions } from '../obsidian-plugin-features.mjs';
+/**
+ * The esbuild options of {@link getEsbuildFeatureBuildOptions}.
+ */
+export type EsbuildFeatureBuildOptions = Pick<BuildOptions, 'define' | 'jsx' | 'jsxImportSource' | 'loader'>;
+/**
+ * Parameters for {@link getEsbuildFeatureBuildOptions}.
+ */
+export interface GetEsbuildFeatureBuildOptionsParams {
+    /**
+     * The build features.
+     */
+    readonly features: ObsidianPluginFeatureOptions;
+    /**
+     * Whether this is a production build.
+     */
+    readonly isProductionBuild: boolean;
+}
+/**
+ * Parameters for {@link getEsbuildFeaturePlugins}.
+ */
+export type GetEsbuildFeaturePluginsParams = GetEsbuildFeatureBuildOptionsParams;
+/**
+ * Parameters for {@link getSassPluginOptionsList}.
+ */
+export type GetSassPluginOptionsListParams = GetEsbuildFeatureBuildOptionsParams;
+/**
+ * Builds the esbuild options the features set: the automatic JSX runtime for React and Preact, the framework's
+ * compile-time constants, and the `binary` loader for `.wasm`.
+ *
+ * @param params - The {@link GetEsbuildFeatureBuildOptionsParams}.
+ * @returns The options, to merge under the consumer's own.
+ */
+export declare function getEsbuildFeatureBuildOptions(params: GetEsbuildFeatureBuildOptionsParams): EsbuildFeatureBuildOptions;
+/**
+ * Creates the esbuild plugins the framework needs: `unplugin-vue` for Vue, and the shared Solid transform for Solid.
+ *
+ * @param params - The {@link GetEsbuildFeaturePluginsParams}.
+ * @returns A {@link Promise} that resolves to the plugins, empty when the framework needs none.
+ */
+export declare function getEsbuildFeaturePlugins(params: GetEsbuildFeaturePluginsParams): Promise<Plugin[]>;
+/**
+ * Builds the option sets of the Sass plugin that loads every stylesheet: one for ordinary stylesheets, and with CSS
+ * modules on, one before it that loads `*.module.css` with esbuild's own `local-css` loader. Each runs the stylesheet
+ * through PostCSS and Tailwind when the options ask for it.
+ *
+ * @param params - The {@link GetSassPluginOptionsListParams}.
+ * @returns The option sets, in the order their plugins must be registered.
+ */
+export declare function getSassPluginOptionsList(params: GetSassPluginOptionsListParams): SassPluginOptions[];

package/dist/lib/esm/bundlers/esbuild-impl/feature-options.mjs

@@ -0,0 +1,82 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { readFile } from "node:fs/promises";
+import {
+  getFrameworkDefines,
+  getJsxImportSource,
+  importOptionalPeer,
+  isPostcssNeeded
+} from "../obsidian-plugin-features.mjs";
+import {
+  appendInlineSourceMap,
+  transformCss,
+  transformSolid
+} from "../obsidian-plugin-transforms.mjs";
+const CSS_MODULE_FILTER = /\.module\.(?:css|s[ac]ss)$/i;
+const SOLID_FILTER = /\.[jt]sx$/i;
+function getEsbuildFeatureBuildOptions(params) {
+  const { features, isProductionBuild } = params;
+  const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild });
+  const jsxImportSource = getJsxImportSource(features.framework);
+  return {
+    ...Object.keys(defines).length > 0 && { define: defines },
+    ...jsxImportSource !== void 0 && { jsx: "automatic", jsxImportSource },
+    ...features.wasm && { loader: { ".wasm": "binary" } }
+  };
+}
+async function getEsbuildFeaturePlugins(params) {
+  const { features, isProductionBuild } = params;
+  switch (features.framework) {
+    case "solid": {
+      return [solidEsbuildPlugin(isProductionBuild)];
+    }
+    case "vue": {
+      const unpluginVue = await importOptionalPeer({
+        feature: "framework: 'vue'",
+        packageName: "unplugin-vue",
+        specifier: "unplugin-vue/esbuild"
+      });
+      return [unpluginVue.default({ isProduction: isProductionBuild })];
+    }
+    default: {
+      return [];
+    }
+  }
+}
+function getSassPluginOptionsList(params) {
+  const { features, isProductionBuild } = params;
+  const styles = features.styles ?? {};
+  const baseOptions = {
+    sourceMap: !isProductionBuild,
+    ...isPostcssNeeded(styles) && {
+      async transform(css, _resolveDirectory, filePath) {
+        const result = await transformCss({ filePath, isCssModuleScoped: false, isProductionBuild, source: css, styles });
+        return result.css;
+      }
+    }
+  };
+  return styles.cssModules ? [{ ...baseOptions, filter: CSS_MODULE_FILTER, type: "local-css" }, baseOptions] : [baseOptions];
+}
+function solidEsbuildPlugin(isProductionBuild) {
+  return {
+    name: "obsidian-plugin-solid",
+    setup(build) {
+      build.onLoad({ filter: SOLID_FILTER }, async ({ path }) => {
+        const code = await readFile(path, "utf-8");
+        return {
+          contents: appendInlineSourceMap(await transformSolid({ code, filePath: path, isProductionBuild })),
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+export {
+  getEsbuildFeatureBuildOptions,
+  getEsbuildFeaturePlugins,
+  getSassPluginOptionsList
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/bundlers/esbuild-impl/feature-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * What the {@link ObsidianPluginFeatureOptions} add to the esbuild build: the JSX runtime, the framework's\n * compile-time constants, the `.wasm` loader, the Solid and Vue plugins, and the stylesheet options of the Sass plugin\n * that loads every stylesheet.\n */\n\nimport type {\n  BuildOptions,\n  Plugin\n} from 'esbuild';\nimport type { SassPluginOptions } from 'esbuild-sass-plugin';\n\nimport { readFile } from 'node:fs/promises';\n\nimport type { ObsidianPluginFeatureOptions } from '../obsidian-plugin-features.ts';\n\nimport {\n  getFrameworkDefines,\n  getJsxImportSource,\n  importOptionalPeer,\n  isPostcssNeeded\n} from '../obsidian-plugin-features.ts';\nimport {\n  appendInlineSourceMap,\n  transformCss,\n  transformSolid\n} from '../obsidian-plugin-transforms.ts';\n\n/**\n * The esbuild options of {@link getEsbuildFeatureBuildOptions}.\n */\nexport type EsbuildFeatureBuildOptions = Pick<BuildOptions, 'define' | 'jsx' | 'jsxImportSource' | 'loader'>;\n\n/**\n * Parameters for {@link getEsbuildFeatureBuildOptions}.\n */\nexport interface GetEsbuildFeatureBuildOptionsParams {\n  /**\n   * The build features.\n   */\n  readonly features: ObsidianPluginFeatureOptions;\n\n  /**\n   * Whether this is a production build.\n   */\n  readonly isProductionBuild: boolean;\n}\n\n/**\n * Parameters for {@link getEsbuildFeaturePlugins}.\n */\nexport type GetEsbuildFeaturePluginsParams = GetEsbuildFeatureBuildOptionsParams;\n\n/**\n * Parameters for {@link getSassPluginOptionsList}.\n */\nexport type GetSassPluginOptionsListParams = GetEsbuildFeatureBuildOptionsParams;\n\ninterface UnpluginVueEsbuildModule {\n  readonly default: (options?: object) => Plugin;\n}\n\n// Esbuild's filters are Go regular expressions, which take no `u` flag.\nconst CSS_MODULE_FILTER = /\\.module\\.(?:css|s[ac]ss)$/i;\nconst SOLID_FILTER = /\\.[jt]sx$/i;\n\n/**\n * Builds the esbuild options the features set: the automatic JSX runtime for React and Preact, the framework's\n * compile-time constants, and the `binary` loader for `.wasm`.\n *\n * @param params - The {@link GetEsbuildFeatureBuildOptionsParams}.\n * @returns The options, to merge under the consumer's own.\n */\nexport function getEsbuildFeatureBuildOptions(params: GetEsbuildFeatureBuildOptionsParams): EsbuildFeatureBuildOptions {\n  const { features, isProductionBuild } = params;\n  const defines = getFrameworkDefines({ framework: features.framework, isProductionBuild });\n  const jsxImportSource = getJsxImportSource(features.framework);\n  return {\n    ...(Object.keys(defines).length > 0 && { define: defines }),\n    ...(jsxImportSource !== undefined && { jsx: 'automatic', jsxImportSource }),\n    ...(features.wasm && { loader: { '.wasm': 'binary' } })\n  };\n}\n\n/**\n * Creates the esbuild plugins the framework needs: `unplugin-vue` for Vue, and the shared Solid transform for Solid.\n *\n * @param params - The {@link GetEsbuildFeaturePluginsParams}.\n * @returns A {@link Promise} that resolves to the plugins, empty when the framework needs none.\n */\nexport async function getEsbuildFeaturePlugins(params: GetEsbuildFeaturePluginsParams): Promise<Plugin[]> {\n  const { features, isProductionBuild } = params;\n  switch (features.framework) {\n    case 'solid': {\n      return [solidEsbuildPlugin(isProductionBuild)];\n    }\n    case 'vue': {\n      const unpluginVue = await importOptionalPeer<UnpluginVueEsbuildModule>({\n        feature: 'framework: \\'vue\\'',\n        packageName: 'unplugin-vue',\n        specifier: 'unplugin-vue/esbuild'\n      });\n      return [unpluginVue.default({ isProduction: isProductionBuild })];\n    }\n    default: {\n      return [];\n    }\n  }\n}\n\n/**\n * Builds the option sets of the Sass plugin that loads every stylesheet: one for ordinary stylesheets, and with CSS\n * modules on, one before it that loads `*.module.css` with esbuild's own `local-css` loader. Each runs the stylesheet\n * through PostCSS and Tailwind when the options ask for it.\n *\n * @param params - The {@link GetSassPluginOptionsListParams}.\n * @returns The option sets, in the order their plugins must be registered.\n */\nexport function getSassPluginOptionsList(params: GetSassPluginOptionsListParams): SassPluginOptions[] {\n  const { features, isProductionBuild } = params;\n  const styles = features.styles ?? {};\n  const baseOptions: SassPluginOptions = {\n    sourceMap: !isProductionBuild,\n    ...(isPostcssNeeded(styles) && {\n      async transform(css: string, _resolveDirectory: string, filePath: string): Promise<string> {\n        const result = await transformCss({ filePath, isCssModuleScoped: false, isProductionBuild, source: css, styles });\n        return result.css;\n      }\n    })\n  };\n\n  return styles.cssModules ? [{ ...baseOptions, filter: CSS_MODULE_FILTER, type: 'local-css' }, baseOptions] : [baseOptions];\n}\n\n/* v8 ignore start -- An esbuild plugin; exercised by the bundler integration test against a real esbuild build. */\nfunction solidEsbuildPlugin(isProductionBuild: boolean): Plugin {\n  return {\n    name: 'obsidian-plugin-solid',\n    setup(build): void {\n      build.onLoad({ filter: SOLID_FILTER }, async ({ path }) => {\n        const code = await readFile(path, 'utf-8');\n        return {\n          contents: appendInlineSourceMap(await transformSolid({ code, filePath: path, isProductionBuild })),\n          loader: 'js'\n        };\n      });\n    }\n  };\n}\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;AAcA,SAAS,gBAAgB;AAIzB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAqCP,MAAM,oBAAoB;AAC1B,MAAM,eAAe;AASd,SAAS,8BAA8B,QAAyE;AACrH,QAAM,EAAE,UAAU,kBAAkB,IAAI;AACxC,QAAM,UAAU,oBAAoB,EAAE,WAAW,SAAS,WAAW,kBAAkB,CAAC;AACxF,QAAM,kBAAkB,mBAAmB,SAAS,SAAS;AAC7D,SAAO;AAAA,IACL,GAAI,OAAO,KAAK,OAAO,EAAE,SAAS,KAAK,EAAE,QAAQ,QAAQ;AAAA,IACzD,GAAI,oBAAoB,UAAa,EAAE,KAAK,aAAa,gBAAgB;AAAA,IACzE,GAAI,SAAS,QAAQ,EAAE,QAAQ,EAAE,SAAS,SAAS,EAAE;AAAA,EACvD;AACF;AAQA,eAAsB,yBAAyB,QAA2D;AACxG,QAAM,EAAE,UAAU,kBAAkB,IAAI;AACxC,UAAQ,SAAS,WAAW;AAAA,IAC1B,KAAK,SAAS;AACZ,aAAO,CAAC,mBAAmB,iBAAiB,CAAC;AAAA,IAC/C;AAAA,IACA,KAAK,OAAO;AACV,YAAM,cAAc,MAAM,mBAA6C;AAAA,QACrE,SAAS;AAAA,QACT,aAAa;AAAA,QACb,WAAW;AAAA,MACb,CAAC;AACD,aAAO,CAAC,YAAY,QAAQ,EAAE,cAAc,kBAAkB,CAAC,CAAC;AAAA,IAClE;AAAA,IACA,SAAS;AACP,aAAO,CAAC;AAAA,IACV;AAAA,EACF;AACF;AAUO,SAAS,yBAAyB,QAA6D;AACpG,QAAM,EAAE,UAAU,kBAAkB,IAAI;AACxC,QAAM,SAAS,SAAS,UAAU,CAAC;AACnC,QAAM,cAAiC;AAAA,IACrC,WAAW,CAAC;AAAA,IACZ,GAAI,gBAAgB,MAAM,KAAK;AAAA,MAC7B,MAAM,UAAU,KAAa,mBAA2B,UAAmC;AACzF,cAAM,SAAS,MAAM,aAAa,EAAE,UAAU,mBAAmB,OAAO,mBAAmB,QAAQ,KAAK,OAAO,CAAC;AAChH,eAAO,OAAO;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,OAAO,aAAa,CAAC,EAAE,GAAG,aAAa,QAAQ,mBAAmB,MAAM,YAAY,GAAG,WAAW,IAAI,CAAC,WAAW;AAC3H;AAGA,SAAS,mBAAmB,mBAAoC;AAC9D,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,OAAa;AACjB,YAAM,OAAO,EAAE,QAAQ,aAAa,GAAG,OAAO,EAAE,KAAK,MAAM;AACzD,cAAM,OAAO,MAAM,SAAS,MAAM,OAAO;AACzC,eAAO;AAAA,UACL,UAAU,sBAAsB,MAAM,eAAe,EAAE,MAAM,UAAU,MAAM,kBAAkB,CAAC,CAAC;AAAA,UACjG,QAAQ;AAAA,QACV;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/esm/bundlers/esbuild-impl/index.d.mts

@@ -1,6 +1,7 @@
 /// <reference path="../../library-references.d.mts" />
 export * as 'copy-to-obsidian-plugins-folder-plugin' from './copy-to-obsidian-plugins-folder-plugin.mjs';
 export * as 'dependency' from './dependency.mjs';
+export * as 'feature-options' from './feature-options.mjs';
 export * as 'fix-source-maps-plugin' from './fix-source-maps-plugin.mjs';
 export * as 'obsidian-plugin-builder' from './obsidian-plugin-builder.mjs';
 export * as 'preprocess-plugin' from './preprocess-plugin.mjs';