obsidian-typings 1.0.3 → 1.0.5

package/obsidian-ex.d.ts

@@ -3,7 +3,8 @@ import {
     Command,
     Component,
     Constructor,
-    EditorRange,
+    EditorRange, 
+    EventRef,
     Events,
     KeymapInfo,
     Loc,
@@ -31,6 +32,11 @@ export * from 'obsidian';
 
 
 // TODO: Interfaces that have not been fully typed yet are marked as @internal with 'unknown'
+// TODO: Add Canvas typings (work off base from Dev-Mike, attribute)
+// TODO: Missing event types on sync plugin (but not the internalplugin itself):
+//  - new-log
+//  - status-change
+
 
 interface Account {
     /**
@@ -321,6 +327,26 @@ interface BlockCache {
     cache: unknown;
 }
 
+interface CanvasConnection {
+    
+}
+
+interface CanvasLeaf extends WorkspaceLeaf {
+
+}
+
+interface CanvasNode {
+    
+}
+
+interface CanvasPlugin extends InternalPlugin {
+
+}
+
+interface CanvasView {
+    
+}
+
 interface CMState extends EditorState {
     vim: {
         inputState: {
@@ -680,11 +706,35 @@ interface FileExplorerPlugin extends InternalPlugin {
 }
 
 interface FileExplorerView extends View {
+    /**
+     * Mapping of tree self element to abstract file
+     */
     files: WeakMapWrapper<HTMLElement, TAbstractFile>;
-
+    /**
+     * Mapping of file path to tree item
+     */
+    fileItems: Record<string, TreeItem<FileTreeItem>>;
+    /**
+     * Tree view of files
+     */
+    tree: Tree<FileTreeItem>;
+    
     openFileContextMenu(event: Event, fileItemElement: HTMLElement): void;
 }
 
+interface FileTreeItem {
+    file: TAbstractFile;
+}
+
+
+interface GlobalSearchLeaf extends WorkspaceLeaf {
+
+}
+
+interface GlobalSearchPlugin extends InternalPlugin {
+
+}
+
 interface HotkeyManager {
     /**
      * Reference to App
@@ -773,6 +823,18 @@ interface HoverLinkSource {
     defaultMod: boolean;
 }
 
+interface HoverLinkEvent {
+    event: MouseEvent,
+    source: "search" | "editor" | "preview" | "properties" | "graph" | "file-explorer" | "hover-link",
+    hoverParent: WorkspaceLeaf,
+    targetEl: HTMLElement | null,
+    linktext: string,
+    sourcePath?: string,
+    state?: {
+        scroll: unknown,
+    }
+}
+
 interface ImportedAttachments {
     data: Promise<ArrayBuffer>;
     extension: string;
@@ -780,6 +842,37 @@ interface ImportedAttachments {
     name: string;
 }
 
+/**
+ * @internal
+ */
+interface InfinityScroll {
+    height: number;
+    lastScroll: number;
+    queued: unknown | null;
+    renderBlockSize: number;
+    rootEl: unknown;
+    scrollEl: HTMLElement;
+    setWidth: boolean;
+    width: number;
+
+    compute(x: unknown): unknown;
+    findElementTop(x: unknown, y: unknown, z: unknown): unknown;
+    getRootTop(): unknown;
+    invalidate(x: unknown, y: unknown): unknown;
+    invalidateAll(): unknown;
+    measure(x: unknown, y: unknown): unknown;
+    onResize(): unknown;
+    onScroll(): unknown;
+    queueCompute(): unknown;
+    scrollIntoView(x: unknown, y: unknown): unknown;
+    update(x: unknown, y: unknown, z: unknown, u: unknown, v: unknown, w: unknown): unknown;
+    updateVirtualDisplay(x: unknown): unknown;
+    
+    _layout(x: unknown, y: unknown): unknown;
+    _measure(x: unknown): unknown;
+    _precompute(x: unknown): unknown;
+}
+
 interface InternalPlugin extends Plugin {
     disable(): void;
     enable(): void;
@@ -830,8 +923,13 @@ interface InternalPlugins extends Events {
     migration: boolean;
     /**
      * Plugin configs for internal plugins
+     * @remark Prefer usage of getPluginById to access a plugin
      */
-    plugins: Record<InternalPluginName, InternalPlugin>;
+    plugins: {
+        "file-explorer": FileExplorerPlugin,
+        "global-search": GlobalSearchPlugin,
+        [key: string]: InternalPlugin,
+    }
     /**
      * @internal Request save of plugin configs
      */
@@ -843,6 +941,7 @@ interface InternalPlugins extends Events {
      */
     getEnabledPluginById(id: InternalPluginName): InternalPlugin | null;
     getEnabledPluginById(id: 'file-explorer'): FileExplorerPlugin | null;
+    getEnabledPluginById(id: 'global-search'): GlobalSearchPlugin | null;
 
     /**
      * Get all enabled internal plugins
@@ -1026,7 +1125,7 @@ interface PluginManifest {
     /**
      * Storage location of the plugin relative to the vault root
      */
-    dir: string;
+    dir?: string;
     /**
      * URL for funding the author
      */
@@ -1038,7 +1137,7 @@ interface PluginManifest {
     /**
      * Whether the plugin is designed for desktop use only
      */
-    isDesktopOnly: boolean;
+    isDesktopOnly?: boolean;
     /**
      * Minimum Obsidian version compatible with the plugin
      */
@@ -1060,6 +1159,7 @@ interface Plugins {
     app: App;
     /**
      * Set of enabled plugin IDs
+     * @remark The plugin ids aren't guaranteed to be either active (in `app.plugins.plugins`) or installed (in `app.plugins.manifests`) 
      */
     enabledPlugins: Set<string>;
     /**
@@ -1067,11 +1167,12 @@ interface Plugins {
      */
     loadingPluginId: string | null;
     /**
-     * Manifests of all the plugins
+     * Manifests of all the plugins that are installed
      */
     manifests: Record<string, PluginManifest>;
     /**
-     * Mapping of plugin ID to plugin instance
+     * Mapping of plugin ID to active plugin instance
+     * @remark Prefer usage of getPlugin to access a plugin
      */
     plugins: Record<string, Plugin>;
     /**
@@ -1410,6 +1511,224 @@ interface ThemeManifest {
     version: '0.0.0' | string;
 }
 
+export interface Token extends EditorRange {
+    type: "tag" | "external-link" | "internal-link";
+}
+
+interface Tree<T> {
+    /**
+     * Currently active item in tree view
+     */
+    activeDom: TreeNode<T> | null;
+    /**
+     * Reference to App
+     */
+    app: App;
+    /**
+     * Container element of the tree view
+     */
+    containerEl: HTMLElement;
+    /**
+     * Currently focused item in tree view
+     */
+    focusedItem: TreeNode<T> | null;
+    /**
+     * Gets the ID of a tree item given its Node
+     */
+    getNodeId: (node: TreeNode<T>) => string | undefined;
+    /**
+     * Handle collapsing of all nodes
+     */
+    handleCollapseAll: () => void;
+    /**
+     * Handle deletion of selected nodes
+     */
+    handleDeleteSelectedItems: () => void | undefined;
+    /**
+     * Handle renaming of focused item
+     */
+    handleRenameFocusedItem: () => void;
+    /**
+     * ID of the view the tree is associated with
+     */
+    id: string;
+    /**
+     * @internal Facilitates rendering of tree view
+     */
+    infinityScroll: InfinityScroll;
+    /**
+     * Whether all items in the tree are collapsed
+     */
+    isAllCollapsed: boolean;
+    /**
+     * Whether tree items should default to collapsed state
+     */
+    prefersCollapsed: boolean;
+    /**
+     * Request saving of the current fold states
+     */
+    requestSaveFolds: () => void;
+    /**
+     * Key scope for tree view
+     */
+    scope: Scope;
+    /**
+     * Currently selected items in tree view
+     */
+    selectedDoms: Set<TreeNode<T>>;
+    /**
+     * The view the tree is associated with
+     */
+    view: View;
+
+    /**
+     * Root item of the tree view
+     */
+    get root(): TreeNode<T>;
+
+    /**
+     * Change the focused item to the next item in specified direction
+     */
+    changeFocusedItem(direction: "forwards" | "backwards"): void;
+    /**
+     * Unselect all selected items in the tree view
+     */
+    clearSelectedDoms(): void;
+    /**
+     * Mark tree item as deselected
+     */
+    deselectItem(node: TreeNode<T>): void;
+    /**
+     * Get the local storage key for the saved tree view folds
+     */
+    getFoldKey(): string;
+    /**
+     * Handle selection of tree item via keyboard event
+     */
+    handleItemSelection(event: MouseEvent, node: TreeNode<T>): void;
+    /**
+     * @internal Registers all keyboard actions to the tree view keyscope
+     */
+    initializeKeyboardNav(): void;
+    /**
+     * Check whether item is a valid tree item
+     */
+    isItem(node: TreeNode<T> | undefined): boolean;
+    /**
+     * Load the saved fold states of the tree view from local storage
+     */
+    loadFolds(): void;
+    /**
+     * Handle keyboard event for moving/selecting tree item below
+     */
+    onKeyArrowDown(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for moving through the hierarchy of tree items (and/or folding/unfolding)
+     */
+    onKeyArrowLeft(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for moving through the hierarchy of tree items (and/or folding/unfolding)
+     */
+    onKeyArrowRight(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for moving/selecting tree item above
+     */
+    onKeyArrowUp(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for opening tree item
+     */
+    onKeyOpen(event: KeyboardEvent): void;
+    /**
+     * @internal Update scroll representation on resize
+     */
+    onResize(): void;
+    /**
+     * Save the current fold states of the tree view to local storage
+     */
+    saveFolds(): void;
+    /**
+     * Mark tree item as selected
+     */
+    selectItem(node: TreeNode<T>): void;
+    /**
+     * Set all items in the tree view to be collapsed or expanded
+     */
+    setCollapseAll(collapse: boolean): void;
+    /**
+     * Set the focused item in the tree view
+     */
+    setFocusedItem(node: TreeNode<T>, scrollIntoView?: boolean): void;
+    /**
+     * (Un)Collapse all items in the tree view
+     */
+    toggleCollapseAll(): void;
+}
+    
+    
+
+type TreeNode<T = object> = T & {
+    childrenEl: HTMLElement;
+    el: HTMLElement;
+    info: {
+        childLeft: number;
+        childLeftPadding: number;
+        childTop: number;
+        computed: boolean;
+        height: number;
+        hidden: boolean;
+        next: boolean;
+        queued: boolean;
+        width: number;
+    };
+    pusherEl: HTMLElement;
+    vChildren: {
+        _children: TreeNode<T>[];
+        owner: TreeNode<T>;
+    };
+}
+
+// NOTE: File-explorer root vs Outline root are different (former is a treeitem, latter just a treenode)
+type TreeItem<T> = TreeNode<T> & {
+    collapseEl: HTMLElement;
+    collapsed: boolean;
+    collapsible: boolean;
+    coverEl: HTMLElement;
+    innerEl: HTMLElement;
+    parent: TreeNode<T> | undefined;
+    selfEl: HTMLElement;
+    view: View;
+
+    /**
+     * Execute collapse functionality on mouse click
+     */
+    onCollapseClick(event: MouseEvent): void;
+    /**
+     * Execute item functionality on clicking tree item
+     */
+    onSelfClick(event: MouseEvent): void;
+    /**
+     * Set clickable state of tree item 
+     */
+    setClickable(clickable: boolean): void;
+    /**
+     * Set collapsed state of tree item
+     */
+    setCollapsed(collapsed: boolean, check: boolean): Promise<undefined>;
+    /**
+     * Set collapsible state of tree item
+     */
+    setCollapsible(collapsible: boolean): void;
+    /**
+     * Toggle collapsed state of tree item
+     */
+    toggleCollapsed(check: boolean): Promise<undefined>;
+    /**
+     * @internal Update the tree item's cover element
+     */
+    updateCollapsed(check: boolean): Promise<undefined>;
+}
+
+
 interface ViewRegistry extends Events {
     /**
      * Mapping of file extensions to view type
@@ -1420,6 +1739,21 @@ interface ViewRegistry extends Events {
      */
     viewByType: Record<string, (leaf: WorkspaceLeaf) => View>;
 
+    /**
+     * Called when a view of type has been registered into the registry
+     */
+    on(name: 'view-registered', callback: (type: string) => void): EventRef;
+    
+    /**
+     * Called when a view of type has been unregistered from the registry
+     */
+    on(name: 'view-unregistered', callback: (type: string) => void): EventRef;
+
+    /**
+     * Called when the file extensions mapping has been updated
+     */
+    on(name: 'extensions-updated', callback: () => void): EventRef;
+
     /**
      * Get the view type associated with a file extension
      * @param extension File extension
@@ -2297,21 +2631,236 @@ declare module 'obsidian' {
     interface FileSystemAdapter extends DataAdapter {
     }
 
+
+    interface MarkdownEditView {
+        triggerClickableToken(token: Token, new_leaf: boolean): void;
+    }
+    
+    interface MarkdownView {
+        editMode: MarkdownEditView;
+    }
+
     interface MarkdownPreviewView {
         renderer: ReadViewRenderer;
     }
 
     interface Menu {
+        /**
+         * Background for the suggestion menu
+         */
+        bgEl: HTMLElement;
+        /**
+         * The currently active submenu, if any
+         */
+        currentSubmenu?: Menu;
+        /**
+         * DOM element of the menu
+         */
         dom: HTMLElement;
+        /**
+         * Callback to execute when the menu is hidden
+         */
+        hideCallback: () => void;
+        /**
+         * Items contained in the menu
+         */
         items: MenuItem[];
-        onMouseOver(evt: MouseEvent): void;
+        /**
+         * @internal Callback that opens the submenu after a delay
+         */
+        openSubmenuSoon: () => void;
+        /**
+         * Parent menu of the current menu
+         */
+        parentMenu: Menu | null;
+        /**
+         * Scope in which the menu is active
+         */
+        scope: Scope;
+        /**
+         * Sections within the menu
+         */
+        sections: string[];
+        /**
+         * @internal Which menuitem is currently selected
+         */
+        selected: number;
+        /**
+         * @internal Configurations for the submenu configs
+         */
+        submenuConfig: Record<string, { title: string, icon: string }>;
+        /**
+         * @internal Whether the submenu is currently unloading
+         */
+        unloading: boolean;
+        /**
+         * Whether the menu is rendered in native mode
+         */
+        useNativeMenu: boolean;
+
+        /**
+         * @internal Children of the menu
+         */
+        _children: unknown[];
+        /**
+         * @internal Events registered on the menu
+         */
+        _events: unknown[];
+        /**
+         * @internal Whether the menu is loaded
+         */
+        _loaded: boolean;
+        
+        /**
+         * @internal Add a section to the menu
+         */
+        addSections(items: string[]): this;
+        /**
+         * @internal Close the currently open submenu
+         */
+        closeSubmenu(): void;
+        /**
+         * @internal Check whether the clicked element is inside the menu
+         */
+        isInside(e: HTMLElement): boolean;
+        /**
+         * @internal Move selection to the next item in the menu
+         * @param e - Keyboard event
+         */
+        onArrowDown(e: KeyboardEvent): boolean;
+        /**
+         * @internal Move selection to the previous item in the menu
+         * @param e - Keyboard event
+         */
+        onArrowUp(e: KeyboardEvent): boolean;
+        /**
+         * @internal Move selection into the submenu
+         */
+        onArrowRight(e: KeyboardEvent): boolean;
+        /**
+         * @internal Move selection out of the submenu
+         */
+        onArrowLeft(e: KeyboardEvent): boolean;
+        /**
+         * @internal Execute selected menu item (does nothing if item is submenu)
+         */
+        onEnter(e: KeyboardEvent): boolean;
+        /**
+         * @internal Pre-emptively closes the menu if click is registered on menu item
+         * @param e
+         */
+        onMenuClick(e: MouseEvent): void;
+        /**
+         * @internal Opens submenu if mouse is hovering over item with submenu
+         * @param e - Mouse event
+         */
+        onMouseOver(e: MouseEvent): boolean;
+        /**
+         * @internal Registers dom events and scope for the menu
+         */
+        onload(): void;
+        /**
+         * @internal Unregisters scope for the menu
+         */
+        onunload():  void;
+        /**
+         * @internal Open the submenu of the selected item
+         * @param item - Item to open submenu for
+         */
+        openSubmenu(item: MenuItem): void;
+        /**
+         * @internal Select the item at the specified index (after either hovering or arrowing over it)
+         * @param index
+         */
+        select(index: number): void;
+        /**
+         * @internal Set the parent element of the menu (i.e. for workspace leaf context menu)
+         * @param el - Element to set as parent
+         */
+        setParentElement(el: HTMLElement): this;
+        /**
+         * @internal Add a section to the submenu config
+         * @param section
+         * @param submenu
+         */
+        setSectionSubmenu(section: string, submenu: {title: string, icon: string}): this;
+        /**
+         * @internal Sort the items in the menu
+         */
+        sort(): void;
+        /**
+         * @internal Unselect the currently selected item and closes the submenu
+         */
+        unselect(): void;
     }
 
     interface MenuItem {
-        callback(): void;
+        /**
+         * The callback that is executed when the menu item is clicked
+         */
+        callback?: () => void;
+        /**
+         * Whether the menu item is checked
+         */
+        checked: boolean | null;
+        /**
+         * Check icon element of the menu item, only present if the item is checked
+         */
+        checkIconEl?: HTMLElement;
+        /**
+         * Whether the menu item is disabled
+         */
+        disabled: boolean;
+        /**
+         * Dom element of the menu item
+         */
         dom: HTMLElement;
+        /**
+         * Icon element of the menu item
+         */
+        iconEl: HTMLElement;
+        /**
+         * Menu the item is in
+         */
+        menu: Menu;
+        /**
+         * The section the item belongs to
+         */
+        section: string;
+        /**
+         * The submenu that is attached to the item
+         */
+        submenu: Menu | null;
+        /**
+         * Title of the menu item
+         */
+        titleEl: string;
+
+        /**
+         * @internal Executes the callback of the onClick event (if not disabled)
+         * @param e - Mouse or keyboard event
+         */
+        handleEvent(e: MouseEvent | KeyboardEvent): void;
+        /**
+         * @internal Remove the icon element from the menu item
+         */
+        removeIcon(): void;
+        /**
+         * @deprecated
+         * @internal Calls `setChecked`, prefer usage of that function instead  
+         * @param active - Whether the menu item should be checked 
+         */
+        setActive(active: boolean): this;
+        /**
+         * Create a submenu on the menu item
+         * @tutorial Creates the foldable menus with more options as seen when you right-click in the editor (e.g. "Insert", "Format", ...) 
+         */
         setSubmenu(): Menu;
-        disabled: boolean;
+        /**
+         * @internal Add warning styling to the menu item
+         * @param warning - Whether the menu item should be styled as a warning
+         */
+        setWarning(warning: boolean): this;
     }
 
     interface MetadataCache {
@@ -2384,6 +2933,18 @@ declare module 'obsidian' {
          */
         workerResolve: unknown;
 
+        /**
+         * Called whenever the metadatacache is fully loaded in
+         * @remark 'finished' is also emitted when the cache is initialized
+         */
+        on(name: 'initialized', callback: () => void): EventRef;
+
+        /**
+         * Called whenever the metadatacache has finished updating
+         */
+        on(name: 'finished', callback: () => void): EventRef;
+        
+
         /**
          * Get all property infos of the vault
          */
@@ -2729,6 +3290,27 @@ declare module 'obsidian' {
         deleted: boolean;
     }
 
+    /**
+     * @internal Used for Obsidian's touch event handling
+     */
+    interface ObsidianTouchEvent {
+        direction: "x" | "y";
+        evt: TouchEvent;
+        points: number;
+        registerCallback: ({
+            move: (x: number) => void,
+            cancel: () => void,
+            finish: (x: number, y: number, z: number) => void
+        }),
+        startX: number;
+        startY: number;
+        targetEl: HTMLElement;
+        touch: Touch;
+        
+        x: number;
+        y: number;
+    }
+
     interface Vault {
         /**
          * Low-level file system adapter for read and write operations
@@ -2753,8 +3335,56 @@ declare module 'obsidian' {
          */
         fileMap: Record<string, TAbstractFile>;
 
+        /**
+         * Called whenever any of Obsidian's settings are changed
+         * @remark Does *not* trigger when a particular plugin's settings are changed, for that, you could monkey-patch the `saveSettings` method of a plugin instance 
+         */
         on(name: 'config-changed', callback: () => void, ctx?: unknown): EventRef;
 
+        /**
+         * @internal Triggered whenever a file gets loaded internally
+         */
+        on(name: 'raw', callback: (path: string) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Not accessible
+         * @remark Always prefer usage of on(name: 'rename', ...) instead
+         */
+        // on(name: 'renamed', callback: (oldPath: string, newPath: string) => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         * @remark Always prefer usage of on(name: 'modify', ...) instead
+         */
+        // on(name: 'modified', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'file-created', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'folder-created', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'file-removed', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'folder-removed', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'closed', callback: () => void): EventRef;       
+        
+        
+        
         /**
          * @internal Add file as child/parent to respective folders
          */
@@ -2993,6 +3623,68 @@ declare module 'obsidian' {
          */
         undoHistory: StateHistory[];
 
+        /**
+         * @internal Triggers when user hovers over any note link element (file explorer, editor, ...)
+         * @remark Used for preparing (Ctrl) hover previews
+         */
+        on(name: 'hover-link', callback: (event: HoverLinkEvent) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Called whenever user opens tab group menu (contains e.g. stacked tabs button)
+         */
+        on(name: 'tab-group-menu', callback: (tabMenu: Menu, tabsLeaf: WorkspaceTabs) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Triggers when user swipes open left/right sidebar
+         */
+        on(name: 'swipe', callback: (touchEvents: ObsidianTouchEvent[]) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when workspace layout is loaded
+         * @remark Prefer usage of onLayoutReady instead
+         */
+        on(name: 'layout-ready', callback: () => void, ctx?: unknown): EventRef;
+        
+        /**
+         * @internal Triggers when user right-clicks on external URL in editor
+         */
+        on(name: 'url-menu', callback: (menu: Menu, url: string) => void, ctx?: unknown): EventRef;
+        
+        /**
+         * Triggers when user clicks on 'N results' button in search view
+         */
+        on(name: 'search:results-menu', callback: (menu: Menu, search: GlobalSearchLeaf) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Called when user shares text on mobile
+         */
+        on(name: 'receive-text-menu', callback: (menu: Menu, x: unknown) => void, ctx?: unknown): EventRef;
+        
+        /**
+         * @internal Called when user shares files on mobile
+         */
+        on(name: 'receive-files-menu', callback: (menu: Menu, x: unknown) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user opens a context menu on a selection of multiple nodes in the canvas
+         */
+        on(name: 'canvas:selection-menu', callback: (menu: Menu, canvasView: CanvasView) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user opens a context menu on a single node in the canvas
+         */
+        on(name: 'canvas:node-menu', callback: (menu: Menu, node: CanvasNode) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user drops edge connection to empty space in the canvas
+         */
+        on(name: 'canvas:node-connection-drop-menu', callback: (menu: Menu, originalNode: CanvasNode, connection: CanvasConnection) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user opens a context menu on a connection in the canvas
+         */
+        on(name: 'canvas:edge-menu', callback: (menu: Menu, connection: CanvasConnection) => void, ctx?: unknown): EventRef;
+
         /**
          * @internal Change active leaf and trigger leaf change event
          */
@@ -3212,6 +3904,25 @@ declare module 'obsidian' {
         tabHeaderEl: HTMLElement;
         tabHeaderInnerIconEl: HTMLElement;
         tabHeaderInnerTitleEl: HTMLElement;
+
+        /**
+         * Triggers when the leaf's history gets updated (e.g. when new file is opened, or moving through history)
+         */
+        on(name: 'history-change', callback: () => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when context menu action is executed on the leaf
+         */
+        on(name: 'leaf-menu', callback: (menu: Menu, leaf: WorkspaceLeaf) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Set the vertical height a leaf may occupy if it is in a split. The height is not set directly, but
+         * by setting the flex-grow (css) of the element. This means to predictably affect the height, you also 
+         * need to use setDimension on the other leafs of the column. (The flex-grow values of every leaf work 
+         basically like a ratio, e.g. 1:2 meaning the first leaf takes 33% of the height, and the second 67%.)
+         * @param flexgrow - sets the flex-grow of the leaf. (0-100)
+         */
+        setDimension(flexgrow?: number | null): void;
     }
 
     interface WorkspaceSplit {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-typings",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Extended type definitions for the Obsidian API (https://obsidian.md)",
   "main": "",
   "types": "obsidian-ex.d.ts",
@@ -24,8 +24,8 @@
     "obsidian": "^1.4.11"
   },
   "devDependencies": {
-    "@ophidian/electron-types": "^24.3.1",
-    "@types/node": "^20.10.7"
+    "@types/node": "^20.10.7",
+    "@types/electron": "npm:@ophidian/electron-types"
   },
   "scripts": {
     "build": "tsc --build --force"

package/CHANGELOG.md

@@ -1,18 +0,0 @@
-# Changelog
-
-## v1.0.3
-- Change `electron-types` types inclusion
-- Added note in `README.md` on automatically including new types
-- Fix lambda definitions and tsc compilatiion
-
-## v1.0.2
-- Changed `any` type to `unknown` to enforcing explicit type casting
-- Fixed `CONTRIBUTING.md` link in `README.md`
-- Added badges to `README.md`
-
-## v1.0.1
-- Automated npm publishing
-
-## v1.0.0 (initial npm release)
-- Made package installable via npm
-- Clarified README, added contribution guidelines

package/CONTRIBUTING.md

@@ -1,235 +0,0 @@
-# Introduction
-
-## General Notes
-Feel free to start typing any part of the Obsidian API that is not yet typed, or fixing/adding additional descriptions to existing typings.
-If you are unsure about anything, don't hesitate to open an issue.
-
-### TSDoc
-Please use [TSDoc](https://tsdoc.org/) to document the typings. This will allow the documentation to be automatically generated
-within your IDE, and can help with the discoverability of the typings.
-
-
-Example: 
-```ts
-interface someObject {
-    /**
-     * Does something specific
-     * @param val1 Enables some functionality
-     * @tutorial Useful for implementing some features for your plugin
-     * @remark Prefer using `someOtherMethod` instead
-     */
-    someMethod(val1: boolean): number;
-
-    /**
-     * Does something that you're not certain about, and should probably not be used
-     * @internal
-     */
-    someInternalMethod(): void;
-}
-```
-
-> [!NOTE]
-> `@internal` --- Method is *very likely* not fully/correctly typed, and/or is not intended to be used by plugins.
-> 
-> `@remark` --- Alternatives that should be used instead, or warnings about the function.
-> 
-> `@tutorial` --- Short description on how the function could be used in your plugin.
-> 
-> `@deprecated` --- Method is deprecated in a particular version (can't be found in `app.js` anymore).
-
-
-# Tutorial
-
-## Adding new typings
-
-### Finding/Discovering new typings 
-
-The first step to add new typings, is finding the object/interface/module you want to add typings for within the Obsidian app.
-One of the easiest way to do this, is to open the developer console (Ctrl+Shift+I), and start searching for the interface you wish to
-type from the `app.` object.
-
-If you want to, for example, add typings for the `InternalPlugins` object, you can type `app.internalPlugins` into the console,
-which will produce the following output:
-
-![images/prototype-reference.png](images/prototype-reference.png)
-
-Note how the internalPlugins object contains multiple prototypes: the `InternalPlugins` interface itself, but also
-the `Events` class and then the `Object` literal (does not need to be typed). This can be determined this by looking at the other definitions in the (un)official API,
-and checking whether the two objects define the same properties.
-
-Thus, to define `InternalPlugin`, you can start by adding each of the methods and properties to a `InternalPlugins` interface:
-
-```ts
-interface InternalPlugins extends Events {
-    // Variables
-    app: App;
-    config: Record<unknown, unknown>;
-    migration: unknown;
-    plugins: Record<unknown, unknown>;
-    
-    // Methods
-    requestSaveConfig(): unknown;
-    enable(): unknown;
-    getEnabledPluginById(var1: unknown): unknown;
-    getEnabledPlugins(): unknown;
-    // ...
-}
-```
-To keep it simple, we first add `unknown` as type to every variable and method -- unless it is obvious what the type should be
-(i.e. `app` will always be an instance of `App`).
-
-Next up, is the most tedious part of adding typings: finding the correct types for each of the methods and variables.
-
-### Typing variables
-
-The easiest way to start, is by tackling the variables first. For example, in the console output, you can see that `config`
-is mapping a string to `true`. In this case, it would be safe to assume that the type of `config` is `Record<string, boolean>`.
-
-```ts
-interface InternalPlugins extends Events {
-    // ...
-    config: Record<string, boolean>;
-    // ...
-}
-```
-
-However, you can take this one step further still by considering the fact that each string is essentialy a different plugin ID.
-In this case, we might just define a new type that contains all the plugin IDs, and use this as the key for the `config` object:
-
-```ts
-type InternalPluginName = 'audio-recorder' | 'backlink' | 'bookmarks' | 'canvas' /*| ... */;
-interface InternalPlugins extends Events {
-    // ...
-    config: Record<InternalPluginName, boolean>;
-    // ...
-}
-```
-
-Similarly, you can define the `plugins` variable as `Record<InternalPluginName, unknown>`.
-
-Further, it is safe to assume that each element in `Plugins` would be some instance of a `InternalPlugin` class, so we
-will also need to add a new interface for this:
-
-```ts
-interface InternalPlugin {
-    app: App;
-    commands: unknown;
-    // etc. (repeat the same procedure)
-}
-
-interface InternalPlugins extends Events {
-    // ...
-    plugins: Record<InternalPluginName, InternalPlugin>;
-    // ...
-}
-```
-
-Make sure to also add brief descriptions (using [TSDoc](https://tsdoc.org/)) to each of the variables. Mark variables that you are not entirely sure about with `@internal`.
-Feel free to copy descriptions from previous typings, or from the official API.
-
-
-### Typing methods
-
-Typing methods is a bit more difficult, as aside you will need to know what the method does, and what the expected input and output is.
-
-You could start by typing the methods that do not take any arguments, and have a simple return type. For example, the `requestSaveConfig` method.
-From the name, we can already make the assumption that this method will probably _not_ return anything, as it is just telling
-the app that a config should be saved, the method will thus _likely_ be of type `void`.
-
-However, to make sure whether this assumption is correct, you _**should**_ check the source code (see next section).
-If possible, you can also run the method in the console, and see what happens (in this case, nothing happens, so it is likely just `void`).
-
-As before, if you are not certain about the return type or the workings of the function in general,
-add a `@internal` tag to the method description, and/or mark the return type as `unknown`.
-
-
-```ts
-interface InternalPlugins extends Events {
-    // ...
-    /**
-     * @internal Request save of plugin configs
-     */
-    requestSaveConfig(): unknown;
-    // ...
-}
-```
-
-Next up, are methods that take arguments. For example, the `getEnabledPluginById` method takes a single argument.
-It is very likely that this argument will just be of type `InternalPluginName`, but again, you could easily verify this by
-running the method in the console (i.e. `app.internalPlugins.getEnabledPluginById('audio-recorder')` and `app.internalPlugins.getEnabledPluginById('wrong-id')`).
-
-```ts
-interface InternalPlugins extends Events {
-    // ...
-    /**
-     * Get an internal plugin by ID
-     * @param id - ID of the plugin to get
-     * @returns Plugin instance
-     */
-    getEnabledPluginById(id: InternalPluginName): InternalPlugin;
-    // ...
-}
-```
-
-
-## Traversing and analysing the source code
-
-Finally, this is both the most tedious but also the most important technique: finding the definition of the method in the minified source code.
-
-Start off by going back to the console, and going into the `Sources` tab. Here you will find the `app.js` file where
-all the internal methods are defined.
-
-1. Go to the `Sources` tab
-2. Select the `app.js` file
-3. `Pretty format` the code (optional)
-4. Copy the code to your IDE of choice (optional, but recommended)
-
-
-![images/accessing-main.png](images/accessing-main.png)
-
-With access to the minified code, you can now start searching through it and find the definition of the method you are trying to type.
-
-For any method "XYZ", start by just searching for "XYZ". Generally, the method is defined as either:
-- `t.XYZ = ...` (for prototype methods)
-- `t.prototype.XYZ = ...` (for prototype methods)
-- `function XYZ(` (for internal/minified methods)
-
-At this stage, you might get lucky and get a single definition, or you may get multiple definitions of the method. 
-In the latter case,
-you will need try to look at the context of the code to determine which interface/class the method belongs to. 
-The main tip for finding the correct definition, is to look at the other methods being defined on the prototype, 
-and check if these match with the other methods of your object.
-
-With the correct line found for the definition, you can now start analysing the code to determine the input/output types
-and its behaviour. 
-
-For example, the `requestSaveConfig` method (seen earlier) is defined as follows:
-
-```js
-n.requestSaveConfig = at(n.saveConfig.bind(n), 1e3, !0),
-```
-
-Here, we find the following three things:
-- `at` is a minified function that takes three arguments, and its return value is the return value of the method
-- `1e3` is shorthand notation for `1000`
-- `!0` is shorthand notation for `true`
-
-(There are many shorthands and structural changes that you will need to get used to in the minified code)
-
-Since we don't know what `at` does, we need to start searching through the code again. Make sure to enable caps + whole word search, as `at` is a very common word.
-Start by searching for `function at`, or `.prototype.at`. With any luck, this will lead you to the following definition:
-
-```js
-function at(e, t, n) {
-    void 0 === t && (t = 0),
-    void 0 === n && (n = !1);
-    var i, r = null, o = null, a = null, s = 0, l = function() {
-        var t = o
-            , n = a;
-        /*   ...    */
-    }
-}
-```
-
-You may want to pass the code through your favourite flavour of LLM or de-minifier to make the code at least somewhat understandable.
-Depending on whether you manage to decipher the code, you can now explicitly define the behaviour and/or types of the method.