@lapis-notes/api 0.1.0

package/dist/logging.js

@@ -0,0 +1,352 @@
+import { EventDispatcher } from "./events";
+import { Plugin } from "./plugin";
+import { DateTime } from "luxon";
+/**
+ * Logger class to handle consistency of logs across the plugin.
+ *
+ * @class LogManager
+ * @extends {EventDispatcher}
+ */
+export class LogManager extends EventDispatcher {
+    options = {
+        minLevels: {
+            "": "info",
+            cache: "debug",
+            app: "info",
+            notebook: "debug",
+        },
+    };
+    // Prevent the console logger from being added twice
+    consoleLoggerRegistered = false;
+    /**
+     * Set the minimum log levels for the module name or global.
+     *
+     * @param {LogOptions} options
+     * @returns {any} {LogManager}
+     */
+    configure(options) {
+        this.options = Object.assign({}, this.options, options);
+        return this;
+    }
+    setLevel(module, level) {
+        this.options.minLevels[module] = level;
+    }
+    /**
+     * Returns a logger instance for the given module name.
+     *
+     * @param {string} module
+     * @returns {any} {Logger}
+     */
+    getLogger(module) {
+        return new Logger(this, module, () => {
+            let minLevel = "none";
+            let match = "";
+            for (const key in this.options.minLevels) {
+                if (module.startsWith(key) && key.length >= match.length) {
+                    minLevel = this.options.minLevels[key];
+                    match = key;
+                }
+            }
+            return minLevel;
+        });
+    }
+    /**
+     *
+     *
+     * @param {(logEntry: LogEntry) => void} listener
+     * @returns {any} {LogManager}
+     */
+    onLogEntry(listener) {
+        this.on("log", listener);
+        return this;
+    }
+    arrAvg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+    /**
+     * Registers a logger that write to the console.
+     *
+     * @returns {any} {LogManager}
+     */
+    registerConsoleLogger(props = { color: true }) {
+        if (this.consoleLoggerRegistered)
+            return this;
+        this.onLogEntry((logEntry) => {
+            let msg = `[${DateTime.now().toISO()}][${logEntry.level}][${logEntry.module}]`;
+            if (logEntry.traceId) {
+                msg += `[${logEntry.traceId}]`;
+            }
+            msg += ` ${logEntry.message}`;
+            if (logEntry.objects === undefined) {
+                logEntry.objects = "";
+            }
+            const args = [msg];
+            if (props.color) {
+                args[0] = "%c" + msg;
+                const colors = {
+                    trace: "color: #9c27b0; font-weight: italic",
+                    debug: "color: #666666; font-style: italic",
+                    info: "color: green;",
+                    warn: "color: #ffc107; font-weight: bold",
+                    error: "color: #e74c3c; font-weight: bold",
+                };
+                args.push(colors[logEntry.level]);
+            }
+            args.push(logEntry.objects);
+            switch (logEntry.level) {
+                case "trace":
+                    console.trace(...args);
+                    break;
+                case "debug":
+                    console.debug(...args);
+                    break;
+                case "info":
+                    console.info(...args);
+                    break;
+                case "warn":
+                    console.warn(...args);
+                    break;
+                case "error":
+                    console.error(...args);
+                    break;
+                default:
+                    console.log(`{${logEntry.level}}`, ...args);
+            }
+        });
+        this.consoleLoggerRegistered = true;
+        return this;
+    }
+}
+export const logging = new LogManager();
+/**
+ * Main logging library, to view the logs a logger listener must be added. The
+ * Console Logger is already implemented for this project.
+ *
+ * @class Logger
+ */
+export class Logger {
+    getLevel;
+    logManager;
+    module;
+    levels = {
+        trace: 1,
+        debug: 2,
+        info: 3,
+        warn: 4,
+        error: 5,
+    };
+    /**
+     * Creates an instance of Logger.
+     *
+     * @param {EventEmitter2} logManager
+     * @param {string} module
+     * @param {string} minLevel
+     */
+    constructor(logManager, module, getLevel) {
+        this.getLevel = getLevel;
+        this.logManager = logManager;
+        this.module = module;
+    }
+    get minLevel() {
+        return this.levelToInt(this.getLevel());
+    }
+    /**
+     * Converts a string level (trace/debug/info/warn/error) into a number
+     *
+     * @param minLevel
+     */
+    levelToInt(minLevel) {
+        if (minLevel.toLowerCase() in this.levels)
+            return this.levels[minLevel.toLowerCase()];
+        else
+            return 99;
+    }
+    /**
+     * Central logging method.
+     *
+     * @param logLevel
+     * @param message
+     */
+    log(logLevel, message, objects) {
+        const level = this.levelToInt(logLevel);
+        if (level < this.minLevel)
+            return;
+        const logEntry = {
+            level: logLevel,
+            module: this.module,
+            message,
+            objects,
+            traceId: undefined,
+        };
+        // Obtain the line/file through a thoroughly hacky method
+        // This creates a new stack trace and pulls the caller from it.  If the caller
+        // if .trace()
+        // const error = new Error('');
+        // if (error.stack) {
+        //     const cla = error.stack.split('\n');
+        //     let idx = 1;
+        //     while (idx < cla.length && cla[idx].includes('at Logger.Object.')) idx++;
+        //     if (idx < cla.length) {
+        //         logEntry.location = cla[idx].slice(cla[idx].indexOf('at ') + 3, cla[idx].length);
+        //     }
+        // }
+        this.logManager.emit("log", logEntry);
+    }
+    trace(message, objects) {
+        this.log("trace", message, objects);
+    }
+    debug(message, objects) {
+        this.log("debug", message, objects);
+    }
+    info(message, objects) {
+        this.log("info", message, objects);
+    }
+    warn(message, objects) {
+        this.log("warn", message, objects);
+    }
+    error(message, objects) {
+        this.log("error", message, objects);
+    }
+    /**
+     * Central logging method with a trace ID to track calls between
+     * modules/components.
+     *
+     * @param logLevel
+     * @param message
+     */
+    logWithId(logLevel, traceId, message, objects) {
+        const level = this.levelToInt(logLevel);
+        if (level < this.minLevel)
+            return;
+        const logEntry = {
+            level: logLevel,
+            module: this.module,
+            message,
+            objects,
+            traceId,
+        };
+        this.logManager.emit("log", logEntry);
+    }
+    traceWithId(traceId, message, objects) {
+        this.logWithId("trace", traceId, message, objects);
+    }
+    debugWithId(traceId, message, objects) {
+        this.logWithId("debug", traceId, message, objects);
+    }
+    infoWithId(traceId, message, objects) {
+        this.logWithId("info", traceId, message, objects);
+    }
+    warnWithId(traceId, message, objects) {
+        this.logWithId("warn", traceId, message, objects);
+    }
+    errorWithId(traceId, message, objects) {
+        this.logWithId("error", traceId, message, objects);
+    }
+}
+// Comment from the original author:
+// I was calculating metrics on call times to debug some performance issues.
+// This is a simple JS hashmap where the id could be one of the 4 items.
+// (see the comment-out code in logCall below...)
+const timingMap = {};
+/**
+ * This deceleration will log the time taken to run the function it is attached
+ * to. Be careful where it is added as it increases the output.
+ *
+ * @returns {any}
+ */
+export const logCall = (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    //const logger = logging.getLogger('taskssql.perf');
+    descriptor.value = function (...args) {
+        const startTime = new Date(Date.now());
+        const result = originalMethod.apply(this, args);
+        const endTime = new Date(Date.now());
+        const name = `${target?.constructor?.name}${propertyKey}`;
+        const time = endTime.getTime() - startTime.getTime();
+        if (timingMap[name] === undefined) {
+            timingMap[name] = [];
+        }
+        timingMap[name].push(time);
+        //console.log(timingMap);
+        // if (endTime.getTime() - startTime.getTime() > 50) {
+        //     console.debug(
+        //         `[debug][taskssql.perf] ${String(timingMap[name].avg).padEnd(4)}${String(
+        //             endTime.getTime() - startTime.getTime(),
+        //         ).padEnd(4)} ${target?.constructor?.name.padEnd(10)}${propertyKey.padEnd(20)}`,
+        //     );
+        //     // logger.debug(
+        //     //     `${target?.constructor?.name}:${propertyKey}:called with ${args.length} arguments. Took: ${
+        //     //         endTime.getTime() - startTime.getTime()
+        //     //     }ms`,
+        //     // );
+        // }
+        return result;
+    };
+    return descriptor;
+};
+export function logCallDetails() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const logger = logging.getLogger("tasks");
+        descriptor.value = async function (...args) {
+            const startTime = new Date(Date.now());
+            const result = await originalMethod.apply(this, args);
+            const endTime = new Date(Date.now());
+            const elapsed = endTime.getTime() - startTime.getTime();
+            logger.debug(`${typeof target}:${propertyKey} called with ${args.length} arguments. Took: ${elapsed}ms ${JSON.stringify(args)}`);
+            return result;
+        };
+        return descriptor;
+    };
+}
+/**
+ * Provides a simple log function that can be used to log messages against
+ * default module.
+ *
+ * @param {TLogLevelName} logLevel
+ * @param {string} message
+ */
+export function log(logLevel, message) {
+    const logger = logging.getLogger("tasks");
+    switch (logLevel) {
+        case "trace":
+            logger.trace(message);
+            break;
+        case "debug":
+            logger.debug(message);
+            break;
+        case "info":
+            logger.info(message);
+            break;
+        case "warn":
+            logger.warn(message);
+            break;
+        case "error":
+            logger.error(message);
+            break;
+        default:
+            break;
+    }
+}
+/**
+ * This allows the plugin to be debugged in a mobile application add it when
+ * debugging on a device. Not meant to be used by end users. Add it into main.ts
+ * and remove before you commit.
+ *
+ * @param {Plugin} plugin
+ * @returns {any}
+ */
+export function monkeyPatchConsole(plugin) {
+    const logFile = `${plugin.manifest.dir}/tasks-logs.txt`;
+    const logs = [];
+    const logMessages = (prefix) => (...messages) => {
+        logs.push(`\n[${prefix}]`);
+        for (const message of messages) {
+            logs.push(String(message));
+        }
+        plugin.app.vault.adapter.write(logFile, logs.join(" "));
+    };
+    console.debug = logMessages("debug");
+    console.error = logMessages("error");
+    console.info = logMessages("info");
+    console.log = logMessages("log");
+    console.warn = logMessages("warn");
+}

package/dist/markdown-extension-registry.d.ts

@@ -0,0 +1,31 @@
+import type { Extension } from "@codemirror/state";
+import type { App } from "./context.svelte";
+import type { MarkdownPostProcessor } from "./markdown";
+/** Identifies the Markdown host that is rendering or editing a document. */
+export interface MarkdownSurfaceContext {
+    /** Stable surface identifier such as `workspace` or `tasks-list`. */
+    id: string;
+    /** Optional opaque context owned by the surface consumer. */
+    context?: unknown;
+}
+export type MarkdownContributionMode = "source" | "live-preview" | "reading" | "embed";
+export interface MarkdownCodeMirrorExtensionContext {
+    app: App;
+    mode: "source" | "live-preview";
+    sourcePath: string;
+    surface: MarkdownSurfaceContext;
+}
+/** A plugin-owned Markdown contribution adapted by the bundled Markdown plugin. */
+export interface MarkdownExtensionContribution {
+    id: string;
+    codeMirror?: (context: MarkdownCodeMirrorExtensionContext) => Extension | readonly Extension[] | null | undefined;
+    postProcessor?: MarkdownPostProcessor;
+}
+export interface RegisteredMarkdownExtensionContribution extends MarkdownExtensionContribution {
+    pluginId: string;
+}
+export declare class MarkdownExtensionRegistry {
+    private readonly contributions;
+    register(pluginId: string, contribution: MarkdownExtensionContribution): () => void;
+    getAll(): RegisteredMarkdownExtensionContribution[];
+}

package/dist/markdown-extension-registry.js

@@ -0,0 +1,31 @@
+function contributionKey(pluginId, contributionId) {
+    return `${pluginId}:${contributionId}`;
+}
+export class MarkdownExtensionRegistry {
+    contributions = new Map();
+    register(pluginId, contribution) {
+        const normalizedPluginId = pluginId.trim();
+        const normalizedId = contribution.id.trim();
+        if (!normalizedPluginId || !normalizedId) {
+            throw new Error("Markdown contributions require plugin and contribution ids.");
+        }
+        const key = contributionKey(normalizedPluginId, normalizedId);
+        if (this.contributions.has(key)) {
+            throw new Error(`Markdown contribution ${key} is already registered.`);
+        }
+        const registered = {
+            ...contribution,
+            id: normalizedId,
+            pluginId: normalizedPluginId,
+        };
+        this.contributions.set(key, registered);
+        return () => {
+            if (this.contributions.get(key) === registered) {
+                this.contributions.delete(key);
+            }
+        };
+    }
+    getAll() {
+        return [...this.contributions.values()];
+    }
+}

package/dist/markdown-file-surface-registry.d.ts

@@ -0,0 +1,25 @@
+import type { TFile } from "./storage/fs";
+import type { MarkdownSurfaceContext } from "./markdown-extension-registry";
+export type MarkdownFileSurfaceActivation = "manual" | "click" | "double-click";
+export interface MarkdownFileSurfaceOptions {
+    containerEl: HTMLElement;
+    file: TFile;
+    editable?: boolean;
+    activation?: MarkdownFileSurfaceActivation;
+    returnToPreviewOnBlur?: boolean;
+    surface: MarkdownSurfaceContext;
+    onEditingChange?: (editing: boolean) => void;
+}
+export interface MarkdownFileSurfaceHandle {
+    enter(): void | Promise<void>;
+    flush(): Promise<boolean>;
+    exit(): Promise<boolean>;
+    dispose(): void | Promise<void>;
+}
+export type MarkdownFileSurfaceProvider = (options: MarkdownFileSurfaceOptions) => MarkdownFileSurfaceHandle | Promise<MarkdownFileSurfaceHandle>;
+export declare class MarkdownFileSurfaceRegistry {
+    private providers;
+    register(pluginId: string, provider: MarkdownFileSurfaceProvider): () => void;
+    get available(): boolean;
+    mount(options: MarkdownFileSurfaceOptions): MarkdownFileSurfaceHandle | Promise<MarkdownFileSurfaceHandle>;
+}

package/dist/markdown-file-surface-registry.js

@@ -0,0 +1,23 @@
+export class MarkdownFileSurfaceRegistry {
+    providers = [];
+    register(pluginId, provider) {
+        const registered = { pluginId: pluginId.trim(), provider };
+        if (!registered.pluginId) {
+            throw new Error("Markdown file surface providers require a plugin id.");
+        }
+        this.providers = [...this.providers, registered];
+        return () => {
+            this.providers = this.providers.filter((entry) => entry !== registered);
+        };
+    }
+    get available() {
+        return this.providers.length > 0;
+    }
+    mount(options) {
+        const provider = this.providers.at(-1)?.provider;
+        if (!provider) {
+            throw new Error("No Markdown file surface provider is registered.");
+        }
+        return provider(options);
+    }
+}

package/dist/markdown.d.ts

@@ -0,0 +1,205 @@
+import type { App } from "./context.svelte";
+import type { Editor, MarkdownFileInfo } from "./editor.svelte";
+import { Component, FileView, TextFileView } from "./view.svelte";
+import type { Menu } from "./menu.svelte";
+import type { TFile } from "./storage/fs";
+import type { WorkspaceLeaf } from "./workspace.svelte";
+import { HoverPopover, type HoverParent } from "./popover";
+import type { Component as SvelteComponent } from "svelte";
+import type { MarkdownContributionMode, MarkdownSurfaceContext } from "./markdown-extension-registry";
+export declare class MarkdownRenderChild extends Component {
+    /**
+     * @param containerEl - This HTMLElement will be used to test whether this
+     *   component is still alive. It should be a child of the Markdown preview
+     *   sections, and when it's no longer attached (for example, when it is
+     *   replaced with a new version because the user edited the Markdown source
+     *   code), this component will be unloaded.
+     * @public
+     */
+    constructor(containerEl: HTMLElement);
+}
+export interface MarkdownSectionInformation {
+    /** @public */
+    text: string;
+    /** @public */
+    lineStart: number;
+    /** @public */
+    lineEnd: number;
+}
+/**
+ * A post processor receives an element which is a section of the preview.
+ *
+ * Post processors can mutate the DOM to render various things, such as mermaid
+ * graphs, latex equations, or custom controls.
+ *
+ * If your post processor requires lifecycle management, for example, to clear
+ * an interval, kill a subprocess, etc when this element is removed from the
+ * app, look into {@link MarkdownPostProcessorContext.addChild}
+ *
+ * @public
+ */
+export interface MarkdownPostProcessor {
+    /**
+     * The processor function itself.
+     *
+     * @public
+     */
+    (el: HTMLElement, ctx: MarkdownPostProcessorContext): Promise<any> | void;
+    /**
+     * An optional integer sort order. Defaults to 0. Lower number runs before
+     * higher numbers.
+     *
+     * @public
+     */
+    sortOrder?: number;
+}
+export interface MarkdownPostProcessorContext {
+    /** @public */
+    docId: string;
+    /**
+     * The path to the associated file. Any links are assumed to be relative to
+     * the `sourcePath`.
+     *
+     * @public
+     */
+    sourcePath: string;
+    /** @public */
+    frontmatter: any | null | undefined;
+    /** Rendering mode for this processor invocation. @public */
+    mode?: MarkdownContributionMode;
+    /** Owning Markdown surface and optional consumer context. @public */
+    surface?: MarkdownSurfaceContext;
+    /**
+     * Adds a child component that will have its lifecycle managed by the
+     * renderer.
+     *
+     * Use this to add a dependent child to the renderer such that if the
+     * containerEl of the child is ever removed, the component's unload will be
+     * called.
+     *
+     * @public
+     */
+    addChild(child: MarkdownRenderChild): void;
+    /**
+     * Gets the section information of this element at this point in time. Only
+     * call this function right before you need this information to get the most
+     * up-to-date version. This function may also return null in many
+     * circumstances; if you use it, you must be prepared to deal with nulls.
+     *
+     * @public
+     */
+    getSectionInfo(el: HTMLElement): MarkdownSectionInformation | null;
+}
+export interface MarkdownViewMenuContext {
+    menu: Menu;
+    source: "more-options" | "tab-header" | string;
+    leaf: WorkspaceLeaf;
+    file: TFile;
+}
+export type MarkdownDirectiveRenderer = SvelteComponent<any, any, any>;
+export type MarkdownViewMenuItemProvider = (context: MarkdownViewMenuContext) => void;
+export interface MarkdownSubView {
+    getScroll(): number;
+    applyScroll(scroll: number): void;
+    get(): string;
+    set(data: string, clear: boolean): void;
+}
+export interface MarkdownPreviewEvents extends Component {
+}
+export type MarkdownViewModeType = "source" | "preview" | "live-preview";
+/**
+ * A file-backed view that Markdown editing can return to without owning that
+ * view's rendering policy.
+ *
+ * @public
+ */
+export interface MarkdownViewReturnTarget {
+    /** Registered workspace view type to restore. @public */
+    type: string;
+    /** Human-readable destination used by the Markdown title action. @public */
+    label: string;
+    /** Optional icon for the return action. Defaults to `book-open`. @public */
+    icon?: string;
+    /** State supplied to the restored view. The current file is preserved. @public */
+    state?: Record<string, unknown>;
+}
+/**
+ * Public serialized state accepted by the bundled Markdown view.
+ *
+ * @public
+ */
+export interface MarkdownViewState {
+    file?: string | null;
+    mode?: MarkdownViewModeType;
+    returnTarget?: MarkdownViewReturnTarget;
+}
+export interface LivePreviewStateType {
+    editor: Editor;
+}
+export declare const livePreviewState: any;
+export declare abstract class EditableFileView extends FileView {
+}
+export declare abstract class MarkdownView extends TextFileView {
+    hoverPopover: HoverPopover | null;
+    previewMode: MarkdownPreviewView;
+    currentMode: MarkdownSubView;
+    constructor(leaf?: WorkspaceLeaf);
+}
+export declare class MarkdownPreviewRenderer {
+    static registerPostProcessor(postProcessor: MarkdownPostProcessor, sortOrder?: number): void;
+    static unregisterPostProcessor(postProcessor: MarkdownPostProcessor): void;
+    static createCodeBlockPostProcessor(language: string, handler: (source: string, el: HTMLElement, ctx: MarkdownPostProcessorContext) => Promise<any> | void): (el: HTMLElement, ctx: MarkdownPostProcessorContext) => void;
+}
+export declare abstract class MarkdownRenderer extends MarkdownRenderChild implements MarkdownPreviewEvents, HoverParent {
+    app: App;
+    hoverPopover: HoverPopover | null;
+    constructor(containerEl?: HTMLElement, application?: App);
+    abstract get file(): TFile | null;
+    /**
+     * Renders Markdown string to an HTML element.
+     *
+     * @deprecated - Use {@link MarkdownRenderer.render}
+     * @public
+     */
+    static renderMarkdown(markdown: string, el: HTMLElement, sourcePath: string, component: Component): Promise<void>;
+    /**
+     * Renders Markdown string to an HTML element.
+     *
+     * @param app - A reference to the app object
+     * @param markdown - The Markdown source code
+     * @param el - The element to append to
+     * @param sourcePath - The normalized path of this Markdown file, used to
+     *   resolve relative internal links
+     * @param component - A parent component to manage the lifecycle of the
+     *   rendered child components.
+     * @public
+     */
+    static render(app: App, markdown: string, el: HTMLElement, sourcePath: string, component: Component): Promise<void>;
+}
+export declare class MarkdownPreviewView extends MarkdownRenderer implements MarkdownSubView, MarkdownPreviewEvents {
+    readonly view?: MarkdownView | undefined;
+    private data;
+    private scroll;
+    constructor(view?: MarkdownView | undefined);
+    get file(): TFile | null;
+    get(): string;
+    set(data: string, clear: boolean): void;
+    clear(): void;
+    rerender(full?: boolean): void;
+    getScroll(): number;
+    applyScroll(scroll: number): void;
+}
+export declare class MarkdownEditView implements MarkdownSubView, HoverParent, MarkdownFileInfo {
+    readonly view: MarkdownView;
+    app: App;
+    hoverPopover: HoverPopover | null;
+    constructor(view: MarkdownView);
+    clear(): void;
+    get(): string;
+    set(data: string, clear: boolean): void;
+    get file(): TFile | null;
+    get editor(): Editor;
+    getSelection(): string;
+    getScroll(): number;
+    applyScroll(scroll: number): void;
+}