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

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

@@ -0,0 +1,2 @@
+  jsx: 'automatic',
+  jsxImportSource: 'preact',

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

@@ -0,0 +1 @@
+  jsx: 'automatic',

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

@@ -0,0 +1,5 @@
+  // esbuild's own loader, rather than `esbuild-plugin-wasm`: that plugin follows the WebAssembly
+  // ESM-integration proposal and emits a top-level `await`, which esbuild supports only for the `esm`
+  // Output format -- and this bundle is `cjs`, because that is what Obsidian loads. `binary` inlines the
+  // File as base64 and hands the importing module a `Uint8Array`, with no await anywhere.
+  loader: { '.wasm': 'binary' },

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

@@ -0,0 +1 @@
+    postcssPlugin(),

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

@@ -0,0 +1 @@
+    sassPlugin(),

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

@@ -0,0 +1 @@
+    solidPlugin(),

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

@@ -0,0 +1,5 @@
+    sveltePlugin({
+      compilerOptions: { css: 'injected', dev: !prod },
+      moduleCompilerOptions: { dev: !prod },
+      preprocess: sveltePreprocess(),
+    }),

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

@@ -0,0 +1 @@
+    vuePlugin(),

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

@@ -0,0 +1,7 @@
+import { build } from 'obsidian-dev-utils/script-utils/bundlers/esbuild';
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+
+<%- render('dev-utils-pre-build') -%>
+import { customEsbuildPlugins } from './esbuild-plugins.ts';
+
+await wrapCliTask(() => build({ customEsbuildPlugins }));

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

@@ -0,0 +1,138 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmSync<%- render('fs-import') %>
+} from 'node:fs';
+import { builtinModules } from 'node:module';
+import { join } from 'node:path';
+import process from 'node:process';
+
+import esbuild from 'esbuild';
+<%- render('import') -%>
+
+const prod = process.argv[2] !== 'dev';
+<%- render('compile') -%>
+
+if (existsSync('.env')) {
+  process.loadEnvFile('.env');
+}
+
+const distFolder = prod ? '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') -%>
+
+const banner = `/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+`;
+
+const context = await esbuild.context({
+  banner: {
+    js: banner
+  },
+  entryPoints: ['src/main.ts'],
+  bundle: true,
+  external: [
+    'obsidian',
+    'electron',
+    '@codemirror/autocomplete',
+    '@codemirror/collab',
+    '@codemirror/commands',
+    '@codemirror/language',
+    '@codemirror/lint',
+    '@codemirror/search',
+    '@codemirror/state',
+    '@codemirror/view',
+    '@lezer/common',
+    '@lezer/highlight',
+    '@lezer/lr',
+    'esbuild',
+    'eslint',
+    ...builtinModules
+  ],
+  conditions: ['browser'],
+  format: 'cjs',
+  keepNames: true,
+  logLevel: 'info',
+  minify: prod,
+  outfile: join(distFolder, 'main.js'),
+  platform: 'node',
+  sourcemap: prod ? false : 'inline',
+  target: 'esnext',
+  treeShaking: true,
+<%- render('options') -%>
+  plugins: [
+<%- render('plugin') -%>
+    renameCssPlugin(distFolder),
+    copyToObsidianPluginsFolderPlugin(prod, distFolder)
+  ]
+});
+
+if (prod) {
+  await context.rebuild();
+  process.exit(0);
+} else {
+  await context.watch();
+}
+
+function copyToObsidianPluginsFolderPlugin(isProduction: boolean, dist: string): esbuild.Plugin {
+  return {
+    name: 'copy-to-obsidian-plugins-folder',
+    setup(build): void {
+      build.onEnd(async () => {
+        if (isProduction) {
+          return;
+        }
+
+        const obsidianConfigFolder = process.env.OBSIDIAN_CONFIG_FOLDER ?? '';
+        if (!obsidianConfigFolder) {
+          return;
+        }
+
+        const pluginFolder = join(obsidianConfigFolder, 'plugins', '<%= pluginId %>');
+        if (!existsSync(pluginFolder)) {
+          mkdirSync(pluginFolder, { recursive: true });
+        }
+
+        const { cpSync } = await import('node:fs');
+        cpSync(dist, pluginFolder, { recursive: true });
+<%- render({ section: 'reload', indentLevel: 4 }) -%>
+      });
+    }
+  };
+}
+
+/**
+ * Renames the emitted stylesheet to the only name Obsidian reads.
+ *
+ * `outfile` is `<dist>/main.js`, so esbuild writes the bundled CSS beside it as `<dist>/main.css`.
+ * Obsidian loads a plugin's stylesheet from `styles.css` and nothing else, so without this the file
+ * ships and is never read -- a build that succeeds and a plugin with no styles.
+ *
+ * Registered BEFORE `copyToObsidianPluginsFolderPlugin`: esbuild runs `onEnd` callbacks in plugin
+ * order, and the copy into the vault has to see the renamed file. Unconditional and existence-guarded
+ * rather than gated on the styling answer, so there is nothing to keep in sync -- a project with no
+ * stylesheet simply has nothing to rename.
+ */
+function renameCssPlugin(dist: string): esbuild.Plugin {
+  return {
+    name: 'rename-css',
+    setup(build): void {
+      build.onEnd(() => {
+        const mainCssPath = join(dist, 'main.css');
+        if (existsSync(mainCssPath)) {
+          renameSync(mainCssPath, join(dist, 'styles.css'));
+        }
+      });
+    }
+  };
+}

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

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

package/templates/default/scripts/commit.ts_dev-utils.ejs

@@ -0,0 +1,3 @@
+import { exec } from 'obsidian-dev-utils/script-utils/exec';
+
+await exec('czg');

package/templates/default/scripts/commit.ts_standalone.ejs

@@ -0,0 +1,3 @@
+import { execSync } from 'node:child_process';
+
+execSync('czg', { stdio: 'inherit' });

package/templates/default/scripts/commitlint-config.ts.ejs

@@ -0,0 +1,5 @@
+import type { UserConfig } from '@commitlint/types';
+
+export const config: UserConfig = {
+  extends: ['@commitlint/config-conventional']
+};

package/templates/default/scripts/demo-vault-global-setup.ts.ejs

@@ -0,0 +1,43 @@
+import type { PopulateFilesParams } from 'obsidian-integration-testing';
+
+import { join } from 'node:path';
+import process from 'node:process';
+import { CODE_SCRIPT_TOOLKIT_PLUGIN_ID } from 'obsidian-dev-utils/script-utils/demo-vault-buttons';
+import { getRootFolder } from 'obsidian-dev-utils/script-utils/root';
+import { buildDemoVaultPopulate } from 'obsidian-integration-testing';
+import { createSetup } from 'obsidian-integration-testing/vitest-global-setup-plugin';
+
+// CodeScript Toolkit is what turns a ```code-button fence into a button, and its root-relative
+// `require('/demoSetup.ts')` into a call. In real use the in-vault `demo-vault-helper` installs it from
+// The community registry on first launch — a NETWORK step. Seeding the copy it already installed into the
+// In-repo demo vault keeps this run hermetic and independent of that bootstrap, which is why the suite
+// Needs `demo-vault/` opened in Obsidian once before it can run. See CONTRIBUTING.md.
+const CODE_SCRIPT_TOOLKIT_SETTINGS = {
+  invocableScriptsFolder: 'Invocables',
+  modulesRoot: '_assets/CodeScriptToolkit',
+  shouldHandleProtocolUrls: true,
+  startupScriptPath: 'startup.ts'
+};
+
+function populate(): PopulateFilesParams {
+  return buildDemoVaultPopulate({
+    demoVaultPath: join(getRootFolder() ?? process.cwd(), 'demo-vault'),
+    injectPlugins: [{
+      data: CODE_SCRIPT_TOOLKIT_SETTINGS,
+      pluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID
+    }]
+  });
+}
+
+// Pre-populates the whole `demo-vault/` tree (plus the CodeScript Toolkit binary and its settings) before
+// Obsidian opens, so the startup scan indexes every note in one pass. Used by
+// `integration-tests:demo-vault`.
+const { setup, teardown } = createSetup({
+  enableCommunityPlugins: [CODE_SCRIPT_TOOLKIT_PLUGIN_ID],
+  populate
+});
+
+export {
+  setup,
+  teardown
+};

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

@@ -0,0 +1,6 @@
+<%# The twin of build.ts.ejs, and it has to be: `dev` is `build` in watch mode, so the two scripts are -%>
+<%# one decision made once. Keyed on the BUNDLER first for that reason -- keying it on the PRESET is -%>
+<%# what left every obsidian-dev-utils preset watching with esbuild whatever bundler was answered, -%>
+<%# while `npm run build` ran the answered one and the emitted config, loaders and plugins went unread -%>
+<%# by the path a developer actually spends the day in. -%>
+<%- render('bundler') -%>

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

@@ -0,0 +1,8 @@
+<%# build.ts already IS the watch script for the four command-line bundlers: it reads `dev` off argv -%>
+<%# and derives watchFlag, dist/dev, sourcemaps, the .hotreload marker and the vault copy from it. So -%>
+<%# `dev` re-enters it rather than restating any of that. Byte-identical to the esbuild+standalone -%>
+<%# partial, and deliberately a second copy: one shared partial contributed by both the CLI bundlers -%>
+<%# and `standalone` would render TWICE on standalone plus a command-line bundler. -%>
+const BUILD_MODE_ARGUMENT_INDEX = 2;
+process.argv[BUILD_MODE_ARGUMENT_INDEX] = 'dev';
+await import('./build.ts');

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

@@ -0,0 +1,3 @@
+<%# obsidian-dev-utils ships an esbuild `dev()` that watches, restarts on node_modules changes and -%>
+<%# re-runs build:compile; standalone has no dev-utils and its own build script is already the watcher. -%>
+<%- render('preset') -%>

package/templates/default/scripts/dev.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/dev.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.

package/templates/default/scripts/dev.ts@bundler_esbuild@preset_dev-utils.ejs

@@ -0,0 +1,7 @@
+import { dev } from 'obsidian-dev-utils/script-utils/bundlers/esbuild';
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+
+<%- render('dev-utils-pre-build') -%>
+import { customEsbuildPlugins } from './esbuild-plugins.ts';
+
+await wrapCliTask(() => dev({ customEsbuildPlugins }));

package/templates/default/scripts/dev.ts@bundler_esbuild@preset_standalone.ejs

@@ -0,0 +1,3 @@
+const BUILD_MODE_ARGUMENT_INDEX = 2;
+process.argv[BUILD_MODE_ARGUMENT_INDEX] = 'dev';
+await import('./build.ts');

package/templates/default/scripts/esbuild-plugins.ts.ejs

@@ -0,0 +1,20 @@
+import type { Plugin } from 'esbuild';
+<%- render('dev-utils-import') -%>
+
+/**
+ * The esbuild plugins obsidian-dev-utils' own build does not already register.
+ *
+ * `build()` and `dev()` spread `customEsbuildPlugins` into their plugin list, which is the whole seam.
+ * They ship a svelte wrapper and a sass plugin built in -- which is exactly why svelte and SCSS work on
+ * these presets untouched -- but nothing for Vue, so `esbuild-plugin-vue3` was installed and never
+ * wired in, and any project reaching a `.vue` file from its module graph failed with "No loader is
+ * configured for `.vue` files".
+ *
+ * Shared by `build.ts` and `dev.ts` rather than written into each: one list, one place to add to.
+ */
+<%# Each per-answer partial ends its entry with a comma so two of them concatenate into a valid list. -%>
+<%# The LAST one's comma is then a trailing comma, which the shared ESLint config rejects, so it is -%>
+<%# stripped here rather than by making every partial know whether it is last. -%>
+<%# With no entry at all the list is `[]` on one line, which is how the formatter writes an empty array. -%>
+<% const devUtilsPlugins = render('dev-utils-plugin').replace(/,(?<Trailing>\s*)$/, '$<Trailing>'); -%>
+export const customEsbuildPlugins: Plugin[] = [<%- devUtilsPlugins === '' ? '' : `\n${devUtilsPlugins}` -%>];

package/templates/default/scripts/esbuild-plugins.ts@dev-utils-import_vue.ejs

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

package/templates/default/scripts/esbuild-plugins.ts@dev-utils-plugin_vue.ejs

@@ -0,0 +1 @@
+  vuePlugin(),

package/templates/default/scripts/esbuild-plugins.ts@dev-utils-plugin_wasm.ejs

@@ -0,0 +1,13 @@
+  // The obsidian-dev-utils `build()` owns the esbuild options, so the `.wasm` loader is set from inside a
+  // Plugin -- the one seam it exposes. Same decision as the standalone preset makes with a plain
+  // `loader` option, and for the same reason: `esbuild-plugin-wasm` emits a top-level `await`, which
+  // Esbuild supports only for `esm` output, and an Obsidian bundle is `cjs`.
+  {
+    name: 'wasm-binary-loader',
+    setup(build): void {
+      build.initialOptions.loader = {
+        ...build.initialOptions.loader,
+        '.wasm': 'binary'
+      };
+    }
+  },

package/templates/default/scripts/eslint-config.ts.ejs

@@ -0,0 +1,113 @@
+import type { Linter } from 'eslint';
+
+import {
+  defineConfig,
+  globalIgnores
+} from 'eslint/config';
+import { defineEslintConfigs } from 'obsidian-dev-utils/script-utils/linters/eslint-config';
+
+export const configs: Linter.Config[] = defineEslintConfigs({
+  customConfigs(context) {
+    return defineConfig(
+      globalIgnores([
+        // `defineEslintConfigs` ignores whatever `.gitignore` names, which already covers `main.js`,
+        // `dist` and `node_modules`. These four it cannot: the three extensions are not TypeScript and so
+        // Are governed by no config object of its own, and `demo-vault/` is COMMITTED, so it is in no
+        // Ignore file. The demo scripts show unusual module and `require` styles on purpose; a linter that
+        // "fixes" them breaks the lesson.
+        '**/*.cjs',
+        '**/*.js',
+        '**/*.mjs',
+        'demo-vault/**'
+      ]),
+      {
+        files: context.allFiles(),
+        rules: {
+          // `process.env['BUILD']` is not a style choice. TypeScript's `noPropertyAccessFromIndexSignature`
+          // — which `@tsconfig/strictest` turns on, and this preset inherits — REJECTS the dotted form on
+          // An index signature, so the compiler and this rule disagree about the same line. The compiler
+          // Wins, because its complaint is an error and this one is a preference. Biome's `useLiteralKeys`
+          // Is turned off in `biome.jsonc` for exactly the same reason. The shared config sets
+          // `dot-notation` only over `context.testFiles`, and only with the two class-property allowances,
+          // So this clash is not handled upstream and has to be re-stated here.
+          '@typescript-eslint/dot-notation': ['error', { allowIndexSignaturePropertyAccess: true }]
+        }
+      },
+      {
+        // `moment` is banned for bundle size, which does not apply here: Obsidian bundles it and
+        // Re-exports it, so it is imported from `'obsidian'` and the dependency exists only so
+        // `moment.Duration` and friends type-check against the version the app actually runs. A no-op
+        // Unless the project depends on it. Both file sets matter: the rule reads the dependency out of
+        // `package.json` and the import out of the source.
+        files: [...context.sourceFiles, 'package.json'],
+        rules: {
+          'depend/ban-dependencies': ['error', { allowed: ['moment'] }]
+        }
+      },
+      {
+        // Scoped to the source files, not to everything, because the rule comes from
+        // `obsidianmd.configs.recommended` and the shared config scopes THAT to `context.sourceFiles`. A
+        // Flat-config rule entry is resolved against the plugins in scope for the file it matches, so
+        // Naming an obsidianmd rule over a wider set is not a wider check -- it is
+        // "could not find plugin", and ESLint refuses to start.
+        files: context.sourceFiles,
+        rules: {
+          'obsidianmd/ui/sentence-case': [
+            'error',
+            {
+              brands: [<% _sentenceCaseBrands.forEach((brand, i) => { %>'<%- brand %>'<%= i < _sentenceCaseBrands.length - 1 ? ', ' : '' %><% }); %>]
+            }
+          ]
+        }
+      },
+      {
+        // Two imports only a build or a bundler can resolve. `src/main.ts` imports the stylesheet
+        // `npm run build:styles` writes, which is absent until the first build and present after it -- so an
+        // Inline disable is wrong in both states, an unresolved import before and an unused directive after.
+        // `data-url:` is a parcel scheme that only parcel's own resolver knows. Both patterns are named
+        // Whether or not the answer that emits them was chosen: a pattern matching nothing costs nothing.
+        files: context.sourceFiles,
+        rules: {
+          'import-x/no-unresolved': ['error', { ignore: ['^data-url:', String.raw`tailwind\.generated\.css$`] }]
+        }
+      },
+      {
+        // Files whose default export is dictated from outside, the way the shared config already exempts
+        // The root configs and `src/main.ts`. An ambient `declare module` describes how a `.wasm`, a CSS
+        // Module or a single-file component is imported, and each of those IS a default import. The two
+        // Stubs stand in for such modules in the unit runners, and typesafe-i18n's generator reads each
+        // Locale's default export.
+        files: [
+          '**/*.d.ts',
+          'scripts/*-stub.ts',
+          'src/i18n/*/index.ts'
+        ],
+        rules: {
+          'import-x/no-default-export': 'off'
+        }
+      },
+      {
+        // Every rollup plugin is imported as `<name>Module` on purpose: its types describe the CommonJS
+        // Shape, so `asPluginFactory` unwraps the import and the unwrapped binding takes the plugin's own
+        // Name. Which plugins are imported depends on the answers, so an inline directive per import would
+        // Have to be composed per answer. Named whether or not rollup was chosen, like the patterns above.
+        files: ['scripts/rollup.config.ts'],
+        rules: {
+          'import-x/no-rename-default': 'off'
+        }
+      }
+    );
+  },
+  editContext(context) {
+    // The shared config's root-config list is the three a plugin built on `obsidian-dev-utils` always has
+    // (`commitlint.config.ts`, `eslint.config.mts`, `vitest.config.ts`). This project may also have a root
+    // Wrapper for another runner, and a root `*.ts` that ESLint reaches but no config object matches is a
+    // File linted with nothing. Named unconditionally: a glob matching no emitted file costs nothing, and
+    // `tsconfig.json` includes `./*.ts` whichever of them was written.
+    context.rootConfigFiles.push(
+      'jest.config.ts',
+      'vite.config.ts',
+      'webpack.config.ts'
+    );<%- render('extra-files') %>
+  }
+});

package/templates/default/scripts/eslint-config.ts@extra-files_has-e2e.ejs

@@ -0,0 +1,7 @@
+
+
+    // Typed rules need every file ESLint reaches to be in the tsconfig `include`, so this list and the
+    // Emitted `tsconfig.json`'s `include` have to agree. `e2e/` reaches both through the same `has-e2e`
+    // Partial, and only when an end-to-end runner was chosen. It goes in `testFiles` rather than
+    // `sourceFiles`, because an end-to-end spec is a test and wants the same relaxations one gets.
+    context.testFiles.push('e2e/**/*.ts');

package/templates/default/scripts/find-overexposed-fix.ts.ejs

@@ -0,0 +1,26 @@
+import process from 'node:process';
+import { parseArgs } from 'node:util';
+import {
+  CliTaskResult,
+  wrapCliTask
+} from 'obsidian-dev-utils/script-utils/cli-utils';
+import {
+  findOverExposure,
+  formatOverExposureFindings
+} from 'obsidian-dev-utils/script-utils/linters/over-exposure';
+
+const [, , ...$arguments] = process.argv;
+
+const { values } = parseArgs({
+  // eslint-disable-next-line unicorn/name-replacements -- `args` is `node:util`'s own option name.
+  args: $arguments,
+  options: {
+    force: { type: 'boolean' }
+  }
+});
+
+await wrapCliTask(() => {
+  const findings = findOverExposure({ projectFolder: process.cwd(), shouldFix: true, shouldForce: values.force ?? false });
+  process.stdout.write(formatOverExposureFindings(findings, { baseFolder: process.cwd() }));
+  return CliTaskResult.Success(findings.every((finding) => finding.wasFixed));
+});

package/templates/default/scripts/find-overexposed.ts.ejs

@@ -0,0 +1,15 @@
+import process from 'node:process';
+import {
+  CliTaskResult,
+  wrapCliTask
+} from 'obsidian-dev-utils/script-utils/cli-utils';
+import {
+  findOverExposure,
+  formatOverExposureFindings
+} from 'obsidian-dev-utils/script-utils/linters/over-exposure';
+
+await wrapCliTask(() => {
+  const findings = findOverExposure({ projectFolder: process.cwd() });
+  process.stdout.write(formatOverExposureFindings(findings, { baseFolder: process.cwd() }));
+  return CliTaskResult.Success(findings.length === 0);
+});

package/templates/default/scripts/format-check.ts.ejs

@@ -0,0 +1,4 @@
+<%# Formatting is keyed on the TOOL first, unlike every other template here, which splits on the -%>
+<%# preset. What `npm run format:check` runs is decided by the formatter answer; only dprint has a -%>
+<%# preset-specific runner, so it splits again underneath. -%>
+<%- render('tool') -%>

package/templates/default/scripts/format-check.ts@tool_biome-formatter.ejs

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+import process from 'node:process';
+
+try {
+  execSync('biome format .', { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}

package/templates/default/scripts/format-check.ts@tool_dprint.ejs

@@ -0,0 +1,3 @@
+<%# The dev-utils presets go through the dev-utils runner, which resolves `dprint.json` from the repo root -%>
+<%# and falls back to the bundled one; standalone has no dev-utils and shells out directly. -%>
+<%- render('preset') -%>

package/templates/default/scripts/format-check.ts@tool_dprint@preset_dev-utils.ejs

@@ -0,0 +1,7 @@
+import process from 'node:process';
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+import { format } from 'obsidian-dev-utils/script-utils/formatters/dprint';
+
+const [, , ...paths] = process.argv;
+
+await wrapCliTask(() => format({ paths, rewrite: false }));

package/templates/default/scripts/format-check.ts@tool_dprint@preset_standalone.ejs

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+import process from 'node:process';
+
+try {
+  execSync('dprint check', { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}

package/templates/default/scripts/format-check.ts@tool_prettier.ejs

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+import process from 'node:process';
+
+try {
+  execSync('prettier --check .', { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}

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

@@ -0,0 +1,4 @@
+<%# Formatting is keyed on the TOOL first, unlike every other template here, which splits on the -%>
+<%# preset. What `npm run format` runs is decided by the formatter answer; only dprint has a -%>
+<%# preset-specific runner, so it splits again underneath. -%>
+<%- render('tool') -%>

package/templates/default/scripts/format.ts@tool_biome-formatter.ejs

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+import process from 'node:process';
+
+try {
+  execSync('biome format --write .', { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}

package/templates/default/scripts/format.ts@tool_dprint.ejs

@@ -0,0 +1,3 @@
+<%# The dev-utils presets go through the dev-utils runner, which resolves `dprint.json` from the repo root -%>
+<%# and falls back to the bundled one; standalone has no dev-utils and shells out directly. -%>
+<%- render('preset') -%>

package/templates/default/scripts/format.ts@tool_dprint@preset_dev-utils.ejs

@@ -0,0 +1,7 @@
+import process from 'node:process';
+import { wrapCliTask } from 'obsidian-dev-utils/script-utils/cli-utils';
+import { format } from 'obsidian-dev-utils/script-utils/formatters/dprint';
+
+const [, , ...paths] = process.argv;
+
+await wrapCliTask(() => format({ paths }));

package/templates/default/scripts/format.ts@tool_dprint@preset_standalone.ejs

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+import process from 'node:process';
+
+try {
+  execSync('dprint fmt', { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}

package/templates/default/scripts/format.ts@tool_prettier.ejs

@@ -0,0 +1,8 @@
+import { execSync } from 'node:child_process';
+import process from 'node:process';
+
+try {
+  execSync('prettier --write .', { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}