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

package/templates/default/cspell.json.ejs

@@ -0,0 +1,67 @@
+{
+  "version": "0.2",
+  "ignorePaths": [
+    "**/*.wasm",
+    "dist",
+    "node_modules",
+    "tsconfig.tsbuildinfo"
+  ],
+  "dictionaryDefinitions": [],
+  "dictionaries": [],
+  "words": [
+    <%- JSON.stringify(authorGitHubName) %>,
+    "Invocables",
+    "assemblyscript",
+    "autoprefixer",
+    "biomejs",
+    "codicon",
+    "codemirror",
+    "collab",
+    "commitlint",
+    "creatordate",
+    "dblclick",
+    "dprint",
+    "edgedriver",
+    "eresolve",
+    "esbuild",
+    "frontmatter",
+    "geckodriver",
+    "ghsa",
+    "hotreload",
+    "inlines",
+    "jiti",
+    "lezer",
+    "liberapay",
+    "linkinator",
+    "lintstagedrc",
+    "lucide",
+    "markdownlint",
+    "mnaoumov",
+    "obsidianmd",
+    "onload",
+    "onunload",
+    "postcss",
+    "preact",
+    "svelte",
+    "tailwindcss",
+    "tidelift",
+    "tsbuildinfo",
+    "tseslint",
+    "tslib",
+    "typesafe",
+    "unrs",
+    "untracked",
+    "unvalidated",
+    "vitest",
+    "wabt",
+    "wasm",
+    "wdio",
+    "wikilinks"
+  ],
+  "ignoreRegExpList": [
+    "/GHSA(-[0-9a-z]{4}){3}/g"
+  ],
+  "ignoreWords": [],
+  "import": [],
+  "enabled": true
+}

package/templates/default/demo-vault/.gitignore.ejs

@@ -0,0 +1,15 @@
+# Churny, runtime-generated Obsidian state.
+.obsidian/workspace*.json
+.obsidian/hotkeys.json
+
+# Both plugins in this vault are injected at release time by obsidian-dev-utils: the freshly built plugin
+# Under test, and the obsidian-dev-utils-owned Demo Vault Helper, which installs, configures and enables
+# CodeScript Toolkit at runtime. Nothing plugin-related is committed.
+#
+# CodeScript Toolkit also lands here the first time you open this vault in Obsidian, which is where the
+# Demo-vault button suite picks it up from.
+.obsidian/plugins/*
+
+# Written by the demo buttons in `01 Sample commands.md`; clicking through the walkthrough should not
+# Leave the repository dirty.
+Materials/01 Sample commands/Scratch note.md

package/templates/default/demo-vault/.obsidian/app.json.ejs

@@ -0,0 +1,4 @@
+{
+  "attachmentFolderPath": "_assets/attachments",
+  "showUnsupportedFiles": true
+}

package/templates/default/demo-vault/.obsidian/community-plugins.json.ejs

@@ -0,0 +1,4 @@
+[
+  "demo-vault-helper",
+  <%- JSON.stringify(pluginId) %>
+]

package/templates/default/demo-vault/00 Start.md.ejs

@@ -0,0 +1,32 @@
+# Start here
+
+This is an [Obsidian](https://obsidian.md/) vault that documents the [<%= pluginName %>](https://github.com/<%= authorGitHubName %>/obsidian-<%= pluginId %>/) plugin by demonstrating it. Every feature has a note that says what it does and why you would want it, and a button you can press to watch it happen.
+
+<%= pluginDescription %>
+
+## Your first minute
+
+Below this paragraph is a **code button** — a captioned rectangle. It is not a picture of a button: **clicking it runs the code**, and the result appears underneath it. The `</>` toggle beside the caption reveals the code it runs, so nothing here is a black box.
+
+```code-button
+---
+caption: Run the Sample command
+---
+require('/demoSetup.ts').runSampleCommand(app);
+```
+
+A notice should have appeared in the top-right corner. That is the plugin's `Sample` command running — the same thing you get from **<%= pluginName %>: Sample** in the Command Palette (`Ctrl+P` / `Cmd+P`).
+
+Every button in this vault also states its **manual equivalent**, so you learn the real steps rather than depending on the buttons.
+
+## Features
+
+| Note | What it covers |
+| --- | --- |
+| [01 Sample commands](<./01 Sample commands.md>) | The commands the plugin adds, and how to run them. |
+| [02 Settings](<./02 Settings.md>) | Every setting, by the key it is stored under in `data.json`. |
+<%- render('features') -%>
+
+## Materials
+
+`Materials/` holds the notes the walkthroughs operate on, so you never have to build a fixture to see a feature working.

package/templates/default/demo-vault/00 Start.md@features_wasm.ejs

@@ -0,0 +1 @@
+| [03 WebAssembly](<./03 WebAssembly.md>) | The WebAssembly module the plugin ships, and the command that calls it. |

package/templates/default/demo-vault/01 Sample commands.md.ejs

@@ -0,0 +1,38 @@
+# Sample commands
+
+<%= pluginName %> adds the sample commands below to the Command Palette. They are the scaffolded samples the generator gives every new plugin — replace them with your own, and rewrite this note as you do.
+
+## Sample
+
+A **global** command: it runs wherever you are, whether or not a note is open. This one shows a notice.
+
+```code-button
+---
+caption: Run Sample
+---
+require('/demoSetup.ts').runSampleCommand(app);
+```
+
+Manual equivalent: open the Command Palette (`Ctrl+P` / `Cmd+P`) and run **<%= pluginName %>: Sample**.
+
+## Sample editor
+
+An **editor** command: it only appears when a note is open for editing, and it acts on the cursor. This one inserts text where the cursor is.
+
+Editor commands need a live editor, and this vault opens notes in reading view — so the button below opens [Scratch note](<./Materials/01 Sample commands/Scratch note.md>) in Source mode first, puts the cursor at the end, and only then runs the command.
+
+```code-button
+---
+caption: Run Sample editor on the scratch note
+---
+await require('/demoSetup.ts').runSampleEditorCommandOnScratchNote(app);
+```
+
+Manual equivalent: open `Scratch note`, switch it to Source mode (`Ctrl+E` / `Cmd+E`), place the cursor, and run **<%= pluginName %>: Sample editor**.
+
+The scratch note is gitignored, so whatever you write in it stays out of your repository.
+
+## Where they are defined
+
+**Sample** and **Sample editor** live in `src/plugin.ts`, registered in `onloadImpl` with `this.addCommand(...)`. The command id you see in `demoSetup.ts` is `<%= pluginId %>:sample` — Obsidian prefixes every command id with the plugin id from `manifest.json`.
+<%- render('commands') -%>

package/templates/default/demo-vault/01 Sample commands.md@commands_wasm.ejs

@@ -0,0 +1,4 @@
+
+## Sample WASM answer
+
+A third command, which calls into the WebAssembly module the plugin ships. It is registered in `src/wasm/sample-command.ts` rather than `src/plugin.ts`, and [03 WebAssembly](<./03 WebAssembly.md>) walks through it.

package/templates/default/demo-vault/02 Settings.md.ejs

@@ -0,0 +1,40 @@
+# Settings
+
+Every setting <%= pluginName %> stores, listed by the **key it is written under in `data.json`** rather than by its display label — that is what you see when you open the file, hit a sync conflict, or read a support thread.
+
+Find them in Obsidian under **Settings → Community plugins → <%= pluginName %>**.
+
+## General
+
+- `textSetting`
+  - free text, shown in the settings tab as **Text setting name**. The scaffolded sample setting; nothing reads it yet.
+
+## Try it
+
+Change the setting without leaving this note. The change applies live — the plugin's settings component picks it up, so there is no reload.
+
+```code-button
+---
+caption: Set textSetting to "changed by the demo"
+---
+await require('/demoSetup.ts').setTextSetting(app, 'changed by the demo');
+```
+
+Manual equivalent: type the same value into **Text setting name** in the settings tab.
+
+Open the settings tab now and the field shows the new value. When you are done, put it back:
+
+```code-button
+---
+caption: Reset textSetting to its default
+---
+await require('/demoSetup.ts').resetTextSetting(app);
+```
+
+Manual equivalent: type `defaultText` back into the field.
+
+## Adding your own
+
+Settings are declared as plain properties on the `PluginSettings` class in `src/plugin-settings.ts`; the property's initial value **is** its default. `src/plugin-settings-tab.ts` renders one row per setting, and `src/plugin-settings-component.ts` is where migrations and validators go.
+
+When you add one, add it to this note too. The demo-vault coverage suite can be told to fail the build when a setting is documented nowhere — see the commented reflection spec in `src/demo-vault.no-app.integration.test.ts`.

package/templates/default/demo-vault/03 WebAssembly.md.ejs

@@ -0,0 +1,34 @@
+# WebAssembly
+
+<%= pluginName %> ships a working WebAssembly module and a command that calls into it. WebAssembly is how a plugin uses code compiled from Rust, C, Go or AssemblyScript — and unlike a native Node binary it runs on mobile too, so it is the portable route.
+
+```code-button
+---
+caption: Run Sample WASM answer
+---
+require('/demoSetup.ts').runSampleWasmAnswerCommand(app);
+```
+
+A notice saying `WebAssembly says: 42` should have appeared. The number was not computed in JavaScript: the command loaded the module, called its exported `answer()` function, and showed what it returned.
+
+Manual equivalent: open the Command Palette (`Ctrl+P` / `Cmd+P`) and run **<%= pluginName %>: Sample WASM answer**.
+
+## The module
+
+The module is `src/wasm/module.wasm` in the plugin's repository, 39 bytes long. Its source is checked in beside it as `src/wasm/module.wat`:
+
+```wat
+(module
+  (func (export "answer") (result i32)
+    i32.const 42))
+```
+
+It exports one function, `answer()`, returning the constant `42`, and imports nothing at all — no host functions, no memory — so returning that number is the only thing it can do. `wat2wasm` from [WABT](https://github.com/WebAssembly/wabt) rebuilds the binary from that source byte for byte.
+
+## Why it is inside main.js
+
+Obsidian installs a plugin as `main.js`, `styles.css` and `manifest.json`, and nothing else. A module left beside the bundle as a separate `.wasm` file works in the repository and is missing from every installed copy. So the build embeds the module in `main.js`, which is why this command works in the released plugin and not only in development.
+
+## Where it is defined
+
+The command is registered in `src/wasm/sample-command.ts`, and `src/wasm/answer.ts` loads the module. `src/wasm/README.md` explains how to replace the sample with a module of your own.

package/templates/default/demo-vault/Materials/01 Sample commands/Scratch note.md.ejs

@@ -0,0 +1,5 @@
+# Scratch note
+
+A note for [01 Sample commands](<../../01 Sample commands.md>) to write into, so the walkthrough has somewhere to run an editor command without touching anything you care about.
+
+It is gitignored: whatever the buttons leave here stays out of the repository.

package/templates/default/demo-vault/README.md.ejs

@@ -0,0 +1,10 @@
+# <%= pluginName %> demo vault
+
+This is an [Obsidian](https://obsidian.md/) vault demonstrating features of the [<%= pluginName %>](https://github.com/<%= authorGitHubName %>/obsidian-<%= pluginId %>) plugin.
+
+## Opening this vault
+
+- **If you already have the plugin installed**, run the **<%= pluginName %>: Open demo vault** command — it downloads and opens the latest demo vault automatically.
+- **Otherwise**, download `<%= pluginId %>-demo-vault.zip` from the [plugin releases](https://github.com/<%= authorGitHubName %>/obsidian-<%= pluginId %>/releases), unzip it, and in Obsidian choose `Manage vaults...` → `Open folder as vault` → select the `<%= pluginId %>-demo-vault-<version>` folder it unzips into.
+
+On first open, Obsidian treats the vault as untrusted — choose **Trust author and enable plugins** (or enable Community plugins manually), then open [00 Start](<./00 Start.md>).

package/templates/default/demo-vault/_assets/CodeScriptToolkit/demoSetup.ts.ejs

@@ -0,0 +1,88 @@
+import type {
+  App,
+  TFile
+} from 'obsidian';
+
+import {
+  MarkdownView,
+  Notice
+} from 'obsidian';
+import { configureCommunityPlugin } from 'obsidian-dev-utils/obsidian/community-plugins';
+
+// Shared code for every `code-button` in this vault, so each note's button stays a one-liner instead of a
+// Block copy-pasted across notes.
+//
+// The plugin id has to match `manifest.json` exactly: commands are keyed by it, and so is `data.json`.
+const PLUGIN_ID = '<%= pluginId %>';
+
+const SCRATCH_NOTE_PATH = 'Materials/01 Sample commands/Scratch note.md';
+
+const DEFAULT_TEXT_SETTING = 'defaultText';
+
+/**
+ * Runs the plugin's `Sample` command, which shows a notice.
+ *
+ * Manual equivalent: `<%= pluginName %>: Sample` in the Command Palette.
+ */
+export function runSampleCommand(app: App): void {
+  app.commands.executeCommandById(`${PLUGIN_ID}:sample`);
+}
+
+/**
+ * Opens the scratch note in editing mode and runs the plugin's `Sample editor` command against it.
+ *
+ * The command is an editor command, so it needs a live editor -- and this vault opens notes in reading
+ * view, where there is none. Opening the scratch note in Source mode first is what a reader would do by
+ * hand before running the command.
+ *
+ * Manual equivalent: open `Scratch note`, switch it to Source mode, put the cursor where you want the text,
+ * and run `<%= pluginName %>: Sample editor` in the Command Palette.
+ */
+export async function runSampleEditorCommandOnScratchNote(app: App): Promise<void> {
+  const scratchNote = await ensureScratchNote(app);
+  const leaf = app.workspace.getLeaf(false);
+  await leaf.openFile(scratchNote, { state: { mode: 'source' } });
+
+  const view = app.workspace.getActiveViewOfType(MarkdownView);
+  if (!view) {
+    new Notice('Could not open the scratch note in editing mode.');
+    return;
+  }
+
+  view.editor.setCursor(view.editor.lastLine());
+  app.commands.executeCommandById(`${PLUGIN_ID}:sample-editor`);
+  new Notice('Ran the Sample editor command. Look at the end of the scratch note.');
+}
+<%- render('commands') -%>
+
+/**
+ * Sets the plugin's `textSetting` to the given value.
+ *
+ * `configureCommunityPlugin` routes through the plugin's own settings component while it is loaded, so the
+ * change applies live -- no window reload, and no writing `data.json` behind a running plugin's back, which
+ * it would overwrite from memory as it unloads.
+ *
+ * Manual equivalent: change the same field in **Settings -> Community plugins -> <%= pluginName %>**.
+ */
+export async function setTextSetting(app: App, value: string): Promise<void> {
+  await configureCommunityPlugin({ app, pluginId: PLUGIN_ID, settings: { textSetting: value } });
+  new Notice(`textSetting is now "${value}". It is live -- no reload needed.`);
+}
+
+/**
+ * Puts `textSetting` back to the value a fresh install starts with, so exploring this note leaves the vault
+ * as you found it.
+ *
+ * Manual equivalent: type the default back into the same field in the settings tab.
+ */
+export async function resetTextSetting(app: App): Promise<void> {
+  await setTextSetting(app, DEFAULT_TEXT_SETTING);
+}
+
+async function ensureScratchNote(app: App): Promise<TFile> {
+  const existing = app.vault.getFileByPath(SCRATCH_NOTE_PATH);
+  if (existing) {
+    return existing;
+  }
+  return await app.vault.create(SCRATCH_NOTE_PATH, '# Scratch note\n\nRun the Sample editor command here.\n');
+}

package/templates/default/demo-vault/_assets/CodeScriptToolkit/demoSetup.ts@commands_wasm.ejs

@@ -0,0 +1,10 @@
+
+/**
+ * Runs the plugin's `Sample WASM answer` command, which calls into the bundled WebAssembly module and shows
+ * what it returned.
+ *
+ * Manual equivalent: `<%= pluginName %>: Sample WASM answer` in the Command Palette.
+ */
+export function runSampleWasmAnswerCommand(app: App): void {
+  app.commands.executeCommandById(`${PLUGIN_ID}:sample-wasm-answer`);
+}

package/templates/default/demo-vault/_assets/CodeScriptToolkit/startup.ts.ejs

@@ -0,0 +1,17 @@
+// Per-vault startup script, run by the universal Demo Vault Helper plugin (through CodeScript Toolkit's
+// `require`) once CodeScript Toolkit is installed and enabled. This is where a demo vault does its own
+// Startup setup. Here it just opens the landing note.
+
+import type { App } from 'obsidian';
+
+const START_NOTE_PATH = '00 Start.md';
+
+// CodeScript Toolkit calls the exported `invoke` on load (its `startupScriptPath` setting, which the Demo
+// Vault Helper points here). A top-level script with no `invoke` export throws
+// `this.startupScript.invoke is not a function` the moment the vault loads.
+export async function invoke(app: App): Promise<void> {
+  const startNote = app.vault.getFileByPath(START_NOTE_PATH);
+  if (startNote) {
+    await app.workspace.getLeaf(false).openFile(startNote);
+  }
+}

package/templates/default/dprint.json_dev-utils.ejs

@@ -0,0 +1,10 @@
+{
+  "extends": "./node_modules/obsidian-dev-utils/dist/templates/dprint.json",
+  "excludes": [
+    "dist",
+    "**/node_modules",
+    "**/*-lock.json",
+    "**/*.md",
+    "demo-vault"
+  ]
+}

package/templates/default/dprint.json_standalone.ejs

@@ -0,0 +1,26 @@
+{
+  "typescript": {
+    "bracePosition": "sameLine",
+    "constructSignature.spaceAfterNewKeyword": true,
+    "constructorType.spaceAfterNewKeyword": true,
+    "exportDeclaration.forceMultiLine": "whenMultiple",
+    "functionExpression.spaceAfterFunctionKeyword": true,
+    "importDeclaration.forceMultiLine": "whenMultiple",
+    "lineWidth": 1000,
+    "quoteStyle": "alwaysSingle",
+    "trailingCommas": "never"
+  },
+  "json": {},
+  "markdown": {},
+  "excludes": [
+    "dist",
+    "**/node_modules",
+    "**/*-lock.json",
+    "**/*.md"
+  ],
+  "plugins": [
+    "npm:@dprint/typescript@0.96.1",
+    "npm:@dprint/json@0.23.0",
+    "npm:@dprint/markdown@0.23.2"
+  ]
+}

package/templates/default/e2e/sample.spec.ts_obsidian-test.ejs

@@ -0,0 +1,16 @@
+// `node:test`'s `test()` returns a promise that the runner owns and awaits itself, so nothing here
+// Should await it -- but that makes every call a floating promise. `void` is the marker
+// `@typescript-eslint/no-floating-promises` accepts for exactly this case, and it keeps the rule armed
+// For the tests you write yourself.
+<%- render('lint-no-void-disable') -%>
+import assert from 'node:assert';
+import test from 'node:test';
+import { embedded } from 'obsidian-test';
+
+embedded((app) => {
+  void test('<%= pluginName %> loads successfully', () => {
+    assert.ok(app.workspace, 'Workspace should be available');
+  });
+<%- render('unofficial') -%>
+});
+<%- render('lint-no-void-enable') -%>

package/templates/default/e2e/sample.spec.ts_obsidian-test@lint-no-void-disable_dev-utils.ejs

@@ -0,0 +1,3 @@
+// This file is nothing but such calls, so the ban on `void` is lifted for the whole of it rather than line
+// By line.
+/* eslint-disable no-void -- See above: no call in this file awaits its `node:test`, deliberately. */

package/templates/default/e2e/sample.spec.ts_obsidian-test@lint-no-void-enable_dev-utils.ejs

@@ -0,0 +1 @@
+/* eslint-enable no-void -- See the top of the file. */

package/templates/default/e2e/sample.spec.ts_obsidian-test@unofficial_with-unofficial.ejs

@@ -0,0 +1,13 @@
+
+  void test('plugin is registered', () => {
+    const pluginId = '<%= pluginId %>';
+    const manifest = app.plugins.manifests[pluginId];
+    assert.ok(manifest, `Plugin "${pluginId}" should have a manifest`);
+    assert.strictEqual(manifest.id, pluginId);
+  });
+
+  void test('sample command exists', () => {
+    const commands = app.commands.listCommands();
+    const sampleCommand = commands.find((command) => command.id === '<%= pluginId %>:sample');
+    assert.ok(sampleCommand, 'Sample command should be registered');
+  });

package/templates/default/e2e/sample.spec.ts_wdio-obsidian.ejs

@@ -0,0 +1,7 @@
+describe('<%= pluginName %>', () => {
+  it('should load Obsidian', async () => {
+    const title = await browser.getTitle();
+    expect(title).toContain('Obsidian');
+  });
+<%- render('unofficial') -%>
+});

package/templates/default/e2e/sample.spec.ts_wdio-obsidian@unofficial_with-unofficial.ejs

@@ -0,0 +1,15 @@
+
+  it('should have the plugin enabled', async () => {
+    const result = await browser.executeObsidian(({ app }) => {
+      return app.plugins.manifests['<%= pluginId %>']?.id;
+    });
+    expect(result).toBe('<%= pluginId %>');
+  });
+
+  it('should register the sample command', async () => {
+    const hasSampleCommand = await browser.executeObsidian(({ app }) => {
+      const commands = app.commands.listCommands();
+      return commands.some((command) => command.id === '<%= pluginId %>:sample');
+    });
+    expect(hasSampleCommand).toBe(true);
+  });

package/templates/default/eslint.config.mts_dev-utils.ejs

@@ -0,0 +1 @@
+export { configs as default } from './scripts/eslint-config.ts';

package/templates/default/eslint.config.mts_standalone.ejs

@@ -0,0 +1,119 @@
+import eslint from '@eslint/js';
+import obsidianmd from 'eslint-plugin-obsidianmd';
+import {
+  defineConfig,
+  globalIgnores
+} from 'eslint/config';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+const typeScriptFiles = [
+  'src/**/*.ts',
+  'src/**/*.tsx',
+  'scripts/**/*.ts',
+  // Root-level config files (`vitest.config.ts`, `commitlint.config.ts`, …). Typed rules need every file
+  // ESLint reaches to be in the tsconfig `include`, so these two lists have to agree — and `e2e/` is the
+  // Third member whenever an end-to-end runner is chosen. It was in neither list, and the plugin config
+  // Below still reached those files: every project with an e2e runner and ESLint died on "You have used
+  // A rule which requires type information", the largest single class of install-tier failures.
+  '*.ts',
+  'eslint.config.mts'<%- render('extra-files') %>
+];
+
+export default defineConfig(
+  globalIgnores([
+    '**/*.cjs',
+    '**/*.js',
+    '**/*.mjs',
+    // The demo scripts show unusual module and `require` styles on purpose; a linter that "fixes" them
+    // Breaks the lesson.
+    'demo-vault/**',
+    'dist/**',
+    'main.js'
+  ]),
+  {
+    extends: [
+      eslint.configs.recommended,
+      ...tseslint.configs.strictTypeChecked,
+      ...tseslint.configs.stylisticTypeChecked
+    ],
+    files: typeScriptFiles,
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        ...globals.node
+      },
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        },
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname
+      }
+    },
+    rules: {
+      // `process.env['BUILD']` is not a style choice. TypeScript's `noPropertyAccessFromIndexSignature`
+      // — which `@tsconfig/strictest` turns on — 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. This preset's `tsconfig.json` spells its strictness out
+      // Rather than extending `@tsconfig/strictest`, so the option is off today and the allowance is what
+      // Keeps the bracketed form writable if it is ever turned on. Biome's `useLiteralKeys` is turned off
+      // In `biome.jsonc` for exactly the same reason.
+      '@typescript-eslint/dot-notation': ['error', { allowIndexSignaturePropertyAccess: true }],
+      '@typescript-eslint/explicit-function-return-type': 'error',
+      '@typescript-eslint/explicit-member-accessibility': 'error',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          args: 'all',
+          argsIgnorePattern: '^_',
+          caughtErrors: 'all',
+          caughtErrorsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+          ignoreRestSiblings: true,
+          varsIgnorePattern: '^_'
+        }
+      ],
+      '@typescript-eslint/prefer-readonly': 'error',
+      'curly': 'error',
+      'eqeqeq': 'error',
+      'no-console': ['error', { allow: ['warn', 'error'] }],
+      'no-var': 'error',
+      'prefer-const': 'error',
+      'prefer-template': 'error'
+    }
+  },
+  ...obsidianmd.configs.recommended,
+  // The Obsidian rules — and the console ban — are about code that SHIPS and runs inside Obsidian: no
+  // Node built-ins, because of mobile, and no stray logging. The build scripts are Node by definition
+  // And a build script that says what it is doing is behaving correctly, so they are turned back off
+  // Outside `src/`. Done as an override rather than by re-scoping the shared config, which would drop
+  // The parser settings that come with it.
+  {
+    files: ['scripts/**/*.ts', '*.ts', 'eslint.config.mts'],
+    rules: {
+      'no-console': 'off',
+      'obsidianmd/no-nodejs-modules': 'off',
+      'obsidianmd/rule-custom-message': 'off'
+    }
+  },
+  {
+    rules: {
+      // `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.
+      'depend/ban-dependencies': ['error', { allowed: ['moment'] }]
+    }
+  },
+  {
+    rules: {
+      'obsidianmd/ui/sentence-case': [
+        'error',
+        {
+          brands: [<% _sentenceCaseBrands.forEach((brand, i) => { %>'<%- brand %>'<%= i < _sentenceCaseBrands.length - 1 ? ', ' : '' %><% }); %>]
+        }
+      ]
+    }
+  }
+);

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

@@ -0,0 +1,2 @@
+,
+  'e2e/**/*.ts'