ts-obsidian-ui-settings 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+[BOTTOM](#100---2026-01-11) [LICENSE](LICENSE) [ROADMAP](ROADMAP.md) [README](README.md)
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+
+### Added
+
+- No additions yet
+
+### Changed
+
+- No changes yet
+
+### Fixed
+
+- No fixes yet
+
+## [1.0.0] - 2026-01-11
+
+- Initial version
+
+### Features
+
+- Type-safe, extensible framework for Obsidian plugin settings
+- Support for multiple sub-tabs with compile-time enforced unique IDs
+- Declarative sub-tab registry for centralized management
+- Decoupled `PluginSettingsRenderContext` for isolated rendering
+- Automatic navigation and active-tab state handling
+- Seamless integration with `ts-obsidian-plugin` settings management
+- Designed for TypeScript and Rollup bundling in Obsidian plugins
+- SubTabs do not manage DOM ownership beyond their render call
+- Settings persistence handled via `plugin.saveSettings()`
+- No global state or side effects introduced by the framework
+
+[TOP](#changelog) [LICENSE](LICENSE) [ROADMAP](ROADMAP.md) [README](README.md)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dirk Brenckmann, db-developer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,233 @@
+[![npm version](https://img.shields.io/npm/v/ts-obsidian-ui-settings?color=blue)](https://www.npmjs.com/package/ts-obsidian-ui-settings)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![jsdoc](https://img.shields.io/static/v1?label=jsdoc&message=%20api%20&color=blue)](https://jsdoc.app/)
+![Build & Test](https://github.com/db-developer/ts-obsidian-ui-settings/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/db-developer/ts-obsidian-ui-settings/branch/master/graph/badge.svg)](https://codecov.io/gh/db-developer/ts-obsidian-ui-settings)
+
+[BOTTOM](#pluginsettingssubtabidmap--pluginsettingssubtabidttabids) [CHANGELOG](CHANGELOG.md) [LICENSE](LICENSE) [ROADMAP](ROADMAP.md)
+
+# ts-obsidian-ui-settings
+
+This module provides a **type-safe, extensible, and declarative framework** for building plugin settings in Obsidian with multiple sub-tabs. It allows separating rendering, state, and navigation responsibilities while keeping each sub-tab isolated and reusable.
+
+---
+
+## Motivation
+
+Obsidian plugins run in a constrained environment:
+
+- External runtime dependencies are discouraged
+- `node_modules` are typically not shipped with plugins
+- All code should be bundled into the final plugin file
+
+This module is therefore designed to:
+
+- Provide centralized navigation and active tab management
+- SubTabs are **isolated** and **reusable** across plugins
+- Full type safety with compile-time enforcement of SubTabIDs
+- Easy to extend by adding new SubTab classes and updating the registry
+- Integrate cleanly with Obsidian’s plugin environment
+- Be **bundled (e.g. via Rollup)** directly into the plugin output
+
+---
+
+## Features
+
+- Strongly typed sub-tab identifiers
+- Compile-time enforcement of unique IDs
+- Declarative sub-tab registry
+- Decoupled render context for each sub-tab
+- Automatic navigation and active-state management
+- Seamlessly works with [ts-obsidian-ui-settings](https://github.com/db-developer/ts-obsidian-ui-settings) settings management
+- Designed for **TypeScript** and **Rollup bundling** in Obsidian plugins
+- SubTabs **do not manage DOM ownership** beyond the render call
+- Settings persistence is always handled via `plugin.saveSettings()`
+- No global state or side effects are introduced by this framework
+
+[Details on AI assistance during development](AI.md)
+
+---
+
+## Usage
+
+### 1. Define SubTab IDs
+
+Use module augmentation to declare all valid sub-tab IDs:
+
+```ts
+// In a plugin-specific module (e.g., "my-plugin/subtabs")
+declare module 'my-plugin/subtabs' {
+  interface PluginSettingsSubTabIdMap {
+    'general': true;
+    'structure': true;
+    'ribbons': true;
+  }
+}
+```
+
+### 2. Implement SubTabs
+
+Each sub-tab must implement the `PluginSettingsSubTab<TSettings>` interface:
+
+```ts
+import type { PluginSettingsSubTab, PluginSettingsRenderContext } from "ts-obsidian-ui-settings";
+
+export class GeneralSubTab implements PluginSettingsSubTab<MySettings> {
+  header = 'General';
+
+  render(context: PluginSettingsRenderContext<MySettings>) {
+    const { containerEl, settings, saveSettings } = context;
+    containerEl.empty();
+    const el = containerEl.createEl('div', { text: `Current value: ${settings.someOption}` });
+
+    // Example input
+    const input = el.createEl('input', { type: 'text', value: settings.someOption });
+    input.addEventListener('change', (e) => {
+      settings.someOption = (e.target as HTMLInputElement).value;
+      saveSettings();
+    });
+  }
+}
+```
+
+### 3. Create the SubTab Registry
+
+```ts
+import type { PluginSettingsSubTabRegistry } from "ts-obsidian-ui-settings";
+
+const subTabRegistry: PluginSettingsSubTabRegistry<MySettings, MyPluginSubTabIdMap> = {
+  general: new GeneralSubTab(),
+  structure: new StructureSubTab(),
+  ribbons: new RibbonsSubTab(),
+};
+```
+
+### 4. Implement the Settings Tab Controller
+
+```ts
+import { PluginSettingsTabWithSubTabs } from "ts-obsidian-ui-settings";
+
+export class MyPluginSettingsTab extends PluginSettingsTabWithSubTabs<
+  MySettings,
+  MyPluginSubTabIdMap
+> {
+  constructor(app: App, plugin: PluginWithSettings<MySettings>) {
+    super(app, plugin, subTabRegistry, 'general');
+  }
+}
+```
+
+### 5. Register the Settings Tab in Obsidian
+
+```ts
+this.addSettingTab(new MyPluginSettingsTab(this.app, this));
+```
+
+---
+
+## Build & Test
+
+The package uses **Rollup** for bundling and Vitest for testing.
+
+```bash
+# Build
+npm run build
+
+# Run tests
+npm run test
+
+# Run tests in watch mode
+npm run test:watch
+```
+
+---
+
+## Bundling (Required)
+
+Obsidian does not support loading external npm modules at runtime.
+All dependencies must be bundled.
+
+### Rollup Example
+
+```js
+import resolve from "@rollup/plugin-node-resolve";
+import typescript from "@rollup/plugin-typescript";
+
+export default {
+  input: "src/main.ts",
+  output: {
+    file: "dist/main.js",
+    format: "cjs",
+  },
+  plugins: [
+    resolve(),
+    typescript(),
+  ],
+  external: ["obsidian"],
+};
+```
+
+---
+
+## API Reference
+
+### `PluginSettingsTabWithSubTabs<TSettings, TTabIds>`
+
+Abstract controller class that manages multiple sub-tabs in a plugin settings tab.
+
+**Constructor:**
+```ts
+// using import { App } from 'obsidian'
+// using import { PluginWithSettings, PluginSettingsSubTabRegistry, PluginSettingsSubTabId} from 'ts-obsidian-ui-settings'
+constructor(
+  app: App,
+  plugin: PluginWithSettings<TSettings>,
+  subTabs: PluginSettingsSubTabRegistry<TSettings, TTabIds>,
+  defaultSubTabId: PluginSettingsSubTabId<TTabIds>
+)
+```
+
+**Properties:**
+- `subTabs` – registry of all available sub-tabs
+- `activeSubTabId` – currently active sub-tab identifier
+
+**Methods:**
+- `display()` – renders the navigation and the active sub-tab
+- `renderNavigation(containerEl: HTMLElement)` – renders tab buttons
+- `renderActiveSubTab(containerEl: HTMLElement)` – renders the currently active sub-tab
+
+### `PluginSettingsSubTab<TSettings>`
+
+Interface that each sub-tab must implement.
+
+**Properties:**
+- `header: string` – the title displayed in the navigation
+
+**Methods:**
+- `render(context: PluginSettingsRenderContext<TSettings>): void` – renders the sub-tab content into the given container
+
+### `PluginSettingsRenderContext<TSettings>`
+
+Provides a decoupled rendering context for sub-tabs.
+
+**Properties:**
+- `containerEl: HTMLElement` – DOM container for rendering
+- `settings: TSettings` – plugin settings object
+- `saveSettings(): Promise<void>` – triggers settings persistence
+- `plugin: PluginWithSettings<TSettings>` – plugin reference
+
+### `PluginSettingsSubTabRegistry<TSettings, TTabIds>`
+
+A declarative mapping from sub-tab IDs to sub-tab instances.
+
+```ts
+type PluginSettingsSubTabRegistry<TSettings, TTabIds extends PluginSettingsSubTabIdMap> = {
+  [K in PluginSettingsSubTabId<TTabIds>]: PluginSettingsSubTab<TSettings>;
+};
+```
+
+### `PluginSettingsSubTabIdMap` / `PluginSettingsSubTabId<TTabIds>`
+
+Compile-time registry and union type of valid sub-tab identifiers using module augmentation.
+
+[TOP](#ts-obsidian-ui-settings) [CHANGELOG](CHANGELOG.md) [LICENSE](LICENSE) [ROADMAP](ROADMAP.md)

package/ROADMAP.md

@@ -0,0 +1,44 @@
+[BOTTOM](#notes) [CHANGELOG](CHANGELOG.md) [LICENSE](LICENSE) [README](README.md)
+
+# Roadmap
+
+This roadmap outlines planned features, improvements, and long-term goals for the **ts-obsidian-ui-settings** framework.
+
+---
+
+## Short-term Goals (Next Release Cycle)
+
+- Complete unit test coverage for all core classes and types
+- Add examples for complex sub-tab interactions
+- Improve documentation and API reference
+- Enhance TypeScript type safety for nested sub-tabs and settings
+- Introduce helper utilities for common sub-tab patterns
+
+---
+
+## Mid-term Goals
+
+- Provide built-in support for dynamic sub-tab loading
+- Implement optional persistent tab state across plugin reloads
+- Offer theming options for tab navigation buttons
+- Add more examples and templates for plugin developers
+
+---
+
+## Long-term Goals
+
+- Support fully pluggable sub-tab layouts
+- Integrate with other Obsidian plugin ecosystems
+- Provide a CLI or generator to scaffold settings tabs
+- Enable advanced type-level validation for plugin settings and dependencies
+- Explore support for internationalized sub-tab headers and dynamic translations
+
+---
+
+## Notes
+
+- All development will maintain full TypeScript compatibility.
+- No external runtime dependencies will be introduced, to remain fully bundleable in Obsidian plugins.
+- Sub-tabs will remain isolated and reusable across plugins.
+
+[TOP](#roadmap) [CHANGELOG](CHANGELOG.md) [LICENSE](LICENSE) [README](README.md)

package/index.d.ts

@@ -0,0 +1,242 @@
+import { PluginWithSettings } from 'ts-obsidian-plugin';
+import { PluginSettingTab, Plugin, App } from 'obsidian';
+
+/**
+ * Provides all dependencies required by a plugin settings sub-tab
+ * to render itself without owning navigation, lifecycle, or state
+ * management responsibilities.
+ *
+ * This context intentionally decouples rendering logic from the
+ * concrete PluginSettingTab implementation and avoids implicit
+ * access to global plugin state.
+ *
+ * @template TSettings
+ * The concrete settings type used by the plugin.
+ */
+interface PluginSettingsRenderContext<TSettings extends object> {
+    /**
+     * The DOM element into which the sub-tab must render its UI.
+     *
+     * This container is guaranteed to be empty before rendering
+     * and is owned by the parent settings tab controller.
+     */
+    readonly containerEl: HTMLElement;
+    /**
+     * The current plugin settings instance.
+     *
+     * This object is mutable; however, persistence must be triggered
+     * explicitly via {@link saveSettings}.
+     */
+    readonly settings: TSettings;
+    /**
+     * Persists the current settings state.
+     *
+     * Sub-tabs must call this method after mutating settings in order
+     * to ensure durability across reloads.
+     */
+    saveSettings(): Promise<void>;
+    /**
+     * Reference to the hosting plugin instance.
+     *
+     * The exposed type is intentionally restricted to
+     * {@link PluginWithSettings} in order to prevent sub-tabs
+     * from relying on concrete plugin implementations.
+     */
+    readonly plugin: PluginWithSettings<TSettings>;
+}
+
+/**
+ * Contract implemented by a single settings sub-tab.
+ *
+ * A sub-tab represents an isolated, self-contained rendering unit
+ * within a plugin settings page. It must not manage navigation,
+ * active state, or DOM cleanup outside of its assigned container.
+ *
+ * @template TSettings
+ * The concrete settings type used by the plugin.
+ */
+interface PluginSettingsSubTab<TSettings extends object> {
+    /**
+     * Human-readable tab header text.
+     *
+     * This value is typically derived from an i18n service and is
+     * expected to be stable for the lifetime of the tab instance.
+     */
+    get header(): string;
+    /**
+     * Renders the complete UI for this sub-tab.
+     *
+     * Implementations must assume that the provided container is empty
+     * and must not retain references to DOM elements beyond this call.
+     *
+     * @param ctx
+     * Rendering context providing access to settings, persistence,
+     * and plugin services.
+     */
+    render(ctx: PluginSettingsRenderContext<TSettings>): void;
+}
+
+/**
+ * Compile-time registry for all valid plugin settings sub-tab identifiers.
+ *
+ * This interface is intentionally empty and must be augmented via
+ * TypeScript module augmentation by consumers.
+ *
+ * The registry has no runtime representation and exists solely
+ * to enforce compile-time correctness and uniqueness of sub-tab IDs.
+ *
+ * @example
+ * ```ts
+ * // In a plugin-specific module (e.g. "my-plugin/subtabs")
+ * declare module "my-plugin/subtabs" {
+ *   interface PluginSettingsSubTabIdMap {
+ *     "general": true;
+ *     "structure": true;
+ *     "ribbons": true;
+ *   }
+ * }
+ *
+ * type SubTabId = keyof PluginSettingsSubTabIdMap;
+ * // "general" | "structure" | "ribbons"
+ * ```
+ */
+interface PluginSettingsSubTabIdMap {
+}
+
+/**
+ * Union type of all registered plugin settings sub-tab identifiers.
+ *
+ * This type represents the complete set of valid sub-tab IDs that
+ * may be used for navigation and persistence.
+ */
+type PluginSettingsSubTabId<T extends PluginSettingsSubTabIdMap> = keyof T;
+
+/**
+ * Declarative registry of settings sub-tabs.
+ *
+ * The keys of this registry are strongly typed sub-tab identifiers,
+ * guaranteed at compile time to be unique and valid.
+ *
+ * The registry is purely declarative and contains no UI state.
+ * Navigation, active state, and rendering orchestration are handled
+ * by the hosting settings tab controller.
+ *
+ * @template TSettings
+ * The concrete settings type used by the plugin.
+ *
+ * @template TTabIds
+ * The compile-time map of valid sub-tab identifiers, typically
+ * provided via TypeScript module augmentation.
+ *
+ * @example
+ * ```ts
+ * // 1. Declare valid sub-tab identifiers via module augmentation
+ * declare module "my-plugin/subtabs" {
+ *   interface PluginSettingsSubTabIdMap {
+ *     "general": true;
+ *     "structure": true;
+ *     "ribbons": true;
+ *   }
+ * }
+ *
+ * // 2. Derive the union type of valid sub-tab identifiers
+ * type SubTabId = keyof PluginSettingsSubTabIdMap;
+ * //   → "general" | "structure" | "ribbons"
+ *
+ * // 3. Define a registry mapping each sub-tab ID to its implementation
+ * const subTabs: PluginSettingsSubTabRegistry<
+ *   MyPluginSettings,
+ *   PluginSettingsSubTabIdMap
+ * > = {
+ *   general: new GeneralSettingsSubTab(),
+ *   structure: new StructureSettingsSubTab(),
+ *   ribbons: new RibbonSettingsSubTab(),
+ * };
+ *
+ * // Any missing, misspelled, or duplicate key would result
+ * // in a compile-time error.
+ * ```
+ */
+type PluginSettingsSubTabRegistry<TSettings, TTabIds extends PluginSettingsSubTabIdMap> = {
+    [K in PluginSettingsSubTabId<TTabIds>]: PluginSettingsSubTab<TSettings>;
+};
+
+/**
+ * Abstract settings tab controller with support for strongly typed sub-tabs.
+ *
+ * This class implements a declarative, extensible, and type-safe mechanism
+ * for rendering plugin settings using multiple sub-tabs.
+ *
+ * Responsibilities:
+ * - Rendering the navigation UI for sub-tabs
+ * - Managing the active sub-tab state
+ * - Providing a stable render context to sub-tabs
+ * - Orchestrating re-rendering on tab switches
+ *
+ * Non-responsibilities:
+ * - Rendering individual settings controls
+ * - Owning sub-tab DOM elements beyond the active container
+ * - Persisting settings directly (delegated to the plugin)
+ *
+ * @template TSettings
+ * The concrete settings object type used by the plugin.
+ *
+ * @template TTabIds
+ * The compile-time registry of valid sub-tab identifiers.
+ */
+declare abstract class PluginSettingsTabWithSubTabs<TSettings extends object, TTabIds extends PluginSettingsSubTabIdMap> extends PluginSettingTab {
+    protected readonly plugin: Plugin & PluginWithSettings<TSettings>;
+    /**
+     * Declarative registry of all available sub-tabs.
+     *
+     * The keys of this registry are compile-time validated sub-tab
+     * identifiers, ensuring correctness and uniqueness.
+     */
+    protected readonly subTabs: PluginSettingsSubTabRegistry<TSettings, TTabIds>;
+    /**
+     * The currently active sub-tab identifier.
+     *
+     * This state is fully owned by the controller and never exposed
+     * to individual sub-tabs.
+     */
+    protected activeSubTabId: PluginSettingsSubTabId<TTabIds>;
+    /**
+     * Protected constructor for a settings tab with multiple sub-tabs.
+     *
+     * This constructor initializes the navigation and active tab state.
+     *
+     * @template TSettings The concrete plugin settings type.
+     * @template TTabIds The compile-time map of valid sub-tab identifiers.
+     *
+     * @param app The Obsidian application instance.
+     * @param plugin The hosting plugin instance, implementing both
+     *               `Plugin` and `PluginWithSettings<TSettings>`.
+     * @param subTabs A declarative registry of all sub-tabs.
+     * @param defaultSubTabId The default sub-tab to activate on display.
+     */
+    protected constructor(app: App, plugin: Plugin & PluginWithSettings<TSettings>, subTabs: PluginSettingsSubTabRegistry<TSettings, TTabIds>, defaultSubTabId: PluginSettingsSubTabId<TTabIds>);
+    /**
+     * Called by Obsidian when the settings tab should be rendered.
+     *
+     * This method is final and must not be overridden by subclasses.
+     * Customization is achieved exclusively through sub-tab registration.
+     */
+    display(): void;
+    /**
+     * Renders the navigation UI for all registered sub-tabs.
+     *
+     * @param containerEl
+     * The container element used to host the navigation controls.
+     */
+    protected renderNavigation(containerEl: HTMLElement): void;
+    /**
+     * Renders the currently active sub-tab.
+     *
+     * @param containerEl
+     * The container element dedicated to sub-tab content.
+     */
+    protected renderActiveSubTab(containerEl: HTMLElement): void;
+}
+
+export { PluginSettingsTabWithSubTabs };
+export type { PluginSettingsRenderContext, PluginSettingsSubTab, PluginSettingsSubTabId, PluginSettingsSubTabIdMap, PluginSettingsSubTabRegistry };

package/index.js

@@ -0,0 +1,52 @@
+import { PluginSettingTab } from "obsidian";
+
+class PluginSettingsTabWithSubTabs extends PluginSettingTab {
+    plugin;
+    subTabs;
+    activeSubTabId;
+    constructor(app, plugin, subTabs, defaultSubTabId) {
+        super(app, plugin);
+        this.plugin = plugin;
+        this.subTabs = subTabs;
+        this.activeSubTabId = defaultSubTabId;
+    }
+    display() {
+        this.containerEl.empty();
+        const navigationEl = this.containerEl.createDiv({
+            cls: "plugin-settings-subtab-nav"
+        });
+        const contentEl = this.containerEl.createDiv({
+            cls: "plugin-settings-subtab-content"
+        });
+        this.renderNavigation(navigationEl);
+        this.renderActiveSubTab(contentEl);
+    }
+    renderNavigation(containerEl) {
+        Object.keys(this.subTabs).forEach(tabId => {
+            const subTab = this.subTabs[tabId];
+            const button = containerEl.createEl("button", {
+                text: subTab.header,
+                cls: tabId === this.activeSubTabId ? "is-active" : undefined
+            });
+            button.addEventListener("click", () => {
+                if (this.activeSubTabId !== tabId) {
+                    this.activeSubTabId = tabId;
+                    this.display();
+                }
+            });
+        });
+    }
+    renderActiveSubTab(containerEl) {
+        const subTab = this.subTabs[this.activeSubTabId];
+        const context = {
+            containerEl: containerEl,
+            settings: this.plugin.settings,
+            saveSettings: () => this.plugin.saveSettings(),
+            plugin: this.plugin
+        };
+        subTab.render(context);
+    }
+}
+
+export { PluginSettingsTabWithSubTabs };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbInNyYy9saWIvUGx1Z2luU2V0dGluZ3NUYWJXaXRoU3ViVGFicy50cyJdLCJuYW1lcyI6WyJQbHVnaW5TZXR0aW5nc1RhYldpdGhTdWJUYWJzIiwiUGx1Z2luU2V0dGluZ1RhYiIsInBsdWdpbiIsInN1YlRhYnMiLCJhY3RpdmVTdWJUYWJJZCIsImNvbnN0cnVjdG9yIiwiYXBwIiwiZGVmYXVsdFN1YlRhYklkIiwic3VwZXIiLCJ0aGlzIiwiZGlzcGxheSIsImNvbnRhaW5lckVsIiwiZW1wdHkiLCJuYXZpZ2F0aW9uRWwiLCJjcmVhdGVEaXYiLCJjbHMiLCJjb250ZW50RWwiLCJyZW5kZXJOYXZpZ2F0aW9uIiwicmVuZGVyQWN0aXZlU3ViVGFiIiwiT2JqZWN0Iiwia2V5cyIsImZvckVhY2giLCJ0YWJJZCIsInN1YlRhYiIsImJ1dHRvbiIsImNyZWF0ZUVsIiwidGV4dCIsImhlYWRlciIsInVuZGVmaW5lZCIsImFkZEV2ZW50TGlzdGVuZXIiLCJjb250ZXh0Iiwic2V0dGluZ3MiLCJzYXZlU2V0dGluZ3MiLCJyZW5kZXIiXSwibWFwcGluZ3MiOiI7O0FBaUNNLE1BQWdCQSxxQ0FHWkM7SUFvQ2FDO0lBNUJGQztJQVNUQztJQWlCVixXQUFBQyxDQUNFQyxLQUNtQkosUUFDbkJDLFNBQ0FJO1FBRUFDLE1BQU1GLEtBQUtKO1FBSlFPLEtBQUFQLFNBQUFBO1FBTW5CTyxLQUFLTixVQUFVQTtRQUNmTSxLQUFLTCxpQkFBaUJHO0FBQ3hCO0lBUVMsT0FBQUc7UUFDUEQsS0FBS0UsWUFBWUM7UUFFakIsTUFBTUMsZUFBZUosS0FBS0UsWUFBWUcsVUFBVTtZQUM5Q0MsS0FBSzs7UUFHUCxNQUFNQyxZQUFZUCxLQUFLRSxZQUFZRyxVQUFVO1lBQzNDQyxLQUFLOztRQUdQTixLQUFLUSxpQkFBaUJKO1FBQ3RCSixLQUFLUyxtQkFBbUJGO0FBQzFCO0lBUVUsZ0JBQUFDLENBQWlCTjtRQUN4QlEsT0FBT0MsS0FBS1gsS0FBS04sU0FFZmtCLFFBQVNDO1lBRVYsTUFBTUMsU0FBU2QsS0FBS04sUUFBUW1CO1lBRTVCLE1BQU1FLFNBQVNiLFlBQVljLFNBQVMsVUFBVTtnQkFDNUNDLE1BQU1ILE9BQU9JO2dCQUNiWixLQUFLTyxVQUFVYixLQUFLTCxpQkFDaEIsY0FDQXdCOztZQUdOSixPQUFPSyxpQkFBaUIsU0FBUztnQkFDL0IsSUFBSXBCLEtBQUtMLG1CQUFtQmtCLE9BQU87b0JBQ2pDYixLQUFLTCxpQkFBaUJrQjtvQkFDdEJiLEtBQUtDO0FBQ1A7OztBQUdOO0lBUVUsa0JBQUFRLENBQW1CUDtRQUMzQixNQUFNWSxTQUFTZCxLQUFLTixRQUFRTSxLQUFLTDtRQUVqQyxNQUFNMEIsVUFBa0Q7WUFDdERuQjtZQUNBb0IsVUFBVXRCLEtBQUtQLE9BQU82QjtZQUN0QkMsY0FBYyxNQUFNdkIsS0FBS1AsT0FBTzhCO1lBQ2hDOUIsUUFBUU8sS0FBS1A7O1FBR2ZxQixPQUFPVSxPQUFPSDtBQUNoQjs7OyJ9

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "ts-obsidian-ui-settings",
+  "version": "1.0.0",
+  "description": "Unified abstraction for obsidian setting ui with support für tabs",
+  "author": "Dirk Brenckmann <db.developer@gmx.de>",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "rollup --config .config/rollup.config.mjs --environment BUILD:production",
+    "coverage": "vitest run --coverage --config .config/vitest.config.ts",
+    "package": "npm run build && npm pack",
+    "test": "vitest --config .config/vitest.config.ts",
+    "test:watch": "vitest --watch --config .config/vitest.config.ts",
+    "test:ui": "vitest --ui --config .config/vitest.config.ts"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "ROADMAP.md"
+  ],
+  "peerDependencies": {
+    "obsidian": ">=1.5.0"
+  },
+  "peerDependenciesMeta": {
+    "obsidian": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.0",
+    "@types/node": "^24.10.0",
+    "@vitest/coverage-v8": "^4.0.15",
+    "@vitest/ui": "^4.0.15",
+    "jsdom": "^27.4.0",
+    "obsidian": "^1.10.2-1",
+    "prettier": "^3.7.4",
+    "prettier-plugin-align": "^0.0.1-alpha.1",
+    "rollup": "^4.53.1",
+    "rollup-plugin-dts": "^6.3.0",
+    "ts-obsidian-plugin": "^1.1.1",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  }
+}