@lapis-notes/api 0.1.0

package/dist/enhance.d.ts

@@ -0,0 +1,111 @@
+interface DomElementInfo {
+    /**
+     * The class to be assigned. Can be a space-separated string or an array of
+     * strings.
+     */
+    cls?: string | string[];
+    /** The textContent to be assigned. */
+    text?: string | DocumentFragment;
+    /** HTML attributes to be added. */
+    attr?: {
+        [key: string]: string | number | boolean | null;
+    };
+    /** HTML title (for hover tooltip). */
+    title?: string;
+    /** The parent element to be assigned toptions. */
+    parent?: Node;
+    value?: string;
+    type?: string;
+    prepend?: boolean;
+    placeholder?: string;
+    href?: string;
+}
+interface SvgElementInfo {
+    /**
+     * The class to be assigned. Can be a space-separated string or an array of
+     * strings.
+     */
+    cls?: string | string[];
+    /** HTML attributes to be added. */
+    attr?: {
+        [key: string]: string | number | boolean | null;
+    };
+    /** The parent element to be assigned to. */
+    parent?: Node;
+    prepend?: boolean;
+}
+declare global {
+    interface Window {
+        /**
+         * The actively focused Window object. This is usually the same as `window`
+         * but it will be different when using popout windows.
+         */
+        activeWindow: Window;
+        /**
+         * The actively focused Document object. This is usually the same as
+         * `document` but it will be different when using popout windows.
+         */
+        activeDocument: Document;
+    }
+    interface Node {
+        detach(): void;
+        empty(): void;
+        insertAfter<T extends Node>(node: T, child: Node | null): T;
+        appendText(val: string): void;
+        createEl<K extends keyof HTMLElementTagNameMap>(tag: K, o?: DomElementInfo | string, callback?: (el: HTMLElementTagNameMap[K]) => void): HTMLElementTagNameMap[K];
+        createDiv(o?: DomElementInfo | string, callback?: (el: HTMLDivElement) => void): HTMLDivElement;
+        createSpan(o?: DomElementInfo | string, callback?: (el: HTMLSpanElement) => void): HTMLSpanElement;
+        createSvg<K extends keyof SVGElementTagNameMap>(tag: K, options?: SvgElementInfo | string, callback?: (el: SVGElementTagNameMap[K]) => void): SVGElementTagNameMap[K];
+        /** The document this node belongs to, or the global document. */
+        doc: Document;
+        /** The window object this node belongs to, or the global window. */
+        win: Window;
+        constructorWin: Window;
+    }
+    interface Element extends Node {
+        find(selector: string): Element | null;
+        findAll(selector: string): HTMLElement[];
+        findAllSelf(selector: string): HTMLElement[];
+        getText(): string;
+        setText(val: string | DocumentFragment): void;
+        addClass(...classes: string[]): void;
+        addClasses(classes: string[]): void;
+        removeClass(...classes: string[]): void;
+        removeClasses(classes: string[]): void;
+        toggleClass(classes: string | string[], value: boolean): void;
+        hasClass(cls: string): boolean;
+        setAttr(qualifiedName: string, value: string | number | boolean | null): void;
+        setAttrs(obj: {
+            [key: string]: string | number | boolean | null;
+        }): void;
+        getAttr(qualifiedName: string): string | null;
+        matchParent(selector: string, lastParent?: Element): Element | null;
+        getCssPropertyValue(property: string, pseudoElement?: string): string;
+        isActiveElement(): boolean;
+    }
+    interface EventListenerInfo {
+        selector: string;
+        listener: Function;
+        options?: boolean | AddEventListenerOptions;
+        callback: Function;
+    }
+    interface HTMLElement extends Element {
+        _EVENTS?: {
+            [K in keyof HTMLElementEventMap]?: EventListenerInfo[];
+        };
+        show(): void;
+        hide(): void;
+        toggle(show: boolean): void;
+        toggleVisibility(visible: boolean): void;
+        scrollOffsetTop(): number;
+        on<K extends keyof HTMLElementEventMap>(this: HTMLElement, type: K, selector: string, listener: (this: HTMLElement, ev: HTMLElementEventMap[K], delegateTarget: HTMLElement) => any, options?: boolean | AddEventListenerOptions): void;
+        off<K extends keyof HTMLElementEventMap>(this: HTMLElement, type: K, selector: string, listener: (this: HTMLElement, ev: HTMLElementEventMap[K], delegateTarget: HTMLElement) => any, options?: boolean | AddEventListenerOptions): void;
+        onClickEvent(this: HTMLElement, listener: (this: HTMLElement, ev: MouseEvent) => any, options?: boolean | AddEventListenerOptions): void;
+    }
+    function createEl<K extends keyof HTMLElementTagNameMap>(tag: K, options?: DomElementInfo | string, callback?: (el: HTMLElementTagNameMap[K]) => void): HTMLElementTagNameMap[K];
+    function createSpan(options?: DomElementInfo | string, callback?: (el: HTMLSpanElement) => void): HTMLSpanElement;
+    function createDiv(options?: DomElementInfo | string, callback?: (el: HTMLDivElement) => void): HTMLDivElement;
+    function createSvg<K extends keyof SVGElementTagNameMap>(tag: K, options?: SvgElementInfo | string, callback?: (el: SVGElementTagNameMap[K]) => void): SVGElementTagNameMap[K];
+    function createFragment(callback?: (el: DocumentFragment) => void): DocumentFragment;
+}
+export {};

package/dist/enhance.js

@@ -0,0 +1,309 @@
+// <TypeDefs />
+if (typeof Node !== "undefined" &&
+    typeof Element !== "undefined" &&
+    typeof HTMLElement !== "undefined" &&
+    typeof Window !== "undefined" &&
+    typeof document !== "undefined" &&
+    typeof window !== "undefined") {
+    Node.prototype.constructorWin = window;
+    Window.prototype.activeWindow = window;
+    Window.prototype.activeDocument = document;
+    Object.defineProperty(Node.prototype, "doc", {
+        get() {
+            return this.ownerDocument || document;
+        },
+        configurable: true,
+    });
+    Object.defineProperty(Node.prototype, "win", {
+        get() {
+            return this.doc.defaultView || window;
+        },
+        configurable: true,
+    });
+    Node.prototype.detach = function () {
+        this.parentNode && this.parentNode.removeChild(this);
+    };
+    Node.prototype.empty = function () {
+        for (; this.lastChild;) {
+            this.removeChild(this.lastChild);
+        }
+    };
+    Node.prototype.insertAfter = function (node, child) {
+        child
+            ? this.insertBefore(node, child.nextSibling)
+            : this.insertBefore(node, this.firstChild);
+        return node;
+    };
+    Node.prototype.appendText = function (val) {
+        this.appendChild(document.createTextNode(val));
+    };
+    Node.prototype.createEl = function (tag, o, callback) {
+        if (typeof o === "string") {
+            o = { cls: o };
+        }
+        (o = o || {}).parent = this;
+        return createEl(tag, o, callback);
+    };
+    Node.prototype.createSpan = function (o, callback) {
+        return this.createEl("span", o, callback);
+    };
+    Node.prototype.createDiv = function (o, callback) {
+        return this.createEl("div", o, callback);
+    };
+    Node.prototype.createDiv = function createDiv(o, callback) {
+        return this.createEl("div", o, callback);
+    };
+    Node.prototype.createSpan = function createSpan(o, callback) {
+        return this.createEl("span", o, callback);
+    };
+    Node.prototype.createSvg = function createSvg(tag, options, callback) {
+        if (typeof options === "string") {
+            options = { cls: options };
+        }
+        (options = options || {}).parent = this;
+        return createSvg(tag, options, callback);
+    };
+    function getText(node) {
+        var nodeType = node.nodeType;
+        if ([1, 9, 11].includes(nodeType)) {
+            if (typeof node.textContent == "string") {
+                return node.textContent;
+            }
+            for (var nodes = [], child = node.firstChild; child; child = child.nextSibling)
+                nodes.push(getText(child));
+            return nodes.join("");
+        }
+        return ([3, 4].includes(nodeType) && node.nodeValue) || "";
+    }
+    Element.prototype.find = function (selector) {
+        return this.querySelector(selector);
+    };
+    Element.prototype.findAll = function (selector) {
+        return Array.from(this.querySelectorAll(selector));
+    };
+    Element.prototype.findAllSelf = function (selector) {
+        return Array.from(this.querySelectorAll(selector));
+    };
+    Element.prototype.getText = function () {
+        return getText(this);
+    };
+    Element.prototype.setText = function (value) {
+        if (value instanceof DocumentFragment || value instanceof Node) {
+            this.empty();
+            this.appendChild(value);
+        }
+        else if (typeof value === "string" &&
+            [1, 9, 11].includes(this.nodeType)) {
+            this.textContent = value;
+        }
+    };
+    Element.prototype.addClass = function (...classes) {
+        this.addClasses(classes);
+    };
+    Element.prototype.addClasses = function (classes) {
+        if (classes) {
+            classes.forEach((it) => this.classList.add(it));
+        }
+    };
+    Element.prototype.removeClass = function (...classes) {
+        this.removeClasses(classes);
+    };
+    Element.prototype.removeClasses = function (classes) {
+        if (classes) {
+            classes.forEach((it) => this.classList.remove(it));
+        }
+    };
+    Element.prototype.toggleClass = function (classes, value) {
+        if (!Array.isArray(classes)) {
+            classes = [classes];
+        }
+        value ? this.addClasses(classes) : this.removeClasses(classes);
+    };
+    Element.prototype.hasClass = function (cls) {
+        return this.classList.contains(cls);
+    };
+    Element.prototype.getAttr = function (qualifiedName) {
+        return this.getAttribute(qualifiedName);
+    };
+    Element.prototype.setAttr = function (qualifiedName, value) {
+        value === null
+            ? this.removeAttribute(qualifiedName)
+            : this.setAttribute(qualifiedName, String(value));
+    };
+    Element.prototype.setAttrs = function (obj) {
+        for (const [key, value] of Object.entries(obj)) {
+            this.setAttr(key, value);
+        }
+    };
+    Element.prototype.getCssPropertyValue = function (property, pseudoElement) {
+        return getComputedStyle(this, pseudoElement)
+            .getPropertyValue(property)
+            .trim();
+    };
+    Element.prototype.matchParent = function (selector, lastParent) {
+        if (this.matches(selector)) {
+            return this;
+        }
+        if (this === lastParent) {
+            return null;
+        }
+        const p = this.parentElement;
+        return p ? p.matchParent(selector, lastParent) : null;
+    };
+    Element.prototype.isActiveElement = function () {
+        return false;
+    };
+    HTMLElement.prototype.scrollOffsetTop = function () {
+        let currenttop = 0;
+        let el = this;
+        if (el.offsetParent) {
+            do {
+                currenttop += el.offsetTop;
+            } while ((el = el.offsetParent));
+            return currenttop;
+        }
+        return currenttop;
+    };
+    HTMLElement.prototype.on = function (type, selector, listener, options) {
+        const delegateTarget = this;
+        const callback = (event) => {
+            const target = event.target;
+            if (target && target.matches(selector)) {
+                listener.bind(delegateTarget)(event, delegateTarget);
+            }
+        };
+        this.addEventListener(type, callback, options);
+        const info = { selector, listener, options, callback };
+        this._EVENTS ||= {};
+        this._EVENTS[type] ||= [];
+        this._EVENTS[type].push(info);
+    };
+    HTMLElement.prototype.off = function (type, selector, listener, options) {
+        this._EVENTS ||= {};
+        this._EVENTS[type] ||= [];
+        const events = this._EVENTS[type].filter((it) => it.selector === selector && it.listener === listener);
+        events.forEach((evt) => {
+            this.removeEventListener(type, evt.listener, evt.options);
+        });
+        this._EVENTS[type] = this._EVENTS[type].filter((it) => !(it.selector === selector && it.listener === listener));
+    };
+    HTMLElement.prototype.onClickEvent = function (listener, options) {
+        this.addEventListener("click", listener, options);
+        this.addEventListener("auxclick", listener, options);
+    };
+    HTMLElement.prototype.show = function () {
+        if (this.style.display === "none") {
+            this.style.display = this.getAttribute("data-display") || "";
+            this.removeAttribute("data-display");
+        }
+    };
+    HTMLElement.prototype.hide = function () {
+        const display = this.style.display;
+        if (display !== "none") {
+            this.style.display = "none";
+            display
+                ? this.setAttribute("data-display", display)
+                : this.removeAttribute("data-display");
+        }
+    };
+    HTMLElement.prototype.toggle = function (show) {
+        show ? this.show() : this.hide();
+    };
+    HTMLElement.prototype.toggleVisibility = function (visible) {
+        this.style.visibility = visible ? "" : "hidden";
+    };
+    globalThis.createFragment = function (callback) {
+        const fragment = document.createDocumentFragment();
+        callback?.(fragment);
+        return fragment;
+    };
+    globalThis.createEl = function (tag, options, callback) {
+        const el = document.createElement(tag);
+        if (typeof options === "string") {
+            el.classList.add(...options.split(" ").filter((it) => it));
+        }
+        else if (options) {
+            if (options.cls) {
+                if (typeof options.cls === "string") {
+                    el.classList.add(...options.cls.split(" ").filter((it) => it));
+                }
+                else {
+                    el.classList.add(...options.cls);
+                }
+            }
+            if (options.title) {
+                el.title = options.title;
+            }
+            if (options.parent) {
+                options.prepend
+                    ? options.parent.insertBefore(el, options.parent.firstChild)
+                    : options.parent.appendChild(el);
+            }
+            if (options.value !== undefined) {
+                if (el instanceof HTMLInputElement ||
+                    el instanceof HTMLSelectElement ||
+                    el instanceof HTMLOptionElement) {
+                    el.value = options.value;
+                }
+            }
+            if (options.type) {
+                if (el instanceof HTMLInputElement) {
+                    el.type = options.type;
+                }
+                else if (el instanceof HTMLStyleElement) {
+                    el.setAttribute("type", options.type);
+                }
+            }
+            if (options.href !== undefined) {
+                if (el instanceof HTMLAnchorElement ||
+                    el instanceof HTMLLinkElement ||
+                    el instanceof HTMLBaseElement) {
+                    el.href = options.href;
+                }
+            }
+            if (options.text !== undefined) {
+                el.setText(options.text);
+            }
+            if (options.attr) {
+                el.setAttrs(options.attr);
+            }
+        }
+        callback?.(el);
+        return el;
+    };
+    globalThis.createSpan = function (options, callback) {
+        return createEl("span", options, callback);
+    };
+    globalThis.createDiv = function (options, callback) {
+        return createEl("div", options, callback);
+    };
+    globalThis.createSvg = function (tag, options, callback) {
+        const el = document.createElementNS("http://www.w3.org/2000/svg", tag);
+        if (typeof options === "string") {
+            el.classList.add(...options.split(" ").filter((it) => it));
+        }
+        else if (options) {
+            if (options.cls) {
+                if (typeof options.cls === "string") {
+                    el.classList.add(...options.cls.split(" ").filter((it) => it));
+                }
+                else {
+                    el.classList.add(...options.cls);
+                }
+            }
+            if (options.attr) {
+                for (const [key, value] of Object.entries(options.attr)) {
+                    el.setAttribute(key, value?.toString() ?? "");
+                }
+            }
+            if (options.parent) {
+                options.prepend
+                    ? options.parent.insertBefore(el, options.parent.firstChild)
+                    : options.parent.appendChild(el);
+            }
+        }
+        callback?.(el);
+        return el;
+    };
+}
+export {};

package/dist/events.d.ts

@@ -0,0 +1,28 @@
+export type ValidEventTypes = string | symbol | object;
+export type DefaultEventMap = Record<string, any[]>;
+export type EventMap<T = any> = Record<string, any>;
+export type EventNames<T extends ValidEventTypes> = T extends string | symbol ? T : keyof T;
+export type ArgumentMap<T extends object> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => void ? Parameters<T[K]> : T[K] extends any[] ? T[K] : any[];
+};
+export type EventListener<T extends ValidEventTypes, K extends EventNames<T>> = T extends string | symbol ? (...args: any[]) => void : (...args: ArgumentMap<Exclude<T, string | symbol>>[Extract<K, keyof T>]) => void;
+export type EventArgs<T extends ValidEventTypes, K extends EventNames<T>> = Parameters<EventListener<T, K>>;
+export type EventRef<T extends ValidEventTypes, K extends EventNames<T>, Context = any> = {
+    eventName: K;
+    callback: EventListener<T, K>;
+    dispatcher: EventDispatcher<T>;
+    context?: Context;
+};
+export declare class EventDispatcher<EventTypes extends ValidEventTypes = string | symbol, Context = any> {
+    private emitter;
+    on<T extends EventNames<EventTypes>>(eventName: T, listener: EventListener<EventTypes, T>, context?: Context): EventRef<EventTypes, T, Context>;
+    once<T extends EventNames<EventTypes>>(eventName: T, listener: EventListener<EventTypes, T>, context?: Context): EventRef<EventTypes, T, Context>;
+    off<T extends EventNames<EventTypes>>(eventName: T, listener: EventListener<EventTypes, T>, context?: Context, once?: boolean): void;
+    offref<T extends EventNames<EventTypes>>(ref: EventRef<EventTypes, T>): void;
+    trigger<T extends EventNames<EventTypes>>(eventName: T, ...args: EventArgs<EventTypes, T>): boolean;
+    emit<T extends EventNames<EventTypes>>(eventName: T, ...args: EventArgs<EventTypes, T>): boolean;
+    dispatch<T extends EventNames<EventTypes>>(eventName: T, ...args: EventArgs<EventTypes, T>): boolean;
+    tryTrigger<T extends EventNames<EventTypes>>(evt: EventRef<EventTypes, T>, ...args: EventArgs<EventTypes, T>): void;
+}
+export declare class Events<EventTypes extends ValidEventTypes = DefaultEventMap, Context = any> extends EventDispatcher<EventTypes, Context> {
+}

package/dist/events.js

@@ -0,0 +1,49 @@
+import { EventEmitter } from "eventemitter3";
+export class EventDispatcher {
+    emitter = new EventEmitter();
+    on(eventName, listener, context) {
+        this.emitter.on(eventName, listener, context);
+        const event = {
+            eventName,
+            callback: listener,
+            dispatcher: this,
+            context,
+        };
+        return event;
+    }
+    once(eventName, listener, context) {
+        this.emitter.once(eventName, listener, context);
+        const event = {
+            eventName,
+            callback: listener,
+            dispatcher: this,
+            context,
+        };
+        return event;
+    }
+    off(eventName, listener, context, once) {
+        this.emitter.off(eventName, listener, context, once);
+    }
+    offref(ref) {
+        this.emitter.off(ref.eventName, ref.callback);
+    }
+    trigger(eventName, ...args) {
+        return this.emitter.emit(eventName, ...args);
+    }
+    emit(eventName, ...args) {
+        return this.emitter.emit(eventName, ...args);
+    }
+    dispatch(eventName, ...args) {
+        return this.emitter.emit(eventName, ...args);
+    }
+    tryTrigger(evt, ...args) {
+        try {
+            this.trigger(evt.eventName, ...args);
+        }
+        catch (e) {
+            console.warn(`Error triggerring event: ${String(evt.eventName)}`, e);
+        }
+    }
+}
+export class Events extends EventDispatcher {
+}

package/dist/file-manager.d.ts

@@ -0,0 +1,90 @@
+import type { App } from "./context.svelte";
+import { TFile } from "./storage/fs";
+import type { DataWriteOptions, TAbstractFile, TFolder } from "./storage/fs";
+/**
+ * High-level helpers for vault file operations that need metadata-aware
+ * follow-up work.
+ *
+ * @public
+ */
+export declare class FileManager {
+    readonly app: App;
+    constructor(app: App);
+    private cloneFrontmatter;
+    private readFrontmatterSeed;
+    private isFrontmatterEqual;
+    private writeUpdatedFrontmatter;
+    private getLinkSettings;
+    private buildVaultIndex;
+    private getReplacementLink;
+    private extractAlias;
+    private collectRenameEdits;
+    /**
+     * Gets the folder that new files should be saved to, given the user's
+     * preferences.
+     *
+     * @param sourcePath - The path to the current open/focused file, used when
+     *   the user wants new files to be created 'in the same folder'. Use an empty
+     *   string if there is no active file.
+     * @param newFilePath - The path to the file that will be newly created, used
+     *   to infer what settings to use based on the path's extension.
+     * @public
+     */
+    getNewFileParent(sourcePath: string, newFilePath?: string): TFolder;
+    getAvailablePathForAttachment(filename: string, sourcePath?: string): string;
+    /**
+     * Rename or move a file safely, and update all links to it depending on the
+     * user's preferences.
+     *
+     * @param file - The file to rename
+     * @param newPath - The new path for the file
+     * @public
+     */
+    renameFile(file: TAbstractFile, newPath: string): Promise<void>;
+    /**
+     * Remove a file or a folder from the vault according the user's preferred
+     * 'trash' options (either moving the file to .trash/ or the OS trash bin).
+     *
+     * @param file
+     * @public
+     */
+    trashFile(file: TAbstractFile): Promise<void>;
+    promptForDeletion(file: TAbstractFile): Promise<void>;
+    /**
+     * Generate a Markdown link based on the user's preferences.
+     *
+     * @param file - The file to link to.
+     * @param sourcePath - Where the link is stored in, used to compute relative
+     *   links.
+     * @param subpath - A subpath, starting with `#`, used for linking to headings
+     *   or blocks.
+     * @param alias - The display text if it's to be different than the file name.
+     *   Pass empty string to use file name.
+     * @public
+     */
+    generateMarkdownLink(file: TFile, sourcePath: string, subpath?: string, alias?: string): string;
+    /**
+     * Atomically read, modify, and save the frontmatter of a note. The
+     * frontmatter is passed in as a JS object, and should be mutated directly to
+     * achieve the desired result.
+     *
+     * Remember to handle errors thrown by this method.
+     *
+     * @example
+     *   ```ts
+     *   app.fileManager.processFrontMatter(file, (frontmatter) => {
+     *       frontmatter['key1'] = value;
+     *       delete frontmatter['key2'];
+     *   });
+     *   ```;
+     *
+     * @param file - The file to be modified. Must be a Markdown file.
+     * @param fn - A callback function which mutates the frontmatter object
+     *   synchronously.
+     * @param options - Write options.
+     * @throws YAMLParseError if the YAML parsing fails
+     * @throws Any errors that your callback function throws
+     * @public
+     */
+    processFrontMatter(file: TFile, fn: (frontmatter: any) => void, options?: DataWriteOptions): Promise<void>;
+}