and create a that + /// will be passed to your handler, and is expected to be filled with your custom elements. + abstract registerMarkdownCodeBlockProcessor: language: string * handler: (string -> HTMLElement -> MarkdownPostProcessorContext -> U2, unit>) * ?sortOrder: float -> MarkdownPostProcessor + /// Runs callback on all currently loaded instances of CodeMirror, + /// then registers the callback for all future CodeMirror instances. + abstract registerCodeMirror: callback: (obj -> obj option) -> unit + /// Registers a CodeMirror 6 extension. + /// To reconfigure cm6 extensions for your plugin on the fly, you can pass an array here and dynamically + /// modify it. Once this array is modified, call `Workspace.updateOptions()` to have the changes applied. + /// - must be a CodeMirror 6 `Extension`, or an array of Extensions. + abstract registerEditorExtension: extension: obj -> unit + /// Register a handler for obsidian:// URLs. + /// - the action string. For example, "open" corresponds to `obsidian://open`. + /// - the callback to trigger. You will be passed the key-value pair that is decoded from the query. + /// For example, `obsidian://open?key=value` would generate `{"action": "open", "key": "value"}`. + abstract registerObsidianProtocolHandler: action: string * handler: ObsidianProtocolHandler -> unit + /// Register an EditorSuggest which can provide live suggestions while the user is typing. + abstract registerEditorSuggest: editorSuggest: EditorSuggest -> unit + abstract loadData: unit -> Promise + abstract saveData: data: obj option -> Promise + +type [] PluginStatic = + [] abstract Create: app: App * manifest: PluginManifest -> Plugin + +type [] PluginManifest = + abstract dir: string option with get, set + abstract id: string with get, set + abstract name: string with get, set + abstract author: string with get, set + abstract version: string with get, set + abstract minAppVersion: string with get, set + abstract description: string with get, set + abstract authorUrl: string option with get, set + abstract isDesktopOnly: bool option with get, set + +type [] PluginSettingTab = + inherit SettingTab + +type [] PluginSettingTabStatic = + [] abstract Create: app: App * plugin: Plugin -> PluginSettingTab + +type [] Point = + abstract x: float with get, set + abstract y: float with get, set + + +type [] PopoverSuggest<'T> = + inherit ISuggestOwner<'T> + inherit CloseableComponent + abstract ``open``: unit -> unit + abstract close: unit -> unit + /// Render the suggestion item into DOM. + abstract renderSuggestion: value: 'T * el: HTMLElement -> unit + /// Called when the user makes a selection. + abstract selectSuggestion: value: 'T * evt: U2 -> unit + +type [] PopoverSuggestStatic = + [] abstract Create: app: App * ?scope: Scope -> PopoverSuggest<'T> + +type [] Pos = + abstract start: Loc with get, set + abstract ``end``: Loc with get, set + +type [] PreparedQuery = + abstract query: string with get, set + abstract tokens: ResizeArray with get, set + abstract fuzzy: ResizeArray with get, set + +type [] Rect_2 = + abstract x: float with get, set + abstract y: float with get, set + abstract w: float with get, set + abstract h: float with get, set + +type [] ReferenceCache = + inherit CacheItem + abstract link: string with get, set + abstract original: string with get, set + /// if title is different than link text, in the case of [[page name|display name]] + abstract displayText: string option with get, set + +type [] RequestUrlParam = + abstract url: string with get, set + abstract ``method``: string option with get, set + abstract contentType: string option with get, set + abstract body: U2 option with get, set + abstract headers: obj with get, set + +type [] RequestUrlResponse = + abstract status: float with get, set + abstract headers: obj with get, set + abstract arrayBuffer: ArrayBuffer with get, set + abstract json: obj option with get, set + abstract text: string with get, set + +type [] Scope = + /// - `Mod`, `Ctrl`, `Meta`, `Shift`, or `Alt`. `Mod` translates to `Meta` on macOS and `Ctrl` otherwise. + /// - Keycode from https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values + /// - the callback + abstract register: modifiers: ResizeArray * key: string option * func: KeymapEventListener -> KeymapEventHandler + abstract unregister: handler: KeymapEventHandler -> unit + +type [] ScopeStatic = + [] abstract Create: ?parent: Scope -> Scope + +type [] SearchComponent = + inherit AbstractTextComponent + abstract clearButtonEl: HTMLElement with get, set + abstract onChanged: unit -> unit + +type [] SearchComponentStatic = + [] abstract Create: containerEl: HTMLElement -> SearchComponent + +type SearchMatches = + ResizeArray + +type SearchMatchPart = + float * float + +type [] SearchResult = + abstract score: float with get, set + abstract matches: SearchMatches with get, set + +type [] SearchResultContainer = + abstract ``match``: SearchResult with get, set + +type [] SectionCache = + inherit CacheItem + /// The block ID of this section, if defined. + abstract id: string option with get, set + /// The type string generated by the parser. + abstract ``type``: string with get, set + +type [] Setting = + abstract settingEl: HTMLElement with get, set + abstract infoEl: HTMLElement with get, set + abstract nameEl: HTMLElement with get, set + abstract descEl: HTMLElement with get, set + abstract controlEl: HTMLElement with get, set + abstract components: ResizeArray with get, set + abstract setName: name: U2 -> Setting + abstract setDesc: desc: U2 -> Setting + abstract setClass: cls: string -> Setting + abstract setTooltip: tooltip: string -> Setting + abstract setHeading: unit -> Setting + abstract setDisabled: disabled: bool -> Setting + abstract addButton: cb: (ButtonComponent -> obj option) -> Setting + abstract addExtraButton: cb: (ExtraButtonComponent -> obj option) -> Setting + abstract addToggle: cb: (ToggleComponent -> obj option) -> Setting + abstract addText: cb: (TextComponent -> obj option) -> Setting + abstract addSearch: cb: (SearchComponent -> obj option) -> Setting + abstract addTextArea: cb: (TextAreaComponent -> obj option) -> Setting + abstract addMomentFormat: cb: (MomentFormatComponent -> obj option) -> Setting + abstract addDropdown: cb: (DropdownComponent -> obj option) -> Setting + abstract addSlider: cb: (SliderComponent -> obj option) -> Setting + /// Facilitates chaining + abstract ``then``: cb: (Setting -> obj option) -> Setting + abstract clear: unit -> Setting + +type [] SettingStatic = + [] abstract Create: containerEl: HTMLElement -> Setting + +type [] SettingTab = + abstract app: App with get, set + abstract containerEl: HTMLElement with get, set + abstract display: unit -> obj option + abstract hide: unit -> obj option + +type [] SettingTabStatic = + [] abstract Create: unit -> SettingTab + +type [] SliderComponent = + inherit ValueComponent + abstract sliderEl: HTMLInputElement with get, set + abstract setDisabled: disabled: bool -> SliderComponent + abstract setLimits: min: float * max: float * step: U2 -> SliderComponent + abstract getValue: unit -> float + abstract setValue: value: float -> SliderComponent + abstract getValuePretty: unit -> string + abstract setDynamicTooltip: unit -> SliderComponent + abstract showTooltip: unit -> unit + abstract onChange: callback: (float -> obj option) -> SliderComponent + +type [] SliderComponentStatic = + [] abstract Create: containerEl: HTMLElement -> SliderComponent + +type [] [] SplitDirection = + | Vertical + | Horizontal + +type [] Stat = + abstract ``type``: StatType with get, set + abstract ctime: float with get, set + abstract mtime: float with get, set + abstract size: float with get, set + +type [] SubpathResult = + abstract start: Loc with get, set + abstract ``end``: Loc option with get, set + +type [] SuggestModal<'T> = + inherit Modal + inherit ISuggestOwner<'T> + abstract limit: float with get, set + abstract emptyStateText: string with get, set + abstract inputEl: HTMLInputElement with get, set + abstract resultContainerEl: HTMLElement with get, set + abstract setPlaceholder: placeholder: string -> unit + abstract setInstructions: instructions: ResizeArray -> unit + abstract onNoSuggestion: unit -> unit + /// Called when the user makes a selection. + abstract selectSuggestion: value: 'T * evt: U2 -> unit +// abstract getSuggestions: query: string -> U2, Promise>> //TODO: set thisd + abstract getSuggestions: query: string -> U2, Promise>> + /// Render the suggestion item into DOM. + abstract renderSuggestion: value: 'T * el: HTMLElement -> obj option + abstract onChooseSuggestion: item: 'T * evt: U2 -> obj option + +type [] SuggestModalStatic = + [] abstract Create: app: App -> SuggestModal<'T> + +/// This can be either a `TFile` or a `TFolder`. +type [] TAbstractFile = + abstract vault: Vault with get, set + abstract path: string with get, set + abstract name: string with get, set + abstract parent: TFolder with get, set + +/// This can be either a `TFile` or a `TFolder`. +type [] TAbstractFileStatic = + [] abstract Create: unit -> TAbstractFile + +type [] TagCache = + inherit CacheItem + abstract tag: string with get, set + +type [] Tasks = + abstract add: callback: (unit -> Promise) -> unit + abstract addPromise: promise: Promise -> unit + abstract isEmpty: unit -> bool + abstract promise: unit -> Promise + +type [] TasksStatic = + [] abstract Create: unit -> Tasks + +type [] TextAreaComponent = + inherit AbstractTextComponent + +type [] TextAreaComponentStatic = + [] abstract Create: containerEl: HTMLElement -> TextAreaComponent + +type [] TextComponent = + inherit AbstractTextComponent + +type [] TextComponentStatic = + [] abstract Create: containerEl: HTMLElement -> TextComponent + +/// This class implements a plaintext-based editable file view, which can be loaded and saved given an editor. +/// +/// Note that by default, this view only saves when it's closing. To implement auto-save, your editor should +/// call `this.requestSave()` when the content is changed. +type [] TextFileView = + inherit EditableFileView + /// In memory data + abstract data: string with get, set + /// Debounced save in 2 seconds from now + abstract requestSave: (unit -> unit) with get, set + abstract onUnloadFile: file: TFile -> Promise + abstract onLoadFile: file: TFile -> Promise + abstract save: ?clear: bool -> Promise + /// Gets the data from the editor. This will be called to save the editor contents to the file. + abstract getViewData: unit -> string + /// Set the data to the editor. This is used to load the file contents. + /// + /// If clear is set, then it means we're opening a completely different file. + /// In that case, you should call clear(), or implement a slightly more efficient + /// clearing mechanism given the new data to be set. + abstract setViewData: data: string * clear: bool -> unit + /// Clear the editor. This is usually called when we're about to open a completely + /// different file, so it's best to clear any editor states like undo-redo history, + /// and any caches/indexes associated with the previous file contents. + abstract clear: unit -> unit + +/// This class implements a plaintext-based editable file view, which can be loaded and saved given an editor. +/// +/// Note that by default, this view only saves when it's closing. To implement auto-save, your editor should +/// call `this.requestSave()` when the content is changed. +type [] TextFileViewStatic = + [] abstract Create: leaf: WorkspaceLeaf -> TextFileView + +type [] TFile = + inherit TAbstractFile + abstract stat: FileStats with get, set + abstract basename: string with get, set + abstract extension: string with get, set + +type [] TFileStatic = + [] abstract Create: unit -> TFile + +type [] TFolder = + inherit TAbstractFile + abstract children: ResizeArray with get, set + abstract isRoot: unit -> bool + +type [] TFolderStatic = + [] abstract Create: unit -> TFolder + +type [] ToggleComponent = + inherit ValueComponent + abstract toggleEl: HTMLElement with get, set + abstract setDisabled: disabled: bool -> ToggleComponent + abstract getValue: unit -> bool + abstract setValue: on: bool -> ToggleComponent + abstract setTooltip: tooltip: string -> ToggleComponent + abstract onClick: unit -> unit + abstract onChange: callback: (bool -> obj option) -> ToggleComponent + +type [] ToggleComponentStatic = + [] abstract Create: containerEl: HTMLElement -> ToggleComponent + +type UserEvent = + U4 + +type [] ValueComponent<'T> = + inherit BaseComponent + abstract registerOptionListener: listeners: obj * key: string -> ValueComponent<'T> + abstract getValue: unit -> 'T + abstract setValue: value: 'T -> ValueComponent<'T> + +type [] ValueComponentStatic = + [] abstract Create: unit -> ValueComponent<'T> + +type [] Vault = + inherit Events + abstract adapter: DataAdapter with get, set + /// Gets the path to the config folder. + /// This value is typically `.obsidian` but it could be different. + abstract configDir: string with get, set + /// Gets the name of the vault + abstract getName: unit -> string + abstract getAbstractFileByPath: path: string -> TAbstractFile option + abstract getRoot: unit -> TFolder + abstract create: path: string * data: string * ?options: DataWriteOptions -> Promise + abstract createBinary: path: string * data: ArrayBuffer * ?options: DataWriteOptions -> Promise + abstract createFolder: path: string -> Promise + abstract read: file: TFile -> Promise + abstract cachedRead: file: TFile -> Promise + abstract readBinary: file: TFile -> Promise + abstract getResourcePath: file: TFile -> string + /// - The file or folder to be deleted + /// - Should attempt to delete folder even if it has hidden children + abstract delete: file: TAbstractFile * ?force: bool -> Promise + /// Tries to move to system trash. If that isn't successful/allowed, use local trash + /// - The file or folder to be deleted + /// - Should move to system trash + abstract trash: file: TAbstractFile * system: bool -> Promise + abstract rename: file: TAbstractFile * newPath: string -> Promise + abstract modify: file: TFile * data: string * ?options: DataWriteOptions -> Promise + abstract modifyBinary: file: TFile * data: ArrayBuffer * ?options: DataWriteOptions -> Promise + abstract append: file: TFile * data: string * ?options: DataWriteOptions -> Promise + abstract copy: file: TFile * newPath: string -> Promise + abstract getAllLoadedFiles: unit -> ResizeArray + abstract getMarkdownFiles: unit -> ResizeArray + abstract getFiles: unit -> ResizeArray + [] abstract on_create: callback: (TAbstractFile -> obj option) * ?ctx: obj -> EventRef + [] abstract on_modify: callback: (TAbstractFile -> obj option) * ?ctx: obj -> EventRef + [] abstract on_delete: callback: (TAbstractFile -> obj option) * ?ctx: obj -> EventRef + [] abstract on_rename: callback: (TAbstractFile -> string -> obj option) * ?ctx: obj -> EventRef + [] abstract on_closed: callback: (unit -> obj option) * ?ctx: obj -> EventRef + +type [] VaultStatic = + [] abstract Create: unit -> Vault + abstract recurseChildren: root: TFolder * cb: (TAbstractFile -> obj option) -> unit + +type [] View = + inherit Component + abstract app: App with get, set + abstract icon: string with get, set + abstract navigation: bool with get, set + abstract leaf: WorkspaceLeaf with get, set + abstract containerEl: HTMLElement with get, set + abstract onOpen: unit -> Promise + abstract onClose: unit -> Promise + abstract getViewType: unit -> string + abstract getState: unit -> obj option + abstract setState: state: obj option * result: ViewStateResult -> Promise + abstract getEphemeralState: unit -> obj option + abstract setEphemeralState: state: obj option -> unit + abstract getIcon: unit -> string + /// Called when the size of this view is changed. + abstract onResize: unit -> unit + abstract getDisplayText: unit -> string + abstract onHeaderMenu: menu: Menu -> unit + +type [] ViewStatic = + [] abstract Create: leaf: WorkspaceLeaf -> View + +type [] ViewCreator = + [] abstract Invoke: leaf: WorkspaceLeaf -> View + +type [] ViewState = + abstract ``type``: string with get, set + abstract state: obj option with get, set + abstract active: bool option with get, set + abstract pinned: bool option with get, set + abstract group: WorkspaceLeaf option with get, set + +type [] ViewStateResult = + interface end + +type [] Workspace = + inherit Events + abstract leftSplit: U2 with get, set + abstract rightSplit: U2 with get, set + abstract leftRibbon: WorkspaceRibbon with get, set + abstract rightRibbon: WorkspaceRibbon with get, set + abstract rootSplit: WorkspaceSplit with get, set + abstract activeLeaf: WorkspaceLeaf option with get, set + abstract containerEl: HTMLElement with get, set + abstract layoutReady: bool with get, set + abstract requestSaveLayout: (unit -> unit) with get, set + abstract requestSaveHistory: (unit -> unit) with get, set + /// Runs the callback function right away if layout is already ready, + /// or push it to a queue to be called later when layout is ready. + abstract onLayoutReady: callback: (unit -> obj option) -> unit + abstract changeLayout: workspace: obj option -> Promise + abstract getLayout: unit -> obj option + abstract createLeafInParent: parent: WorkspaceSplit * index: float -> WorkspaceLeaf + abstract splitLeaf: source: WorkspaceItem * newLeaf: WorkspaceItem * ?direction: SplitDirection * ?before: bool -> unit + abstract createLeafBySplit: leaf: WorkspaceLeaf * ?direction: SplitDirection * ?before: bool -> WorkspaceLeaf + abstract splitActiveLeaf: ?direction: SplitDirection -> WorkspaceLeaf + abstract splitLeafOrActive: ?leaf: WorkspaceLeaf * ?direction: SplitDirection -> WorkspaceLeaf + abstract duplicateLeaf: leaf: WorkspaceLeaf * ?direction: SplitDirection -> Promise + abstract getUnpinnedLeaf: ?``type``: string -> WorkspaceLeaf + abstract getLeaf: ?newLeaf: bool -> WorkspaceLeaf + abstract openLinkText: linktext: string * sourcePath: string * ?newLeaf: bool * ?openViewState: OpenViewState -> Promise + /// Sets the active leaf + /// - The new active leaf + /// - Whether to push the navigation history, or replace the current navigation history. + /// - Whether to ask the leaf to focus. + abstract setActiveLeaf: leaf: WorkspaceLeaf * ?pushHistory: bool * ?focus: bool -> unit + abstract getLeafById: id: string -> WorkspaceLeaf + abstract getGroupLeaves: group: string -> ResizeArray + abstract getMostRecentLeaf: unit -> WorkspaceLeaf + abstract getLeftLeaf: split: bool -> WorkspaceLeaf + abstract getRightLeaf: split: bool -> WorkspaceLeaf + abstract getActiveViewOfType: ``type``: Constructor<'T> -> 'T option + abstract getActiveFile: unit -> TFile option + abstract iterateRootLeaves: callback: (WorkspaceLeaf -> obj option) -> unit + abstract iterateAllLeaves: callback: (WorkspaceLeaf -> obj option) -> unit + abstract getLeavesOfType: viewType: string -> ResizeArray + abstract detachLeavesOfType: viewType: string -> unit + abstract revealLeaf: leaf: WorkspaceLeaf -> unit + abstract getLastOpenFiles: unit -> ResizeArray + /// Calling this function will update/reconfigure the options of all markdown panes. + /// It is fairly expensive, so it should not be called frequently. + abstract updateOptions: unit -> unit + abstract iterateCodeMirrors: callback: (obj -> obj option) -> unit + [] abstract ``on_quick-preview``: callback: (TFile -> string -> obj option) * ?ctx: obj -> EventRef + [] abstract on_resize: callback: (unit -> obj option) * ?ctx: obj -> EventRef + [] abstract on_click: callback: (MouseEvent -> obj option) * ?ctx: obj -> EventRef + [] abstract ``on_active-leaf-change``: callback: (WorkspaceLeaf option -> obj option) * ?ctx: obj -> EventRef + [] abstract ``on_file-open``: callback: (TFile option -> obj option) * ?ctx: obj -> EventRef + [] abstract ``on_layout-change``: callback: (unit -> obj option) * ?ctx: obj -> EventRef + /// Triggered when the CSS of the app has changed. + [] abstract ``on_css-change``: callback: (unit -> obj option) * ?ctx: obj -> EventRef + /// Triggered when the user opens the context menu on a file. + [] abstract ``on_file-menu``: callback: (Menu -> TAbstractFile -> string -> WorkspaceLeaf -> obj option) * ?ctx: obj -> EventRef + /// Triggered when the user opens the context menu on an editor. + [] abstract ``on_editor-menu``: callback: (Menu -> Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef + /// Triggered when changes to an editor has been applied, either programmatically or from a user event. + [] abstract ``on_editor-change``: callback: (Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef + /// Triggered when the editor receives a paste event. + /// Check for `evt.defaultPrevented` before attempting to handle this event, and return if it has been already handled. + /// Use `evt.preventDefault()` to indicate that you've handled the event. + [] abstract ``on_editor-paste``: callback: (ClipboardEvent -> Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef + /// Triggered when the editor receives a drop event. + /// Check for `evt.defaultPrevented` before attempting to handle this event, and return if it has been already handled. + /// Use `evt.preventDefault()` to indicate that you've handled the event. + [] abstract ``on_editor-drop``: callback: (DragEvent -> Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef + [] abstract on_codemirror: callback: (obj -> obj option) * ?ctx: obj -> EventRef + /// Triggered when the app is about to quit. Not guaranteed to actually run. + /// Perform some best effort cleanup here. + [] abstract on_quit: callback: (Tasks -> obj option) * ?ctx: obj -> EventRef + +type [] WorkspaceStatic = + [] abstract Create: unit -> Workspace + +type [] WorkspaceItem = + inherit Events + abstract getRoot: unit -> WorkspaceItem + +type [] WorkspaceItemStatic = + [] abstract Create: unit -> WorkspaceItem + +type [] WorkspaceLeaf = + inherit WorkspaceItem + abstract view: View with get, set + abstract openFile: file: TFile * ?openState: OpenViewState -> Promise + abstract ``open``: view: View -> Promise + abstract getViewState: unit -> ViewState + abstract setViewState: viewState: ViewState * ?eState: obj -> Promise + abstract getEphemeralState: unit -> obj option + abstract setEphemeralState: state: obj option -> unit + abstract togglePinned: unit -> unit + abstract setPinned: pinned: bool -> unit + abstract setGroupMember: other: WorkspaceLeaf -> unit + abstract setGroup: group: string -> unit + abstract detach: unit -> unit + abstract getIcon: unit -> string + abstract getDisplayText: unit -> string + abstract onResize: unit -> unit + [] abstract ``on_pinned-change``: callback: (bool -> obj option) * ?ctx: obj -> EventRef + [] abstract ``on_group-change``: callback: (string -> obj option) * ?ctx: obj -> EventRef + +type [] WorkspaceLeafStatic = + [] abstract Create: unit -> WorkspaceLeaf + +type [] WorkspaceMobileDrawer = + inherit WorkspaceParent + abstract collapsed: bool with get, set + abstract expand: unit -> unit + abstract collapse: unit -> unit + abstract toggle: unit -> unit + +type [] WorkspaceMobileDrawerStatic = + [] abstract Create: unit -> WorkspaceMobileDrawer + +type [] WorkspaceParent = + inherit WorkspaceItem + +type [] WorkspaceParentStatic = + [] abstract Create: unit -> WorkspaceParent + +type [] WorkspaceRibbon = + interface end + +type [] WorkspaceRibbonStatic = + [] abstract Create: unit -> WorkspaceRibbon + +type [] WorkspaceSidedock = + inherit WorkspaceSplit + abstract collapsed: bool with get, set + abstract toggle: unit -> unit + abstract collapse: unit -> unit + abstract expand: unit -> unit + +type [] WorkspaceSidedockStatic = + [] abstract Create: unit -> WorkspaceSidedock + +type [] WorkspaceSplit = + inherit WorkspaceParent + +type [] WorkspaceSplitStatic = + [] abstract Create: unit -> WorkspaceSplit + +type [] WorkspaceTabs = + inherit WorkspaceParent + +type [] WorkspaceTabsStatic = + [] abstract Create: unit -> WorkspaceTabs + +type [] Platform = + /// The UI is in desktop mode. + abstract isDesktop: bool with get, set + /// The UI is in mobile mode. + abstract isMobile: bool with get, set + /// We're running the electron-based desktop app. + abstract isDesktopApp: bool with get, set + /// We're running the capacitor-js mobile app. + abstract isMobileApp: bool with get, set + /// We're running the iOS app. + abstract isIosApp: bool with get, set + /// We're running the Android app. + abstract isAndroidApp: bool with get, set + /// We're on a macOS device, or a device that pretends to be one (like iPhones and iPads). + /// Typically used to detect whether to use command-based hotkeys vs ctrl-based hotkeys. + abstract isMacOS: bool with get, set + /// We're running in Safari. + /// Typically used to provide workarounds for Safari bugs. + abstract isSafari: bool with get, set + +type [] DomElementInfoAttr = + [] abstract Item: key: string -> U3 option with get, set + +type [] [] AjaxOptionsMethod = + | [] GET + | [] POST + +type [] [] StatType = + | File + | Folder diff --git a/Program.fs b/Program.fs new file mode 100644 index 0000000..fb6580b --- /dev/null +++ b/Program.fs @@ -0,0 +1,266 @@ +module Program +open Obsidian +open Fable.Core +open Fable.Core.JsInterop + +[] +let obsidian : Obsidian.IExports = jsNative + +type SamplePluginSettings = { + mutable mySetting : string +} + +let defaultSettings : SamplePluginSettings = { + mySetting = "default" +} + +[] +type DefaultCommand() = + do () + +let defaultCommand () = + let mutable mid = "" + let mutable mname = "" + let mutable _cb = None + let mutable _ccb = None + let mutable _hotkeys = None + let mutable _editorCallback = None + let mutable _editorCheckCallback = None + + { new Command with + member this.callback + with get () = _cb + and set v = _cb <- v + + member this.checkCallback + with get () = _ccb + and set v = _ccb <- v + + member this.editorCallback + with get () = _editorCallback + and set v = _editorCallback <- v + + member this.editorCheckCallback + with get () = _editorCheckCallback + and set v = _editorCheckCallback <- v + + member this.hotkeys + with get () = _hotkeys + and set v = _hotkeys <- v + + member this.icon: string option = None + + member this.icon + with set (v: string option): unit = () + + member this.id: string = mid + + member this.id + with set (v: string): unit = mid <- v + + member this.mobileOnly: bool option = None + + member this.mobileOnly + with set (v: bool option): unit = () + + member this.name: string = mname + + member this.name + with set (v: string): unit = mname <- v + } + +[] +type DefaultPluginSettingTab(app, plugin) = + do () + +type SamplePluginSettingTab(app, plugin) as instance = + inherit DefaultPluginSettingTab(app, plugin) + + let settings = + instance :> obj :?> PluginSettingTab + + let init () = + settings?plugin <- plugin + + instance?display <- fun () -> + let containerEl : HTMLElement = settings?containerEl + containerEl.empty () + + let mutable setting : Setting = obsidian.Setting.Create(containerEl) + + setting <- setting + .setName(U2.Case1 "Setting #1") + .setDesc(U2.Case1 "It's a secret") + .addText(fun text -> + text + .setPlaceholder("Enter your secret") + .setValue(plugin?settings.mySetting) + .onChange(fun value -> + settings?plugin?settings.mySetting <- value + settings?plugin?saveSettings () + Some () + ) |> ignore + + Some () + ) + + do init () + + +[] +type DefaultModal(app) = + do () + +type SampleModal(app) as instance = + inherit DefaultModal(app) + + let modal = + instance :> obj :?> Modal + + let init () = + + modal?onOpen <- fun () -> + let contentEl : HTMLElement = modal?contentEl + U2.Case1 "Woah!" |> contentEl.setText + + modal?onClose <- fun () -> + let contentEl : HTMLElement = modal?contentEl + contentEl.empty () + + do init () + + +// This workaround allows the members to be defined dynamically, without implementing +// the whole interface. +[] +type DefaultPlugin(app, manifest) = + do () + +// Note: This cannot be named "Plugin", or the import from the Obsidian API will be renamed +type SamplePlugin(app, manifest) as instance = + inherit DefaultPlugin(app, manifest) + + // This is what is actually holding the plugin data + // It would be better to have the main plugin implement this interface, but I can't quite + // get it to work right without an absurd amount of boilerplate + let plugin = + instance :> obj :?> Plugin + + let init () : unit = + plugin?loadSettings <- (fun _ -> + promise { + let! data = plugin.loadData () + + match data with + | None -> plugin?settings <- defaultSettings + | Some v -> + try + plugin?settings <- v :?> SamplePluginSettings + with + | _ -> + plugin?settings <- defaultSettings + } + ) + + plugin?saveSettings <- (fun () -> + promise { + do! plugin.saveData (Some(!!plugin?settings)) + } + ) + + // This creates an icon in the left ribbon. + plugin?ribbonIconEl <- + // Called when the user clicks the icon. + let callback (evt : Browser.Types.MouseEvent) : Obsidian.Notice = + obsidian.Notice.Create(U2.Case1 "This is a notice!") + in + + plugin?addRibbonIcon("dice", "Sample Plugin", callback) + + // Perform additional things with the ribbon + (plugin?ribbonIconEl : Element).addClass ( + let array = new ResizeArray(1) + array.Add("my-plugin-ribbon-class") + array + ) + + // This adds a status bar item to the bottom of the app. Does not work on mobile apps. + let statusBarItemEl : Element = plugin?addStatusBarItem () + "Status Bar Text" |> U2.Case1 |> statusBarItemEl.setText + + + // This adds a simple command that can be triggered anywhere + plugin?addCommand ( + let mutable cmd = defaultCommand () + cmd.id <- "open-sample-modal-simple" + cmd.name <- "Open sample modal (simple)" + cmd.callback <- Some (fun _ -> + Some((new SampleModal(plugin?app) :> obj :?> Modal).``open`` ()) + ) + cmd + ) + + // This adds an editor command that can perform some operation on the current editor instance + plugin?addCommand ( + let mutable cmd = defaultCommand () + cmd.id <- "sample-editor-command" + cmd.name <- "Sample editor command" + cmd.editorCallback <- Some (fun (editor : Editor) (view : MarkdownView) -> + printf "%A" (editor.getSelection ()) + let replacement = editor.replaceSelection ("Sample Editor Command") + Some replacement + ) + cmd + ) + + // This adds a complex command that can check whether the current state of the app allows execution of the command + plugin?addCommand ( + let mutable cmd = defaultCommand () + cmd.id <- "open-sample-modal-complex" + cmd.name <- "Open sample modal (complex)" + cmd.checkCallback <- Some (fun checking -> + // Conditions to check + let app : App = plugin?app + let markdownView = + obsidian.MarkdownView :?> Constructor + |> app.workspace.getActiveViewOfType + match markdownView with + | Some markdownView -> + // If checking is true, we're simply "checking" if the command can be run. + // If checking is false, then we want to actually perform the operation. + if checking |> not then + Some((new SampleModal(plugin?app) :> obj :?> Modal).``open`` ()) + |> ignore + + // This command will only show up in Command Palette when the check function returns true + true |> U2.Case1 + | None -> + false |> U2.Case1 + + ) + cmd + ) + + // This adds a settings tab so the user can configure various aspects of the plugin + plugin?addSettingTab (new SamplePluginSettingTab (plugin?app, plugin)) + + // If the plugin hooks up any global DOM events (on parts of the app that doesn't belong to this plugin) + // Using this function will automatically remove the event listener when this plugin is disabled. + plugin?registerDomEvent (Browser.Dom.document, "click", fun (evt : Browser.Types.MouseEvent) -> ( + printfn "click: %A" evt + )) + + // When registering intervals, this function will automatically clear the interval when the plugin is disabled. + plugin?registerInterval Browser.Dom.window.setInterval (fun () -> printfn "setInterval") (5 * 60 * 1000) + + () + + let onload: unit -> unit = fun _ -> plugin?settings <- plugin?loadSettings () + + do init () + + do plugin?onload <- onload + +// DO NOT REMOVE +// Change the name here to match the type name used above +emitJsStatement "" "module.exports = SamplePlugin"; diff --git a/README.md b/README.md new file mode 100644 index 0000000..9eb20f7 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# Obsidian Sample Plugin F\# + +This is a recreation of the [official Obsidian sample plugin](https://github.com/obsidianmd/obsidian-sample-plugin) in F\# using Fable as a proof of concept. diff --git a/justfile b/justfile new file mode 100755 index 0000000..87d9e5c --- /dev/null +++ b/justfile @@ -0,0 +1,11 @@ +build: + dotnet fable --lang javascript --noCache + esbuild ./Program.fs.js --bundle --external:obsidian --outfile=./out/main.js --format=cjs + cp -a ./meta/. ./out/ + +clean: + rm -rf ./fable_modules/ ./bin/ ./obj/ ./out/ *.fs.js + + + + diff --git a/meta/manifest.json b/meta/manifest.json new file mode 100644 index 0000000..088bb4e --- /dev/null +++ b/meta/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-sample-plugin-fs", + "name": "FSharp Sample Plugin", + "version": "1.0.0", + "minAppVersion": "0.15.0", + "description": "Sample project to demonstrate how to use F# and Fable to create an Obsidian plugin.", + "author": "Aaron Manning", + "authorUrl": "https://aaronmanning.net", + "isDesktopOnly": false +} diff --git a/meta/versions.json b/meta/versions.json new file mode 100644 index 0000000..26382a1 --- /dev/null +++ b/meta/versions.json @@ -0,0 +1,3 @@ +{ + "1.0.0": "0.15.0" +} diff --git a/obsidian-sample-plugin-fs.fsproj b/obsidian-sample-plugin-fs.fsproj new file mode 100644 index 0000000..c3ac38d --- /dev/null +++ b/obsidian-sample-plugin-fs.fsproj @@ -0,0 +1,22 @@ + + + + Exe + net7.0 + obsidian_sample_plugin_fs + + + + + + + + + + + + + + + +