@mnaoumov/create-obsidian-plugin 0.0.0-stage → 1.0.0

package/templates/default/jest.config.ts.ejs

@@ -0,0 +1,57 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+  // The project is `"type": "module"` and the tsconfig is `module: node16`, so ts-jest emits ESM. Jest
+  // treats `.ts` as CommonJS unless told otherwise, and then fails to `require` that output.
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    // `src/main.ts` imports the stylesheet for its side effect, and jest would parse it as JavaScript.
+    '\\.(css|scss)$': '<rootDir>/scripts/stylesheet-stub.ts',
+    // Compiling a single-file component is the bundler's job, not the unit runner's -- and the plugin
+    // That does it is only a dependency when the matching bundler was chosen. A unit test that reaches
+    // One through the plugin's module graph gets this stub instead, so the graph loads.
+    '\\.(svelte|vue)$': '<rootDir>/scripts/framework-component-stub.ts',
+    // Same decision for WebAssembly, and the same reason: loading a `.wasm` is the bundler's job. Two
+    // Patterns because two bundlers do not write the import plainly -- vite asks for the asset's URL
+    // (`./module.wasm?url`) and parcel uses a scheme (`data-url:./module.wasm`).
+    '\\.wasm(\\?.*)?$': '<rootDir>/scripts/wasm-module-stub.ts',
+    '^data-url:': '<rootDir>/scripts/wasm-module-stub.ts',
+    // The `obsidian` npm package is types-only: `"main": ""`, and a published tarball carrying nothing
+    // But `.d.ts` files. There is no module for jest to resolve at runtime, so without this every test
+    // That touches the plugin's own code dies in the resolver with "Cannot find module 'obsidian'".
+    // A `jest.mock('obsidian')` in a setup file cannot stand in for it: it has the same nothing to
+    // Resolve.
+    '^obsidian$': 'obsidian-test-mocks/obsidian',
+    // Svelte reaches its own runtime through Node subpath imports (`#client/constants`), and jest's ESM
+    // Resolver hands back the types entry for those -- so any suite that loads `svelte` dies on "does not
+    // Provide an export named 'COMMENT_NODE'" before it can run. The whole package therefore goes to the
+    // Stub too, which exports the `mount` / `unmount` the generated view uses. Vitest resolves the subpath
+    // Imports correctly and needs none of this.
+    '^svelte$': '<rootDir>/scripts/framework-component-stub.ts'
+  },
+  roots: ['<rootDir>/src'],
+  setupFiles: [
+    'obsidian-test-mocks/jest-setup'
+  ],
+  // `obsidian-test-mocks`' `setup()` writes to `Document.prototype`, `Element.prototype` and `window`,
+  // None of which exist in jest's default `node` environment.
+  testEnvironment: 'jsdom',
+  testMatch: ['**/*.test.ts'],
+  transform: {
+    // Replaces `preset: 'ts-jest'`, which is transform-only and leaves nowhere to put these options.
+    // `rootDir` is here rather than in `tsconfig.json` because that file declares `noEmit: true` and is
+    // also read by the bundler scripts, while ts-jest compiles WITH emit and so raises TS5011 on an
+    // inferred common source directory. `.` not `./src`: the tsconfig's `include` also covers `./*.ts`
+    // and `./scripts/**/*.ts`. The object is merged over the tsconfig, not substituted for it.
+    '^.+\\.tsx?$': ['ts-jest', {
+      tsconfig: {
+<%- render('ts-jest-tsconfig') -%>
+<%- render('lint-root-dir') -%>
+        rootDir: '.'
+      },
+      useESM: true
+    }]
+  }
+};
+
+export default config;

package/templates/default/jest.config.ts@lint-root-dir_dev-utils.ejs

@@ -0,0 +1 @@
+        // eslint-disable-next-line unicorn/name-replacements -- `rootDir` is TypeScript's own compiler-option name.

package/templates/default/jest.config.ts@ts-jest-tsconfig_solid.ejs

@@ -0,0 +1,8 @@
+        // Solid compiles its JSX with `babel-preset-solid`, so the project's own tsconfig sets
+        // `jsx: 'preserve'` and leaves the JSX in place for the bundler. ts-jest has no babel step, so
+        // Preserved JSX reaches jest as `SyntaxError: Unexpected token '<'`. The automatic runtime is
+        // What ts-jest can emit on its own, and `solid-js/h` is the entry point that has one -- plain
+        // `solid-js` publishes no `jsx-runtime`. Reactivity is not compiled in, which unit tests do not
+        // Need; rendering a Solid component is an integration-test job.
+        jsx: 'react-jsx',
+        jsxImportSource: 'solid-js/h',

package/templates/default/linkinator.config.json.ejs

@@ -0,0 +1,11 @@
+{
+  "comment": [
+    "Read automatically by linkinator, which the `lint:md` script runs from the project root over every Markdown file.",
+    "The links to this plugin's own GitHub repository are skipped: the scaffold wrote them from the project's answers,",
+    "and they return 404 until the repository is created and pushed and its first release is cut, which would leave a",
+    "fresh project failing its own `lint:md` for a reason nothing local can fix. Every other link is still checked."
+  ],
+  "skip": [
+    <%- JSON.stringify(_ownRepoLinkPattern) %>
+  ]
+}

package/templates/default/manifest.json.ejs

@@ -0,0 +1,11 @@
+{
+  "author": <%- JSON.stringify(authorGitHubName) %>,
+  "authorUrl": <%- JSON.stringify(`https://github.com/${authorGitHubName}/`) %>,
+  "description": <%- JSON.stringify(pluginDescription) %>,
+<%- render('funding') -%>
+  "id": <%- JSON.stringify(pluginId) %>,
+<%- render('platform') -%>
+  "minAppVersion": <%- JSON.stringify(_minAppVersion) %>,
+  "name": <%- JSON.stringify(pluginName) %>,
+  "version": "0.0.0"
+}

package/templates/default/manifest.json@funding_has-funding.ejs

@@ -0,0 +1 @@
+  "fundingUrl": <%- JSON.stringify(fundingUrl) %>,

package/templates/default/manifest.json@platform_desktop-and-mobile.ejs

@@ -0,0 +1 @@
+  "isDesktopOnly": false,

package/templates/default/manifest.json@platform_desktop-only.ejs

@@ -0,0 +1 @@
+  "isDesktopOnly": true,

package/templates/default/package.json.ejs

@@ -0,0 +1,32 @@
+{
+  "name": <%- JSON.stringify(pluginId) %>,
+  "version": "0.0.0",
+  "description": <%- JSON.stringify(pluginDescription) %>,
+  "type": "module",
+  "main": "main.js",
+<%- render('targets') -%>
+  "keywords": [],
+  "license": "MIT",
+  "author": <%- JSON.stringify(authorGitHubName) %>,
+  "scripts": {
+<% const scriptEntries = Object.entries(_scripts); -%>
+<% scriptEntries.forEach(([key, value], i) => { -%>
+    <%- JSON.stringify(key) %>: <%- JSON.stringify(value) %><%= i < scriptEntries.length - 1 ? ',' : '' %>
+<% }); -%>
+  },
+  "overrides": {
+<% _overrides.forEach((override, i) => { -%>
+    <%- JSON.stringify(override.packageName) %>: <%- JSON.stringify(override.spec) %><%= i < _overrides.length - 1 ? ',' : '' %>
+<% }); -%>
+  },
+  "resolutions": {
+<% _resolutions.forEach((resolution, i) => { -%>
+    <%- JSON.stringify(resolution.packageName) %>: <%- JSON.stringify(resolution.spec) %><%= i < _resolutions.length - 1 ? ',' : '' %>
+<% }); -%>
+  },
+  "devDependencies": {
+<% _dependencies.forEach((dep, i) => { -%>
+    <%- JSON.stringify(dep.packageName) %>: <%- JSON.stringify(dep.version) %><%= i < _dependencies.length - 1 ? ',' : '' %>
+<% }); -%>
+  }
+}

package/templates/default/package.json@targets_parcel.ejs

@@ -0,0 +1,36 @@
+<%#
+  Parcel alone needs a declared target, for two reasons that both bite silently.
+
+  `"main": "main.js"` above is a Parcel TARGET as far as Parcel is concerned, with a dist directory of
+  `.` -- so `parcel build --dist-dir dist/build` wrote the bundle to the project root instead and left
+  `dist/build` holding nothing but `manifest.json`. Disabling that target is what lets `--dist-dir` apply.
+
+  The replacement target is `electron-renderer`, which is where Obsidian runs a plugin, and CommonJS.
+  Parcel counts that context as BOTH a browser and a node one, and each half is load-bearing:
+
+  - node: builtins stay external, and the resolver may exclude `obsidian` and CodeMirror, which the app
+    supplies at runtime. A plain browser target refuses outright to leave any module external.
+  - browser: package `exports` resolve the `browser` condition. A plain `node` context resolves `node`,
+    which is Solid's and Svelte's SERVER build -- a view whose `render` / `mount` never mounts anything.
+
+  `includeNodeModules` is what bundles the dependencies at all. A node-flavoured context defaults it to
+  false, which left every package a `require()` in `main.js` that nothing installs beside a plugin -- a
+  build that exited 0 and a plugin that failed to load.
+
+  `packageExports` makes the resolver read package `exports`. Without it, a subpath such as
+  `svelte/internal/client` does not resolve once the package is bundled rather than required.
+-%>
+  "targets": {
+    "main": false,
+    "obsidianPlugin": {
+      "context": "electron-renderer",
+      "includeNodeModules": true,
+      "isLibrary": false,
+      "optimize": true,
+      "outputFormat": "commonjs",
+      "sourceMap": false
+    }
+  },
+  "@parcel/resolver-default": {
+    "packageExports": true
+  },

package/templates/default/parcel-namer-obsidian.cjs.ejs

@@ -0,0 +1,26 @@
+/*
+ * Names the emitted stylesheet `styles.css`.
+ *
+ * Obsidian loads a plugin's stylesheet from `styles.css` and nothing else. Parcel does not
+ * content-hash an entry bundle, so `src/main.ts` becomes `main.js` -- but the CSS it pulls in is a
+ * SIBLING bundle, and siblings are hashed, so the stylesheet came out as `main.<hash>.css`: shipped
+ * with every build, and read by nothing.
+ *
+ * Every other bundler takes an output name as an option -- `MiniCssExtractPlugin({ filename })`,
+ * `postcss({ extract })`, `build.lib.cssFileName`. Parcel takes a namer, so this is that option, for
+ * the same reason `parcel-resolver-obsidian.cjs` is Parcel's `external` list.
+ *
+ * Returning `null` for everything else defers to the default namer, so the JavaScript entry keeps the
+ * `main.js` it already had.
+ *
+ * CommonJS on purpose, as with the resolver beside it. The project is `"type": "module"`, so a `.mjs`
+ * plugin makes Parcel warn "ES module dependencies are experimental" on every single build.
+ */
+
+const { Namer } = require('@parcel/plugin');
+
+module.exports = new Namer({
+  name({ bundle }) {
+    return bundle.type === 'css' ? 'styles.css' : null;
+  }
+});

package/templates/default/parcel-resolver-obsidian.cjs.ejs

@@ -0,0 +1,37 @@
+/*
+ * Marks the modules Obsidian supplies at runtime as external.
+ *
+ * Parcel's default resolver refuses to treat a package as external unless it is declared in
+ * `dependencies`, and an Obsidian plugin must not declare `obsidian` there: the app provides it, and
+ * bundling a second copy of the API breaks `instanceof` against the running one. Every other bundler
+ * takes an `external` list; Parcel takes a resolver, so this is that list.
+ *
+ * CommonJS on purpose. The project is `"type": "module"`, so a `.mjs` plugin makes Parcel warn "ES
+ * module dependencies are experimental" on every single build.
+ */
+
+const { Resolver } = require('@parcel/plugin');
+
+const EXTERNAL = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'electron',
+  'esbuild',
+  'eslint',
+  'obsidian'
+]);
+
+module.exports = new Resolver({
+  resolve({ specifier }) {
+    return EXTERNAL.has(specifier) ? { isExcluded: true } : null;
+  }
+});

package/templates/default/parcel-transformer-inline-imports.cjs.ejs

@@ -0,0 +1,39 @@
+/*
+ * Keeps every dynamic `import()` inside `main.js`.
+ *
+ * Obsidian loads a plugin's `main.js` and nothing beside it, so a code-split chunk is shipped by no
+ * release and fails to load in an installed plugin. Parcel's default bundler makes every `import()` a
+ * new bundle root unconditionally, and has no option to inline one. The other bundlers each do:
+ * rollup's `inlineDynamicImports`, vite's `rollupOptions.output.inlineDynamicImports`, webpack's
+ * `asyncChunks: false`. This transformer is that option for Parcel, for the same reason
+ * `parcel-resolver-obsidian.cjs` is its `external` list. obsidian-dev-utils is what needs it: it
+ * reaches its desktop-only modules through `await import(...)`.
+ *
+ * It runs before Parcel's own JavaScript transformer and rewrites `import('<literal>')` into a
+ * `require()` inside an async arrow. The module still evaluates only when that code runs -- Parcel wraps
+ * a module it reaches through a nested `require()` -- which is what the dynamic import was for, and the
+ * promise still rejects when evaluation throws. The shape is deliberate: Parcel recognizes
+ * `Promise.resolve().then(() => require(...))` as a dynamic import and splits it all the same.
+ *
+ * Only a plain string specifier is rewritten; a computed one cannot be bundled by any bundler. The
+ * rewrite is textual, so an `import('<literal>')` spelled out inside a string or a comment is rewritten
+ * too, which changes nothing a plugin runs unless that string is itself code.
+ *
+ * CommonJS on purpose, as with the resolver beside it.
+ */
+
+const { Transformer } = require('@parcel/plugin');
+
+const DYNAMIC_IMPORT = /\bimport\(\s*(["'])([^"'`\n\\]+)\1\s*\)/gu;
+
+module.exports = new Transformer({
+  async transform({ asset }) {
+    const source = await asset.getCode();
+
+    if (source.includes('import(')) {
+      asset.setCode(source.replace(DYNAMIC_IMPORT, (_match, quote, specifier) => `(async () => require(${quote}${specifier}${quote}))()`));
+    }
+
+    return [asset];
+  }
+});

package/templates/default/parcel-transformer-svelte.cjs.ejs

@@ -0,0 +1,67 @@
+/*
+ * Compiles `.svelte` single-file components.
+ *
+ * Shipped here rather than installed, because no working package exists. Parcel publishes a scoped
+ * transformer for Vue but never has for Svelte, and the community `parcel-transformer-svelte` peers on
+ * `svelte@^3` and reaches for `svelte/compiler.js` -- a path Svelte 5 does not ship. Every parcel build
+ * that touched a `.svelte` file therefore died, first with "No transformers found" and then, once the
+ * package was registered, with "Could not resolve module svelte/compiler.js".
+ *
+ * The whole job is `compile()` plus handing Parcel the component's styles back as a separate asset, so
+ * carrying it is cheaper than depending on an unmaintained package. Same reasoning, and the same
+ * CommonJS-on-purpose note, as `parcel-resolver-obsidian.cjs`.
+ */
+
+const { Transformer } = require('@parcel/plugin');
+const { compile } = require('svelte/compiler');
+
+module.exports = new Transformer({
+  async transform({ asset }) {
+    const source = await asset.getCode();
+
+    const { css, js, warnings } = compile(source, {
+      css: 'external',
+      dev: process.env.BUILD !== 'production',
+      filename: asset.filePath,
+      name: toComponentName(asset.filePath)
+    });
+
+    for (const warning of warnings) {
+      // Parcel has no per-asset warning channel a transformer can write to, and swallowing them would
+      // Hide real problems in the component.
+      console.warn(`[svelte] ${warning.filename ?? asset.filePath}: ${warning.message}`);
+    }
+
+    asset.type = 'js';
+    asset.setCode(js.code);
+
+    const assets = [asset];
+
+    // `css: 'external'` keeps the styles out of the JavaScript so Parcel can extract them into the
+    // Plugin's stylesheet, which is what Obsidian loads. A component with no `<style>` block yields
+    // Nothing here.
+    if (css?.code) {
+      asset.addDependency({
+        specifier: `./${asset.id}.css`,
+        specifierType: 'esm'
+      });
+      assets.push({
+        content: css.code,
+        type: 'css',
+        uniqueKey: `${asset.id}.css`
+      });
+    }
+
+    return assets;
+  }
+});
+
+/** Svelte wants a valid JavaScript identifier for the component; the file name is the conventional one. */
+function toComponentName(filePath) {
+  const base = filePath.split(/[\\/]/u).pop().replace(/\.svelte$/u, '');
+  return base
+    .split(/[^A-Za-z0-9]/u)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('') || 'Component';
+}

package/templates/default/pinned-versions.json.ejs

@@ -0,0 +1 @@
+<%- _pinnedVersionsJson -%>

package/templates/default/pnpm-workspace.yaml.ejs

@@ -0,0 +1,19 @@
+# pnpm's settings file. Not only for workspaces: since pnpm 10 this is where per-project settings live,
+# and pnpm 12 says outright that "the `pnpm` field in package.json is no longer read by pnpm".
+#
+# pnpm blocks dependency install scripts by default and, unlike npm, treats that as an ERROR rather
+# than a warning -- `pnpm install` fails with ERR_PNPM_IGNORED_BUILDS until each one is named here.
+# Every package below downloads or compiles a native binary, which is exactly what it needs its install
+# script for. Naming one this project does not depend on is harmless, so the list covers what any
+# answer can pull in.
+#
+# `allowBuilds`, not the `onlyBuiltDependencies` list pnpm 10 used: pnpm 12 reads the map form and
+# silently ignores the old key.
+allowBuilds:
+  '@parcel/watcher': true
+  dprint: true
+  edgedriver: true
+  esbuild: true
+  geckodriver: true
+  svelte-preprocess: true
+  unrs-resolver: true

package/templates/default/postcss.config.cjs.ejs

@@ -0,0 +1,12 @@
+// This file is required by postcss at the root level.
+// The actual configuration lives in scripts/postcss.config.ts
+//
+// `.cjs`, not `.mjs`: every consumer finds this file through `postcss-load-config`, and the copy
+// `esbuild-postcss` bundles is v3, whose search places stop at `postcss.config.cjs`. With an `.mjs`
+// name it found nothing, reported no error, and silently ran the build with NO postcss plugins at all
+// -- so autoprefixer and Tailwind never ran on the standalone esbuild path. `.cjs` is the one name
+// every version of the loader, plus parcel, vite, webpack and rollup, all agree on.
+const { createJiti } = require('jiti');
+
+const jiti = createJiti(__filename);
+module.exports = jiti('./scripts/postcss.config.ts').config;

package/templates/default/prettier.config.mjs.ejs

@@ -0,0 +1,5 @@
+import { createJiti } from 'jiti';
+
+const jiti = createJiti(import.meta.url);
+const { config } = await jiti.import('./scripts/prettier.config.ts');
+export default config;

package/templates/default/rollup.config.mjs.ejs

@@ -0,0 +1,7 @@
+// This file is required by rollup at the root level.
+// The actual configuration lives in scripts/rollup.config.ts
+import { createJiti } from 'jiti';
+
+const jiti = createJiti(import.meta.url);
+const { config } = await jiti.import('./scripts/rollup.config.ts');
+export default config;

package/templates/default/scripts/babel.config.ts_rollup.ejs

@@ -0,0 +1,16 @@
+<%# Composed from list sections rather than from three whole-file partials, each of which declared its -%>
+<%# own `export const config`. A preset forcing a second UI framework on top of the chosen one -- which -%>
+<%# `demo` does with react -- rendered two of them into one file: TS2451. The file now declares `config` -%>
+<%# exactly once however many frameworks are active. -%>
+<%# -%>
+<%# Each list item ends in the comma a partial cannot help writing, so the last one is stripped here, as -%>
+<%# `rollup.config.ts.ejs` does with its plugins, and a list nothing contributed to collapses to `[]`. -%>
+<%# `plugins` comes first because `perfectionist/sort-objects` wants the keys sorted. -%>
+<%# -%>
+<%# What SHOULD happen when two JSX transforms are both active is a separate question, and not this -%>
+<%# file's to answer: it is the same demo-collision question the forced frameworks raise everywhere. -%>
+<% const list = (items) => `[\n${items}  ]`.replace(/,(?<Trailing>\s*)\]$/, '$<Trailing>]').replace(/^\[\s*\]$/, '[]'); -%>
+export const config = {
+  plugins: <%- list(render('babel-plugin')) %>,
+  presets: <%- list(render('babel-preset')) %>
+};

package/templates/default/scripts/babel.config.ts_rollup@babel-plugin_preact.ejs

@@ -0,0 +1 @@
+    ['@babel/plugin-transform-react-jsx', { importSource: 'preact', runtime: 'automatic' }],

package/templates/default/scripts/babel.config.ts_rollup@babel-preset_react.ejs

@@ -0,0 +1 @@
+    '@babel/preset-react',

package/templates/default/scripts/babel.config.ts_rollup@babel-preset_solid.ejs

@@ -0,0 +1 @@
+    'babel-preset-solid',

package/templates/default/scripts/build-clean.ts.ejs

@@ -0,0 +1,4 @@
+import { buildClean } from 'obsidian-dev-utils/script-utils/build';
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+
+await wrapCliTask(() => buildClean());

package/templates/default/scripts/build-compile.ts.ejs

@@ -0,0 +1,4 @@
+import { buildCompile } from 'obsidian-dev-utils/script-utils/build';
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+
+await wrapCliTask(() => buildCompile());

package/templates/default/scripts/build-styles.ts.ejs

@@ -0,0 +1,12 @@
+import { execSync } from 'node:child_process';
+
+// Tailwind 4 is compiled by its own CLI rather than through PostCSS, because PostCSS is not reachable on
+// Every path this generator emits: the obsidian-dev-utils presets call that library's esbuild build,
+// Which registers no PostCSS step at all AND registers `esbuild-sass-plugin` -- whose default filter is
+// `/\.(s[ac]ss|css)$/`, so it claims `.css` too -- ahead of the `customEsbuildPlugins` seam a project can
+// Add to. A PostCSS plugin appended there would never see the file. Running the CLI first sidesteps the
+// Question entirely: every bundler then receives ordinary, already-expanded CSS.
+//
+// `src/styles/main.css` is the SOURCE (it carries `@import "tailwindcss"`); nothing imports it directly.
+// `src/main.ts` imports the generated file below, which is git-ignored.
+execSync('npx @tailwindcss/cli --input src/styles/main.css --output src/styles/tailwind.generated.css', { stdio: 'inherit' });

package/templates/default/scripts/build.ts.ejs

@@ -0,0 +1,6 @@
+<%# Keyed on the BUNDLER first, as the lint and format scripts are keyed on their tool. Only esbuild -%>
+<%# has a preset-specific build -- obsidian-dev-utils supplies one, and standalone inlines its own -- -%>
+<%# so esbuild splits again underneath and the four CLI bundlers share one script. Splitting on the -%>
+<%# preset first is what made every obsidian-dev-utils preset run esbuild whatever was chosen, while -%>
+<%# still installing the chosen bundler and emitting its config for nothing to read. -%>
+<%- render('bundler') -%>

package/templates/default/scripts/build.ts@bundler_cli-bundler.ejs

@@ -0,0 +1,63 @@
+<%# The relative imports go in a group of their own, after a blank line, which is what an import-sorting -%>
+<%# lint rule asks for -- and the dev-utils presets now run one. Emitted only when a partial contributes. -%>
+<% const relativeImports = render('import'); -%>
+import { execSync } from 'node:child_process';
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  rmSync<%- render('fs-import') %>
+} from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+<%- relativeImports ? `\n${relativeImports}` : '' -%>
+
+<%# `npm run dev` re-enters this script with `dev` in this slot; see `scripts/dev.ts`. -%>
+const BUILD_MODE_ARGUMENT_INDEX = 2;
+const isProduction = process.argv[BUILD_MODE_ARGUMENT_INDEX] !== 'dev';
+<%# The `if (prod)` guard belongs to the partial, not to this wrapper. Wrapping it here emitted an -%>
+<%# EMPTY `if (prod) { }` on every answer that contributes no compile step -- which the generated -%>
+<%# ESLint config rejects with `no-empty` -- and a nested `if (prod) { if (prod) { … } }` on the one -%>
+<%# answer that does. -%>
+<%- render('compile') -%>
+
+if (existsSync('.env')) {
+  process.loadEnvFile('.env');
+}
+
+const distFolder = isProduction ? 'dist/build' : 'dist/dev';
+
+if (existsSync(distFolder)) {
+  rmSync(distFolder, { recursive: true });
+}
+mkdirSync(distFolder, { recursive: true });
+
+copyFileSync('manifest.json', join(distFolder, 'manifest.json'));
+
+<%- render('hot-reload') -%>
+process.env['DIST_FOLDER'] = distFolder;
+// Passed through the child's environment rather than as a `BUILD=production ` command prefix.
+// Inline environment assignments are POSIX shell syntax: on Windows cmd.exe they are not a prefix at
+// All, and the build died with "'BUILD' is not recognized as an internal or external command".
+const env = isProduction ? { ...process.env, BUILD: 'production' } : process.env;
+const watchFlag = isProduction ? '' : ' --watch';
+<%- render('run') -%>
+
+if (!isProduction) {
+  copyToObsidianPluginsFolder(distFolder);
+}
+
+function copyToObsidianPluginsFolder(dist: string): void {
+  const obsidianConfigFolder = process.env['OBSIDIAN_CONFIG_FOLDER'] ?? '';
+  if (!obsidianConfigFolder) {
+    return;
+  }
+
+  const pluginFolder = join(obsidianConfigFolder, 'plugins', '<%= pluginId %>');
+  if (!existsSync(pluginFolder)) {
+    mkdirSync(pluginFolder, { recursive: true });
+  }
+  cpSync(dist, pluginFolder, { recursive: true });
+<%- render({ section: 'reload', indentLevel: 1 }) -%>
+}

package/templates/default/scripts/build.ts@bundler_cli-bundler@compile_svelte.ejs

@@ -0,0 +1,4 @@
+
+if (isProduction) {
+  execSync('svelte-check --tsconfig tsconfig.json', { stdio: 'inherit' });
+}

package/templates/default/scripts/build.ts@bundler_cli-bundler@fs-import_hot-reload-plugin.ejs

@@ -0,0 +1,2 @@
+,
+  writeFileSync

package/templates/default/scripts/build.ts@bundler_cli-bundler@hot-reload_hot-reload-plugin.ejs

@@ -0,0 +1,3 @@
+if (!isProduction) {
+  writeFileSync(join(distFolder, '.hotreload'), '');
+}

package/templates/default/scripts/build.ts@bundler_cli-bundler@import_tailwind.ejs

@@ -0,0 +1,2 @@
+<%- render('lint-build-styles') -%>
+import './build-styles.ts';

package/templates/default/scripts/build.ts@bundler_cli-bundler@lint-build-styles_dev-utils.ejs

@@ -0,0 +1 @@
+// eslint-disable-next-line import-x/no-unassigned-import -- Importing the module RUNS the style build; there is nothing to bind.

package/templates/default/scripts/build.ts@bundler_cli-bundler@reload_obsidian-cli.ejs

@@ -0,0 +1,5 @@
+try {
+  execSync('obsidian plugin:reload id=<%= pluginId %>', { stdio: 'ignore' });
+} catch {
+  // Obsidian CLI may not be available
+}

package/templates/default/scripts/build.ts@bundler_cli-bundler@run_parcel.ejs

@@ -0,0 +1 @@
+execSync(`npx parcel build src/main.ts --dist-dir ${distFolder} --no-cache${watchFlag}`, { env, stdio: 'inherit' });

package/templates/default/scripts/build.ts@bundler_cli-bundler@run_rollup.ejs

@@ -0,0 +1 @@
+execSync(`npx rollup -c${watchFlag}`, { env, stdio: 'inherit' });

package/templates/default/scripts/build.ts@bundler_cli-bundler@run_vite.ejs

@@ -0,0 +1 @@
+execSync(`npx vite build${watchFlag}`, { env, stdio: 'inherit' });

package/templates/default/scripts/build.ts@bundler_cli-bundler@run_webpack.ejs

@@ -0,0 +1 @@
+execSync(`npx webpack --config webpack.config.ts${watchFlag}`, { env, stdio: 'inherit' });

package/templates/default/scripts/build.ts@bundler_esbuild.ejs

@@ -0,0 +1,3 @@
+<%# obsidian-dev-utils ships an esbuild build that already handles the dist folders, the manifest copy, -%>
+<%# hot reload and the plugins-folder copy; standalone has no dev-utils and does all of that inline. -%>
+<%- render('preset') -%>

package/templates/default/scripts/build.ts@bundler_esbuild@compile_svelte.ejs

@@ -0,0 +1,4 @@
+
+if (prod) {
+  execSync('svelte-check --tsconfig tsconfig.json', { stdio: 'inherit' });
+}

package/templates/default/scripts/build.ts@bundler_esbuild@dev-utils-pre-build_tailwind.ejs

@@ -0,0 +1,2 @@
+<%- render('lint-build-styles') -%>
+import './build-styles.ts';

package/templates/default/scripts/build.ts@bundler_esbuild@fs-import_hot-reload-plugin.ejs

@@ -0,0 +1,2 @@
+,
+  writeFileSync

package/templates/default/scripts/build.ts@bundler_esbuild@hot-reload_hot-reload-plugin.ejs

@@ -0,0 +1,4 @@
+
+if (!prod) {
+  writeFileSync(join(distFolder, '.hotreload'), '');
+}

package/templates/default/scripts/build.ts@bundler_esbuild@import_postcss.ejs

@@ -0,0 +1 @@
+import postcssPlugin from 'esbuild-postcss';

package/templates/default/scripts/build.ts@bundler_esbuild@import_scss.ejs

@@ -0,0 +1 @@
+import { sassPlugin } from 'esbuild-sass-plugin';

package/templates/default/scripts/build.ts@bundler_esbuild@import_solid.ejs

@@ -0,0 +1 @@
+import { solidPlugin } from 'esbuild-plugin-solid';

package/templates/default/scripts/build.ts@bundler_esbuild@import_svelte.ejs

@@ -0,0 +1,10 @@
+import { execSync } from 'node:child_process';
+import esbuildSvelte from 'esbuild-svelte';
+import { sveltePreprocess } from 'svelte-preprocess';
+
+// `esbuild-svelte` declares `export default function` in its types but ships a CommonJS `main` whose
+// `module.exports` IS that function, and it publishes no `exports` map. Under `moduleResolution:
+// node16` TypeScript therefore models the default import as the module object and rejects the call,
+// while at runtime the import really is the function (verified: `typeof` is `function`). The cast
+// follows the runtime. It costs the option object's type-checking, which is the narrower loss.
+const sveltePlugin = esbuildSvelte as unknown as (options?: Record<string, unknown>) => esbuild.Plugin;

package/templates/default/scripts/build.ts@bundler_esbuild@import_tailwind.ejs

@@ -0,0 +1 @@
+import './build-styles.ts';

package/templates/default/scripts/build.ts@bundler_esbuild@import_vue.ejs

@@ -0,0 +1 @@
+import vuePlugin from 'esbuild-plugin-vue3';

package/templates/default/scripts/build.ts@bundler_esbuild@lint-build-styles_dev-utils.ejs

@@ -0,0 +1 @@
+// eslint-disable-next-line import-x/no-unassigned-import -- Importing the module RUNS the style build; there is nothing to bind.