@mnaoumov/obsidian-lib 10.5.0 → 10.6.0

package/dist/lib/esm/setting-ex.mjs

@@ -38,6 +38,9 @@ import { DateComponent } from "./setting-components/date-component.mjs";
 import { DateTimeComponent } from "./setting-components/date-time-component.mjs";
 import { EmailComponent } from "./setting-components/email-component.mjs";
 import { FileComponent } from "./setting-components/file-component.mjs";
+import { FolderListComponent } from "./setting-components/folder-list-component.mjs";
+import { HotkeyComponent } from "./setting-components/hotkey-component.mjs";
+import { ListComponent } from "./setting-components/list-component.mjs";
 import { MonthComponent } from "./setting-components/month-component.mjs";
 import { MultipleDropdownComponent } from "./setting-components/multiple-dropdown-component.mjs";
 import { MultipleEmailComponent } from "./setting-components/multiple-email-component.mjs";
@@ -45,6 +48,7 @@ import { MultipleFileComponent } from "./setting-components/multiple-file-compon
 import { MultipleTextComponent } from "./setting-components/multiple-text-component.mjs";
 import { NumberComponent } from "./setting-components/number-component.mjs";
 import { PasswordComponent } from "./setting-components/password-component.mjs";
+import { TagListComponent } from "./setting-components/tag-list-component.mjs";
 import { TelephoneComponent } from "./setting-components/telephone-component.mjs";
 import { TimeComponent } from "./setting-components/time-component.mjs";
 import { TriStateCheckboxComponent } from "./setting-components/tri-state-checkbox-component.mjs";
@@ -122,6 +126,38 @@ class SettingEx extends Setting {
   addFile(callback) {
     return this.addComponentClass(FileComponent, callback);
   }
+  /**
+   * Adds a {@link FolderListComponent} to the setting.
+   *
+   * @param app - The Obsidian app, for the folder suggest.
+   * @param callback - The callback to call with the component.
+   * @returns The setting instance.
+   */
+  addFolderList(app, callback) {
+    return this.addComponent((element) => {
+      const component = new FolderListComponent(element, app);
+      callback(component);
+      return component;
+    });
+  }
+  /**
+   * Adds a {@link HotkeyComponent} to the setting.
+   *
+   * @param callback - The callback to call with the component.
+   * @returns The setting instance.
+   */
+  addHotkey(callback) {
+    return this.addComponentClass(HotkeyComponent, callback);
+  }
+  /**
+   * Adds a {@link ListComponent} to the setting.
+   *
+   * @param callback - The callback to call with the component.
+   * @returns The setting instance.
+   */
+  addList(callback) {
+    return this.addComponentClass(ListComponent, callback);
+  }
   /**
    * Adds a {@link MonthComponent} to the setting.
    *
@@ -185,6 +221,20 @@ class SettingEx extends Setting {
   addPassword(callback) {
     return this.addComponentClass(PasswordComponent, callback);
   }
+  /**
+   * Adds a {@link TagListComponent} to the setting.
+   *
+   * @param app - The Obsidian app, for the tag suggest.
+   * @param callback - The callback to call with the component.
+   * @returns The setting instance.
+   */
+  addTagList(app, callback) {
+    return this.addComponent((element) => {
+      const component = new TagListComponent(element, app);
+      callback(component);
+      return component;
+    });
+  }
   /**
    * Adds a {@link TelephoneComponent} to the setting.
    *
@@ -262,4 +312,4 @@ export {
   SettingEx,
   adoptSettingEx
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/setting-ex.ts"],"sourcesContent":["/**\n * @file\n *\n * Extends the Setting class with additional methods for adding components.\n */\n\nimport type { BaseComponent } from 'obsidian';\n\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport { Setting } from 'obsidian';\n\nimport { CheckboxComponent } from './setting-components/checkbox-component.ts';\nimport { CodeHighlighterComponent } from './setting-components/code-highlighter-component.ts';\nimport { DateComponent } from './setting-components/date-component.ts';\nimport { DateTimeComponent } from './setting-components/date-time-component.ts';\nimport { EmailComponent } from './setting-components/email-component.ts';\nimport { FileComponent } from './setting-components/file-component.ts';\nimport { MonthComponent } from './setting-components/month-component.ts';\nimport { MultipleDropdownComponent } from './setting-components/multiple-dropdown-component.ts';\nimport { MultipleEmailComponent } from './setting-components/multiple-email-component.ts';\nimport { MultipleFileComponent } from './setting-components/multiple-file-component.ts';\nimport { MultipleTextComponent } from './setting-components/multiple-text-component.ts';\nimport { NumberComponent } from './setting-components/number-component.ts';\nimport { PasswordComponent } from './setting-components/password-component.ts';\nimport { TelephoneComponent } from './setting-components/telephone-component.ts';\nimport { TimeComponent } from './setting-components/time-component.ts';\nimport { TriStateCheckboxComponent } from './setting-components/tri-state-checkbox-component.ts';\nimport { TypedDropdownComponent } from './setting-components/typed-dropdown-component.ts';\nimport { TypedMultipleDropdownComponent } from './setting-components/typed-multiple-dropdown-component.ts';\nimport { UrlComponent } from './setting-components/url-component.ts';\nimport { WeekComponent } from './setting-components/week-component.ts';\n\n/**\n * Extends the Setting class with additional methods for adding components.\n */\nexport class SettingEx extends Setting {\n  /**\n   * Adds a {@link CheckboxComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addCheckbox(callback: (checkbox: CheckboxComponent) => void): this {\n    return this.addComponentClass(CheckboxComponent, callback);\n  }\n\n  /**\n   * Adds a {@link CodeHighlighterComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addCodeHighlighter(callback: (codeHighlighter: CodeHighlighterComponent) => void): this {\n    return this.addComponentClass(CodeHighlighterComponent, callback);\n  }\n\n  /**\n   * Adds a component to the setting.\n   *\n   * @typeParam T - The type of the component to add.\n   * @param componentClass - The class of the component to add.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addComponentClass<T extends BaseComponent>(componentClass: new (containerEl: HTMLElement) => T, callback: (component: T) => void): this {\n    return this.addComponent((element) => {\n      const component = new componentClass(element);\n      callback(component);\n      return component;\n    });\n  }\n\n  /**\n   * Adds a {@link DateComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addDate(callback: (date: DateComponent) => void): this {\n    return this.addComponentClass(DateComponent, callback);\n  }\n\n  /**\n   * Adds a {@link DateTimeComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addDateTime(callback: (dateTime: DateTimeComponent) => void): this {\n    return this.addComponentClass(DateTimeComponent, callback);\n  }\n\n  /**\n   * Adds an {@link EmailComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addEmail(callback: (email: EmailComponent) => void): this {\n    return this.addComponentClass(EmailComponent, callback);\n  }\n\n  /**\n   * Adds a {@link FileComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addFile(callback: (file: FileComponent) => void): this {\n    return this.addComponentClass(FileComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MonthComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMonth(callback: (month: MonthComponent) => void): this {\n    return this.addComponentClass(MonthComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleDropdownComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleDropdown(callback: (multipleDropdown: MultipleDropdownComponent) => void): this {\n    return this.addComponentClass(MultipleDropdownComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleEmailComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleEmail(callback: (multipleEmail: MultipleEmailComponent) => void): this {\n    return this.addComponentClass(MultipleEmailComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleFileComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleFile(callback: (multipleFile: MultipleFileComponent) => void): this {\n    return this.addComponentClass(MultipleFileComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleTextComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleText(callback: (multipleText: MultipleTextComponent) => void): this {\n    return this.addComponentClass(MultipleTextComponent, callback);\n  }\n\n  /**\n   * Adds a {@link NumberComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addNumber(callback: ($number: NumberComponent) => void): this {\n    return this.addComponentClass(NumberComponent, callback);\n  }\n\n  /**\n   * Adds a {@link PasswordComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addPassword(callback: (password: PasswordComponent) => void): this {\n    return this.addComponentClass(PasswordComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TelephoneComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTelephone(callback: (telephone: TelephoneComponent) => void): this {\n    return this.addComponentClass(TelephoneComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TimeComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTime(callback: (time: TimeComponent) => void): this {\n    return this.addComponentClass(TimeComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TriStateCheckboxComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTriStateCheckbox(callback: (triStateCheckbox: TriStateCheckboxComponent) => void): this {\n    return this.addComponentClass(TriStateCheckboxComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TypedDropdownComponent} to the setting.\n   *\n   * @typeParam T - The type of the dropdown items.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTypedDropdown<T>(callback: (typedDropdown: TypedDropdownComponent<T>) => void): this {\n    return this.addComponentClass(TypedDropdownComponent<T>, callback);\n  }\n\n  /**\n   * Adds a {@link TypedMultipleDropdownComponent} to the setting.\n   *\n   * @typeParam T - The type of the items in the dropdown.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTypedMultipleDropdown<T>(callback: (typedMultipleDropdown: TypedMultipleDropdownComponent<T>) => void): this {\n    return this.addComponentClass(TypedMultipleDropdownComponent<T>, callback);\n  }\n\n  /**\n   * Adds an {@link UrlComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addUrl(callback: (url: UrlComponent) => void): this {\n    return this.addComponentClass(UrlComponent, callback);\n  }\n\n  /**\n   * Adds a {@link WeekComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addWeek(callback: (week: WeekComponent) => void): this {\n    return this.addComponentClass(WeekComponent, callback);\n  }\n}\n\n/**\n * Adopts a plain {@link Setting} into a {@link SettingEx}, returning the very same instance.\n *\n * Obsidian's declarative settings API creates the row itself and hands a plain {@link Setting} to a\n * `SettingDefinitionRender.render` callback, so the extended adders are out of reach there. Re-pointing the\n * instance's prototype at {@link SettingEx.prototype} makes them available on the object Obsidian already\n * owns and keeps rendering: {@link SettingEx} declares no instance state and its constructor only delegates\n * to `super`, and `SettingEx.prototype` inherits from the very `Setting.prototype` the instance came from,\n * so every method Obsidian relies on — including the ones absent from the public typings — stays reachable.\n *\n * @param setting - The setting to adopt.\n * @returns The same instance, typed as a {@link SettingEx}.\n */\nexport function adoptSettingEx(setting: Setting): SettingEx {\n  if (setting instanceof SettingEx) {\n    return setting;\n  }\n\n  Object.setPrototypeOf(setting, SettingEx.prototype);\n  return castTo<SettingEx>(setting);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,cAAc;AACvB,SAAS,eAAe;AAExB,SAAS,yBAAyB;AAClC,SAAS,gCAAgC;AACzC,SAAS,qBAAqB;AAC9B,SAAS,yBAAyB;AAClC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,iCAAiC;AAC1C,SAAS,8BAA8B;AACvC,SAAS,6BAA6B;AACtC,SAAS,6BAA6B;AACtC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,0BAA0B;AACnC,SAAS,qBAAqB;AAC9B,SAAS,iCAAiC;AAC1C,SAAS,8BAA8B;AACvC,SAAS,sCAAsC;AAC/C,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAKvB,MAAM,kBAAkB,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO9B,YAAY,UAAuD;AACxE,WAAO,KAAK,kBAAkB,mBAAmB,QAAQ;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,mBAAmB,UAAqE;AAC7F,WAAO,KAAK,kBAAkB,0BAA0B,QAAQ;AAAA,EAClE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUO,kBAA2C,gBAAqD,UAAwC;AAC7I,WAAO,KAAK,aAAa,CAAC,YAAY;AACpC,YAAM,YAAY,IAAI,eAAe,OAAO;AAC5C,eAAS,SAAS;AAClB,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,UAA+C;AAC5D,WAAO,KAAK,kBAAkB,eAAe,QAAQ;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,YAAY,UAAuD;AACxE,WAAO,KAAK,kBAAkB,mBAAmB,QAAQ;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,SAAS,UAAiD;AAC/D,WAAO,KAAK,kBAAkB,gBAAgB,QAAQ;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,UAA+C;AAC5D,WAAO,KAAK,kBAAkB,eAAe,QAAQ;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,SAAS,UAAiD;AAC/D,WAAO,KAAK,kBAAkB,gBAAgB,QAAQ;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,oBAAoB,UAAuE;AAChG,WAAO,KAAK,kBAAkB,2BAA2B,QAAQ;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,iBAAiB,UAAiE;AACvF,WAAO,KAAK,kBAAkB,wBAAwB,QAAQ;AAAA,EAChE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,gBAAgB,UAA+D;AACpF,WAAO,KAAK,kBAAkB,uBAAuB,QAAQ;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,gBAAgB,UAA+D;AACpF,WAAO,KAAK,kBAAkB,uBAAuB,QAAQ;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,UAAU,UAAoD;AACnE,WAAO,KAAK,kBAAkB,iBAAiB,QAAQ;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,YAAY,UAAuD;AACxE,WAAO,KAAK,kBAAkB,mBAAmB,QAAQ;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,aAAa,UAAyD;AAC3E,WAAO,KAAK,kBAAkB,oBAAoB,QAAQ;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,UAA+C;AAC5D,WAAO,KAAK,kBAAkB,eAAe,QAAQ;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,oBAAoB,UAAuE;AAChG,WAAO,KAAK,kBAAkB,2BAA2B,QAAQ;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,iBAAoB,UAAoE;AAC7F,WAAO,KAAK,kBAAkB,wBAA2B,QAAQ;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,yBAA4B,UAAoF;AACrH,WAAO,KAAK,kBAAkB,gCAAmC,QAAQ;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,UAA6C;AACzD,WAAO,KAAK,kBAAkB,cAAc,QAAQ;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,UAA+C;AAC5D,WAAO,KAAK,kBAAkB,eAAe,QAAQ;AAAA,EACvD;AACF;AAeO,SAAS,eAAe,SAA6B;AAC1D,MAAI,mBAAmB,WAAW;AAChC,WAAO;AAAA,EACT;AAEA,SAAO,eAAe,SAAS,UAAU,SAAS;AAClD,SAAO,OAAkB,OAAO;AAClC;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/setting-ex.ts"],"sourcesContent":["/**\n * @file\n *\n * Extends the Setting class with additional methods for adding components.\n */\n\nimport type {\n  App,\n  BaseComponent\n} from 'obsidian';\n\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport { Setting } from 'obsidian';\n\nimport { CheckboxComponent } from './setting-components/checkbox-component.ts';\nimport { CodeHighlighterComponent } from './setting-components/code-highlighter-component.ts';\nimport { DateComponent } from './setting-components/date-component.ts';\nimport { DateTimeComponent } from './setting-components/date-time-component.ts';\nimport { EmailComponent } from './setting-components/email-component.ts';\nimport { FileComponent } from './setting-components/file-component.ts';\nimport { FolderListComponent } from './setting-components/folder-list-component.ts';\nimport { HotkeyComponent } from './setting-components/hotkey-component.ts';\nimport { ListComponent } from './setting-components/list-component.ts';\nimport { MonthComponent } from './setting-components/month-component.ts';\nimport { MultipleDropdownComponent } from './setting-components/multiple-dropdown-component.ts';\nimport { MultipleEmailComponent } from './setting-components/multiple-email-component.ts';\nimport { MultipleFileComponent } from './setting-components/multiple-file-component.ts';\nimport { MultipleTextComponent } from './setting-components/multiple-text-component.ts';\nimport { NumberComponent } from './setting-components/number-component.ts';\nimport { PasswordComponent } from './setting-components/password-component.ts';\nimport { TagListComponent } from './setting-components/tag-list-component.ts';\nimport { TelephoneComponent } from './setting-components/telephone-component.ts';\nimport { TimeComponent } from './setting-components/time-component.ts';\nimport { TriStateCheckboxComponent } from './setting-components/tri-state-checkbox-component.ts';\nimport { TypedDropdownComponent } from './setting-components/typed-dropdown-component.ts';\nimport { TypedMultipleDropdownComponent } from './setting-components/typed-multiple-dropdown-component.ts';\nimport { UrlComponent } from './setting-components/url-component.ts';\nimport { WeekComponent } from './setting-components/week-component.ts';\n\n/**\n * Extends the Setting class with additional methods for adding components.\n */\nexport class SettingEx extends Setting {\n  /**\n   * Adds a {@link CheckboxComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addCheckbox(callback: (checkbox: CheckboxComponent) => void): this {\n    return this.addComponentClass(CheckboxComponent, callback);\n  }\n\n  /**\n   * Adds a {@link CodeHighlighterComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addCodeHighlighter(callback: (codeHighlighter: CodeHighlighterComponent) => void): this {\n    return this.addComponentClass(CodeHighlighterComponent, callback);\n  }\n\n  /**\n   * Adds a component to the setting.\n   *\n   * @typeParam T - The type of the component to add.\n   * @param componentClass - The class of the component to add.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addComponentClass<T extends BaseComponent>(componentClass: new (containerEl: HTMLElement) => T, callback: (component: T) => void): this {\n    return this.addComponent((element) => {\n      const component = new componentClass(element);\n      callback(component);\n      return component;\n    });\n  }\n\n  /**\n   * Adds a {@link DateComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addDate(callback: (date: DateComponent) => void): this {\n    return this.addComponentClass(DateComponent, callback);\n  }\n\n  /**\n   * Adds a {@link DateTimeComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addDateTime(callback: (dateTime: DateTimeComponent) => void): this {\n    return this.addComponentClass(DateTimeComponent, callback);\n  }\n\n  /**\n   * Adds an {@link EmailComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addEmail(callback: (email: EmailComponent) => void): this {\n    return this.addComponentClass(EmailComponent, callback);\n  }\n\n  /**\n   * Adds a {@link FileComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addFile(callback: (file: FileComponent) => void): this {\n    return this.addComponentClass(FileComponent, callback);\n  }\n\n  /**\n   * Adds a {@link FolderListComponent} to the setting.\n   *\n   * @param app - The Obsidian app, for the folder suggest.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addFolderList(app: App, callback: (folderList: FolderListComponent) => void): this {\n    return this.addComponent((element) => {\n      const component = new FolderListComponent(element, app);\n      callback(component);\n      return component;\n    });\n  }\n\n  /**\n   * Adds a {@link HotkeyComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addHotkey(callback: (hotkey: HotkeyComponent) => void): this {\n    return this.addComponentClass(HotkeyComponent, callback);\n  }\n\n  /**\n   * Adds a {@link ListComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addList(callback: (list: ListComponent) => void): this {\n    return this.addComponentClass(ListComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MonthComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMonth(callback: (month: MonthComponent) => void): this {\n    return this.addComponentClass(MonthComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleDropdownComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleDropdown(callback: (multipleDropdown: MultipleDropdownComponent) => void): this {\n    return this.addComponentClass(MultipleDropdownComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleEmailComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleEmail(callback: (multipleEmail: MultipleEmailComponent) => void): this {\n    return this.addComponentClass(MultipleEmailComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleFileComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleFile(callback: (multipleFile: MultipleFileComponent) => void): this {\n    return this.addComponentClass(MultipleFileComponent, callback);\n  }\n\n  /**\n   * Adds a {@link MultipleTextComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addMultipleText(callback: (multipleText: MultipleTextComponent) => void): this {\n    return this.addComponentClass(MultipleTextComponent, callback);\n  }\n\n  /**\n   * Adds a {@link NumberComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addNumber(callback: ($number: NumberComponent) => void): this {\n    return this.addComponentClass(NumberComponent, callback);\n  }\n\n  /**\n   * Adds a {@link PasswordComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addPassword(callback: (password: PasswordComponent) => void): this {\n    return this.addComponentClass(PasswordComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TagListComponent} to the setting.\n   *\n   * @param app - The Obsidian app, for the tag suggest.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTagList(app: App, callback: (tagList: TagListComponent) => void): this {\n    return this.addComponent((element) => {\n      const component = new TagListComponent(element, app);\n      callback(component);\n      return component;\n    });\n  }\n\n  /**\n   * Adds a {@link TelephoneComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTelephone(callback: (telephone: TelephoneComponent) => void): this {\n    return this.addComponentClass(TelephoneComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TimeComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTime(callback: (time: TimeComponent) => void): this {\n    return this.addComponentClass(TimeComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TriStateCheckboxComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTriStateCheckbox(callback: (triStateCheckbox: TriStateCheckboxComponent) => void): this {\n    return this.addComponentClass(TriStateCheckboxComponent, callback);\n  }\n\n  /**\n   * Adds a {@link TypedDropdownComponent} to the setting.\n   *\n   * @typeParam T - The type of the dropdown items.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTypedDropdown<T>(callback: (typedDropdown: TypedDropdownComponent<T>) => void): this {\n    return this.addComponentClass(TypedDropdownComponent<T>, callback);\n  }\n\n  /**\n   * Adds a {@link TypedMultipleDropdownComponent} to the setting.\n   *\n   * @typeParam T - The type of the items in the dropdown.\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addTypedMultipleDropdown<T>(callback: (typedMultipleDropdown: TypedMultipleDropdownComponent<T>) => void): this {\n    return this.addComponentClass(TypedMultipleDropdownComponent<T>, callback);\n  }\n\n  /**\n   * Adds an {@link UrlComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addUrl(callback: (url: UrlComponent) => void): this {\n    return this.addComponentClass(UrlComponent, callback);\n  }\n\n  /**\n   * Adds a {@link WeekComponent} to the setting.\n   *\n   * @param callback - The callback to call with the component.\n   * @returns The setting instance.\n   */\n  public addWeek(callback: (week: WeekComponent) => void): this {\n    return this.addComponentClass(WeekComponent, callback);\n  }\n}\n\n/**\n * Adopts a plain {@link Setting} into a {@link SettingEx}, returning the very same instance.\n *\n * Obsidian's declarative settings API creates the row itself and hands a plain {@link Setting} to a\n * `SettingDefinitionRender.render` callback, so the extended adders are out of reach there. Re-pointing the\n * instance's prototype at {@link SettingEx.prototype} makes them available on the object Obsidian already\n * owns and keeps rendering: {@link SettingEx} declares no instance state and its constructor only delegates\n * to `super`, and `SettingEx.prototype` inherits from the very `Setting.prototype` the instance came from,\n * so every method Obsidian relies on — including the ones absent from the public typings — stays reachable.\n *\n * @param setting - The setting to adopt.\n * @returns The same instance, typed as a {@link SettingEx}.\n */\nexport function adoptSettingEx(setting: Setting): SettingEx {\n  if (setting instanceof SettingEx) {\n    return setting;\n  }\n\n  Object.setPrototypeOf(setting, SettingEx.prototype);\n  return castTo<SettingEx>(setting);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/settings-tabs.d.mts

@@ -0,0 +1,101 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Tabbed sections inside a plugin's settings.
+ */
+/**
+ * A tab of {@link SettingsTabs}.
+ */
+export interface SettingsTab {
+    /**
+     * The name of an Obsidian icon shown before the name.
+     */
+    readonly icon?: string;
+    /**
+     * The id of the tab, unique among the tabs.
+     */
+    readonly id: string;
+    /**
+     * The name shown on the tab button.
+     */
+    readonly name: string;
+    /**
+     * Renders the tab's settings into the panel, which is empty each time the tab is selected.
+     *
+     * @param containerEl - The panel.
+     */
+    readonly render: (containerEl: HTMLElement) => void;
+}
+/**
+ * Tabbed sections inside a plugin's settings: a row of tab buttons and one panel, which renders only the selected tab.
+ * The arrow keys, Home and End move between tabs, as in the WAI-ARIA tabs pattern.
+ *
+ * ```ts
+ * public override display(): void {
+ *   this.containerEl.empty();
+ *   new SettingsTabs(this.containerEl)
+ *     .addTab({ id: 'general', name: 'General', render: (el) => this.renderGeneral(el) })
+ *     .addTab({ id: 'advanced', name: 'Advanced', render: (el) => this.renderAdvanced(el) })
+ *     .selectTab(this.lastTabId)
+ *     .onTabChange((tabId) => {
+ *       this.lastTabId = tabId;
+ *     });
+ * }
+ * ```
+ *
+ * In order to add the styles for the component, use {@link initPluginContext} in your plugin's `onload()` function.
+ *
+ * Alternatively, you can copy styles from {@link https://unpkg.com/@mnaoumov/obsidian-lib/dist/styles.css}.
+ */
+export declare class SettingsTabs {
+    /**
+     * The panel the selected tab renders into.
+     */
+    readonly panelEl: HTMLElement;
+    /**
+     * The row of tab buttons.
+     */
+    readonly tabBarEl: HTMLElement;
+    private changeCallback?;
+    private readonly entries;
+    private selectedTabId;
+    /**
+     * Creates new settings tabs.
+     *
+     * @param containerEl - The container element.
+     */
+    constructor(containerEl: HTMLElement);
+    /**
+     * Adds a tab. The first tab added is selected.
+     *
+     * @param tab - The tab.
+     * @returns The tabs.
+     * @throws If a tab with the same id was already added.
+     */
+    addTab(tab: SettingsTab): this;
+    /**
+     * Gets the id of the selected tab.
+     *
+     * @returns The id, or `null` before any tab is added.
+     */
+    getSelectedTabId(): null | string;
+    /**
+     * Sets the callback to be called when the user selects another tab.
+     *
+     * @param callback - The callback, given the id of the selected tab.
+     * @returns The tabs.
+     */
+    onTabChange(callback: (tabId: string) => void): this;
+    /**
+     * Selects a tab and renders it into the panel. An unknown id, such as a stored id whose tab was since removed, leaves
+     * the selection as it is.
+     *
+     * @param tabId - The id of the tab.
+     * @returns The tabs.
+     */
+    selectTab(tabId: null | string | undefined): this;
+    private findEntry;
+    private onKeyDown;
+}

package/dist/lib/esm/settings-tabs.mjs

@@ -0,0 +1,170 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { setIcon } from "obsidian";
+import { CssClass } from "./css-class.mjs";
+import { addPluginCssClasses } from "./plugin/plugin-context.mjs";
+class SettingsTabs {
+  /**
+   * The panel the selected tab renders into.
+   */
+  panelEl;
+  /**
+   * The row of tab buttons.
+   */
+  tabBarEl;
+  changeCallback;
+  entries = [];
+  selectedTabId = null;
+  /**
+   * Creates new settings tabs.
+   *
+   * @param containerEl - The container element.
+   */
+  constructor(containerEl) {
+    addPluginCssClasses(containerEl, CssClass.SettingsTabs);
+    this.tabBarEl = containerEl.createDiv({ attr: { role: "tablist" }, cls: "settings-tabs-bar" });
+    this.tabBarEl.addEventListener("keydown", this.onKeyDown.bind(this));
+    this.panelEl = containerEl.createDiv({ attr: { role: "tabpanel" }, cls: "settings-tabs-panel" });
+  }
+  /**
+   * Adds a tab. The first tab added is selected.
+   *
+   * @param tab - The tab.
+   * @returns The tabs.
+   * @throws If a tab with the same id was already added.
+   */
+  addTab(tab) {
+    if (this.findEntry(tab.id)) {
+      throw new Error(`A settings tab with the id ${tab.id} was already added.`);
+    }
+    const buttonEl = this.tabBarEl.createEl("button", { attr: { "aria-selected": "false", "role": "tab", "tabindex": "-1" }, cls: "settings-tabs-button" });
+    if (tab.icon) {
+      setIcon(buttonEl.createSpan({ cls: "settings-tabs-icon" }), tab.icon);
+    }
+    buttonEl.createSpan({ text: tab.name });
+    buttonEl.addEventListener("click", () => {
+      this.selectTab(tab.id);
+    });
+    this.entries.push({ buttonEl, tab });
+    if (this.selectedTabId === null) {
+      this.selectTab(tab.id);
+    }
+    return this;
+  }
+  /**
+   * Gets the id of the selected tab.
+   *
+   * @returns The id, or `null` before any tab is added.
+   */
+  getSelectedTabId() {
+    return this.selectedTabId;
+  }
+  /**
+   * Sets the callback to be called when the user selects another tab.
+   *
+   * @param callback - The callback, given the id of the selected tab.
+   * @returns The tabs.
+   */
+  onTabChange(callback) {
+    this.changeCallback = callback;
+    return this;
+  }
+  /**
+   * Selects a tab and renders it into the panel. An unknown id, such as a stored id whose tab was since removed, leaves
+   * the selection as it is.
+   *
+   * @param tabId - The id of the tab.
+   * @returns The tabs.
+   */
+  selectTab(tabId) {
+    const entry = this.findEntry(tabId);
+    if (!entry) {
+      return this;
+    }
+    const { tab } = entry;
+    const isChange = this.selectedTabId !== null && this.selectedTabId !== tab.id;
+    this.selectedTabId = tab.id;
+    for (const { buttonEl, tab: candidate } of this.entries) {
+      const isSelected = candidate === tab;
+      buttonEl.toggleClass(CssClass.IsActive, isSelected);
+      buttonEl.setAttribute("aria-selected", String(isSelected));
+      buttonEl.setAttribute("tabindex", isSelected ? "0" : "-1");
+    }
+    this.panelEl.empty();
+    tab.render(this.panelEl);
+    if (isChange) {
+      this.changeCallback?.(tab.id);
+    }
+    return this;
+  }
+  findEntry(tabId) {
+    return this.entries.find((entry) => entry.tab.id === tabId);
+  }
+  onKeyDown(event_) {
+    const count = this.entries.length;
+    const index = this.entries.findIndex((entry) => entry.tab.id === this.selectedTabId);
+    let nextIndex;
+    switch (event_.key) {
+      case "ArrowLeft": {
+        nextIndex = (index - 1 + count) % count;
+        break;
+      }
+      case "ArrowRight": {
+        nextIndex = (index + 1) % count;
+        break;
+      }
+      case "End": {
+        nextIndex = count - 1;
+        break;
+      }
+      case "Home": {
+        nextIndex = 0;
+        break;
+      }
+      default: {
+        return;
+      }
+    }
+    const nextEntry = this.entries[nextIndex];
+    if (!nextEntry) {
+      return;
+    }
+    event_.preventDefault();
+    this.selectTab(nextEntry.tab.id);
+    nextEntry.buttonEl.focus();
+  }
+}
+export {
+  SettingsTabs
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/settings-tabs.ts"],"sourcesContent":["/**\n * @file\n *\n * Tabbed sections inside a plugin's settings.\n */\n\nimport { setIcon } from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `initPluginContext` to use it in the tsdocs.\nimport type { initPluginContext } from './plugin/plugin-context.ts';\n\nimport { CssClass } from './css-class.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * A tab of {@link SettingsTabs}.\n */\nexport interface SettingsTab {\n  /**\n   * The name of an Obsidian icon shown before the name.\n   */\n  readonly icon?: string;\n\n  /**\n   * The id of the tab, unique among the tabs.\n   */\n  readonly id: string;\n\n  /**\n   * The name shown on the tab button.\n   */\n  readonly name: string;\n\n  /**\n   * Renders the tab's settings into the panel, which is empty each time the tab is selected.\n   *\n   * @param containerEl - The panel.\n   */\n  readonly render: (containerEl: HTMLElement) => void;\n}\n\ninterface SettingsTabEntry {\n  readonly buttonEl: HTMLButtonElement;\n  readonly tab: SettingsTab;\n}\n\n/**\n * Tabbed sections inside a plugin's settings: a row of tab buttons and one panel, which renders only the selected tab.\n * The arrow keys, Home and End move between tabs, as in the WAI-ARIA tabs pattern.\n *\n * ```ts\n * public override display(): void {\n *   this.containerEl.empty();\n *   new SettingsTabs(this.containerEl)\n *     .addTab({ id: 'general', name: 'General', render: (el) => this.renderGeneral(el) })\n *     .addTab({ id: 'advanced', name: 'Advanced', render: (el) => this.renderAdvanced(el) })\n *     .selectTab(this.lastTabId)\n *     .onTabChange((tabId) => {\n *       this.lastTabId = tabId;\n *     });\n * }\n * ```\n *\n * In order to add the styles for the component, use {@link initPluginContext} in your plugin's `onload()` function.\n *\n * Alternatively, you can copy styles from {@link https://unpkg.com/@mnaoumov/obsidian-lib/dist/styles.css}.\n */\nexport class SettingsTabs {\n  /**\n   * The panel the selected tab renders into.\n   */\n  public readonly panelEl: HTMLElement;\n\n  /**\n   * The row of tab buttons.\n   */\n  public readonly tabBarEl: HTMLElement;\n\n  private changeCallback?: (tabId: string) => void;\n  private readonly entries: SettingsTabEntry[] = [];\n  private selectedTabId: null | string = null;\n\n  /**\n   * Creates new settings tabs.\n   *\n   * @param containerEl - The container element.\n   */\n  public constructor(containerEl: HTMLElement) {\n    addPluginCssClasses(containerEl, CssClass.SettingsTabs);\n    this.tabBarEl = containerEl.createDiv({ attr: { role: 'tablist' }, cls: 'settings-tabs-bar' });\n    this.tabBarEl.addEventListener('keydown', this.onKeyDown.bind(this));\n    this.panelEl = containerEl.createDiv({ attr: { role: 'tabpanel' }, cls: 'settings-tabs-panel' });\n  }\n\n  /**\n   * Adds a tab. The first tab added is selected.\n   *\n   * @param tab - The tab.\n   * @returns The tabs.\n   * @throws If a tab with the same id was already added.\n   */\n  public addTab(tab: SettingsTab): this {\n    if (this.findEntry(tab.id)) {\n      throw new Error(`A settings tab with the id ${tab.id} was already added.`);\n    }\n    const buttonEl = this.tabBarEl.createEl('button', { attr: { 'aria-selected': 'false', 'role': 'tab', 'tabindex': '-1' }, cls: 'settings-tabs-button' });\n    if (tab.icon) {\n      setIcon(buttonEl.createSpan({ cls: 'settings-tabs-icon' }), tab.icon);\n    }\n    buttonEl.createSpan({ text: tab.name });\n    buttonEl.addEventListener('click', () => {\n      this.selectTab(tab.id);\n    });\n    this.entries.push({ buttonEl, tab });\n    if (this.selectedTabId === null) {\n      this.selectTab(tab.id);\n    }\n    return this;\n  }\n\n  /**\n   * Gets the id of the selected tab.\n   *\n   * @returns The id, or `null` before any tab is added.\n   */\n  public getSelectedTabId(): null | string {\n    return this.selectedTabId;\n  }\n\n  /**\n   * Sets the callback to be called when the user selects another tab.\n   *\n   * @param callback - The callback, given the id of the selected tab.\n   * @returns The tabs.\n   */\n  public onTabChange(callback: (tabId: string) => void): this {\n    this.changeCallback = callback;\n    return this;\n  }\n\n  /**\n   * Selects a tab and renders it into the panel. An unknown id, such as a stored id whose tab was since removed, leaves\n   * the selection as it is.\n   *\n   * @param tabId - The id of the tab.\n   * @returns The tabs.\n   */\n  public selectTab(tabId: null | string | undefined): this {\n    const entry = this.findEntry(tabId);\n    if (!entry) {\n      return this;\n    }\n    const { tab } = entry;\n    const isChange = this.selectedTabId !== null && this.selectedTabId !== tab.id;\n    this.selectedTabId = tab.id;\n    for (const { buttonEl, tab: candidate } of this.entries) {\n      const isSelected = candidate === tab;\n      buttonEl.toggleClass(CssClass.IsActive, isSelected);\n      buttonEl.setAttribute('aria-selected', String(isSelected));\n      buttonEl.setAttribute('tabindex', isSelected ? '0' : '-1');\n    }\n    this.panelEl.empty();\n    tab.render(this.panelEl);\n    if (isChange) {\n      this.changeCallback?.(tab.id);\n    }\n    return this;\n  }\n\n  private findEntry(tabId: null | string | undefined): SettingsTabEntry | undefined {\n    return this.entries.find((entry) => entry.tab.id === tabId);\n  }\n\n  private onKeyDown(event_: KeyboardEvent): void {\n    const count = this.entries.length;\n    const index = this.entries.findIndex((entry) => entry.tab.id === this.selectedTabId);\n    let nextIndex: number;\n    switch (event_.key) {\n      case 'ArrowLeft': {\n        nextIndex = (index - 1 + count) % count;\n        break;\n      }\n      case 'ArrowRight': {\n        nextIndex = (index + 1) % count;\n        break;\n      }\n      case 'End': {\n        nextIndex = count - 1;\n        break;\n      }\n      case 'Home': {\n        nextIndex = 0;\n        break;\n      }\n      default: {\n        return;\n      }\n    }\n    const nextEntry = this.entries[nextIndex];\n    if (!nextEntry) {\n      return;\n    }\n    event_.preventDefault();\n    this.selectTab(nextEntry.tab.id);\n    nextEntry.buttonEl.focus();\n  }\n}\n"],"mappings":"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","names":[]}