@lapis-notes/api 0.1.0

package/dist/markdown.js

@@ -0,0 +1,147 @@
+import { resolveApplication } from "./application-compatibility";
+import { Component, FileView, TextFileView } from "./view.svelte";
+import { HoverPopover } from "./popover";
+function createFallbackElement() {
+    if (typeof document !== "undefined") {
+        return document.createElement("div");
+    }
+    return {};
+}
+export 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) {
+        super();
+        this.containerEl = containerEl;
+    }
+}
+export const livePreviewState = null;
+export class EditableFileView extends FileView {
+}
+export class MarkdownView extends TextFileView {
+    hoverPopover = null;
+    previewMode;
+    currentMode;
+    constructor(leaf) {
+        super(leaf);
+    }
+}
+export class MarkdownPreviewRenderer {
+    static registerPostProcessor(postProcessor, sortOrder) {
+        postProcessor.sortOrder = sortOrder ?? postProcessor.sortOrder ?? 0;
+        resolveApplication().registerMarkdownPostProcessor(postProcessor);
+    }
+    static unregisterPostProcessor(postProcessor) {
+        resolveApplication().unregisterMarkdownPostProcessor(postProcessor);
+    }
+    static createCodeBlockPostProcessor(language, handler) {
+        return (el, ctx) => {
+            const source = ctx.getSectionInfo(el)?.text ?? "";
+            handler(source.replace(/^([`]{3}[^\n]*\n+)|\n+[`]{3}\n*$/g, ""), el, ctx);
+        };
+    }
+}
+export class MarkdownRenderer extends MarkdownRenderChild {
+    app;
+    hoverPopover = null;
+    constructor(containerEl = createFallbackElement(), application) {
+        super(containerEl);
+        this.app = resolveApplication(application);
+    }
+    /**
+     * Renders Markdown string to an HTML element.
+     *
+     * @deprecated - Use {@link MarkdownRenderer.render}
+     * @public
+     */
+    static renderMarkdown(markdown, el, sourcePath, component) {
+        return MarkdownRenderer.render(app, markdown, el, sourcePath, component);
+    }
+    /**
+     * 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 async render(app, markdown, el, sourcePath, component) {
+        await app.props.markdownRenderer(markdown, el, sourcePath, component);
+    }
+}
+export class MarkdownPreviewView extends MarkdownRenderer {
+    view;
+    data = "";
+    scroll = 0;
+    constructor(view) {
+        super(view?.containerEl ?? createFallbackElement(), view?.app);
+        this.view = view;
+    }
+    get file() {
+        return this.view?.file ?? null;
+    }
+    get() {
+        return this.data;
+    }
+    set(data, clear) {
+        if (clear)
+            this.clear();
+        this.data = data;
+    }
+    clear() {
+        this.containerEl?.replaceChildren?.();
+    }
+    rerender(full) { }
+    getScroll() {
+        return this.containerEl?.scrollTop ?? this.scroll;
+    }
+    applyScroll(scroll) {
+        this.scroll = scroll;
+        if (this.containerEl) {
+            this.containerEl.scrollTop = scroll;
+        }
+    }
+}
+export class MarkdownEditView {
+    view;
+    app;
+    hoverPopover = null;
+    constructor(view) {
+        this.view = view;
+        this.app = view.app;
+    }
+    clear() {
+        this.view.clear();
+    }
+    get() {
+        return this.view.getViewData();
+    }
+    set(data, clear) {
+        this.view.setViewData(data, clear);
+    }
+    get file() {
+        return this.view.file;
+    }
+    get editor() {
+        return this.view.editor;
+    }
+    getSelection() {
+        return this.view.editor.getSelection();
+    }
+    getScroll() {
+        return this.view.editor.getScrollInfo().top;
+    }
+    applyScroll(scroll) {
+        this.view.editor.scrollTo(null, scroll);
+    }
+}

package/dist/menu-utils.d.ts

@@ -0,0 +1 @@
+export declare function trimMenuEdgeSeparators<T>(sections: Record<string, Array<T | "separator">> | null | undefined): Record<string, Array<T | "separator">>;

package/dist/menu-utils.js

@@ -0,0 +1,47 @@
+export function trimMenuEdgeSeparators(sections) {
+    const entries = Object.entries(sections ?? {});
+    let firstContentSection = -1;
+    let firstContentIndex = -1;
+    let lastContentSection = -1;
+    let lastContentIndex = -1;
+    for (let sectionIndex = 0; sectionIndex < entries.length; sectionIndex++) {
+        const [, items] = entries[sectionIndex];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            if (items[itemIndex] !== "separator") {
+                firstContentSection = sectionIndex;
+                firstContentIndex = itemIndex;
+                break;
+            }
+        }
+        if (firstContentSection !== -1) {
+            break;
+        }
+    }
+    for (let sectionIndex = entries.length - 1; sectionIndex >= 0; sectionIndex--) {
+        const [, items] = entries[sectionIndex];
+        for (let itemIndex = items.length - 1; itemIndex >= 0; itemIndex--) {
+            if (items[itemIndex] !== "separator") {
+                lastContentSection = sectionIndex;
+                lastContentIndex = itemIndex;
+                break;
+            }
+        }
+        if (lastContentSection !== -1) {
+            break;
+        }
+    }
+    if (firstContentSection === -1 || lastContentSection === -1) {
+        return {};
+    }
+    const trimmedSections = {};
+    for (let sectionIndex = firstContentSection; sectionIndex <= lastContentSection; sectionIndex++) {
+        const [sectionId, items] = entries[sectionIndex];
+        const start = sectionIndex === firstContentSection ? firstContentIndex : 0;
+        const end = sectionIndex === lastContentSection ? lastContentIndex + 1 : items.length;
+        const slice = items.slice(start, end);
+        if (slice.length) {
+            trimmedSections[sectionId] = slice;
+        }
+    }
+    return trimmedSections;
+}

package/dist/menu.svelte.d.ts

@@ -0,0 +1,121 @@
+import { type MountComponent } from "./hooks/mountComponent.svelte";
+declare const MENU_ITEM_TAG: unique symbol;
+export declare class MenuItem {
+    readonly menu: Menu;
+    readonly [MENU_ITEM_TAG] = true;
+    private props;
+    get section(): string;
+    get title(): string | DocumentFragment;
+    get icon(): string | null;
+    get checked(): boolean | null;
+    get disabled(): boolean;
+    get isLabel(): boolean;
+    click(evt: MouseEvent | KeyboardEvent): any;
+    static create(menu: Menu): MenuItem;
+    /**
+     * Private constructor. Use {@link addItem} instead.
+     *
+     * @public
+     */
+    private constructor();
+    /** @public */
+    setTitle(title: string | DocumentFragment): this;
+    /**
+     * @param icon - ID of the icon, can use any icon loaded with {@link addIcon}
+     *   or from the built-in lucide library.
+     * @public
+     * @see The Obsidian icon library includes the {@link https://lucide.dev/ Lucide icon library}, any icon name from their site will work here.
+     */
+    setIcon(icon: string | null): this;
+    /** @public */
+    setChecked(checked: boolean | null): this;
+    /** @public */
+    setDisabled(disabled: boolean): this;
+    setWarning(warning?: boolean): this;
+    /** @public */
+    setIsLabel(isLabel: boolean): this;
+    /** @public */
+    onClick(callback: (evt: MouseEvent | KeyboardEvent) => any): this;
+    /**
+     * Sets the section this menu item should belong in. To find the section IDs
+     * of an existing menu, inspect the DOM elements to see their `data-section`
+     * attribute.
+     *
+     * @public
+     */
+    setSection(section: string): this;
+}
+export declare function isMenuItem(value: unknown): value is MenuItem;
+export interface MenuPositionDef {
+    /** @public */
+    x: number;
+    /** @public */
+    y: number;
+    /** @public */
+    width?: number;
+    /** @public */
+    overlap?: boolean;
+    /** @public */
+    left?: boolean;
+}
+export declare class MenuSeparator {
+    readonly section: string;
+    constructor(section?: string);
+}
+type Separator = "separator";
+type MenuEntry = MenuItem | Separator | Menu;
+export declare class Menu {
+    component: MountComponent<any> | null;
+    open: boolean;
+    filter: string;
+    private lastSection;
+    private readonly props;
+    get noIcon(): boolean;
+    get useNativeMenu(): boolean;
+    get items(): Record<string, MenuEntry[]>;
+    get renderedItems(): Record<string, ("separator" | MenuItem | Menu)[]>;
+    get filteredItems(): Record<string, ("separator" | MenuItem | Menu)[]>;
+    get title(): string;
+    get section(): string;
+    popover(): this;
+    dropdown(): this;
+    search(value: string): this;
+    clear(): this;
+    /** @public */
+    constructor();
+    /** @public */
+    setNoIcon(): this;
+    setTitle(title: string): this;
+    setSection(section: string): this;
+    /**
+     * Force this menu to use native or DOM. (Only works on the desktop app)
+     *
+     * @public
+     */
+    setUseNativeMenu(useNativeMenu: boolean): this;
+    /**
+     * Adds a menu item. Only works when menu is not shown yet.
+     *
+     * @public
+     */
+    addItem(cb: (item: MenuItem) => any): this;
+    addMenu(cb: (item: Menu) => any): this;
+    addGroups(...groups: Array<string | Array<string>>): this;
+    /**
+     * Adds a separator. Only works when menu is not shown yet.
+     *
+     * @public
+     */
+    addSeparator(section?: string): this;
+    /** @public */
+    hide(): this;
+    /** @public */
+    close(): void;
+    /** @public */
+    onHide(callback: () => any): void;
+    showAtElement(target?: HTMLElement | null): this;
+    showAtMouseEvent(evt: Event): this;
+    forEvent(evt: Event): this;
+    showAtPosition(position: MenuPositionDef, doc?: Document): this;
+}
+export {};

package/dist/menu.svelte.js

@@ -0,0 +1,295 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { mountComponent, } from "./hooks/mountComponent.svelte";
+import MenuComponent from "./components/menu/menu.svelte";
+import { fuzzyMatchScore } from "@lapis-notes/ui";
+import { trimMenuEdgeSeparators } from "./menu-utils";
+const MENU_ITEM_TAG = Symbol.for("@lapis-notes/menu-item");
+export class MenuItem {
+    menu;
+    [MENU_ITEM_TAG] = true;
+    props = $state({
+        section: "default",
+        title: "",
+        icon: "",
+        checked: null,
+        disabled: false,
+        isLabel: false,
+        onClick: () => {
+            this.menu.setOpen(false);
+        },
+    });
+    get section() {
+        return this.props.section;
+    }
+    get title() {
+        return this.props.title;
+    }
+    get icon() {
+        return this.props.icon;
+    }
+    get checked() {
+        return this.props.checked;
+    }
+    get disabled() {
+        return this.props.disabled;
+    }
+    get isLabel() {
+        return this.props.isLabel;
+    }
+    click(evt) {
+        return this.props.onClick(evt);
+    }
+    static create(menu) {
+        return new MenuItem(menu);
+    }
+    /**
+     * Private constructor. Use {@link addItem} instead.
+     *
+     * @public
+     */
+    constructor(menu) {
+        this.menu = menu;
+    }
+    /** @public */
+    setTitle(title) {
+        this.props.title = title;
+        return this;
+    }
+    /**
+     * @param icon - ID of the icon, can use any icon loaded with {@link addIcon}
+     *   or from the built-in lucide library.
+     * @public
+     * @see The Obsidian icon library includes the {@link https://lucide.dev/ Lucide icon library}, any icon name from their site will work here.
+     */
+    setIcon(icon) {
+        this.props.icon = icon;
+        return this;
+    }
+    /** @public */
+    setChecked(checked) {
+        this.props.checked = checked;
+        return this;
+    }
+    /** @public */
+    setDisabled(disabled) {
+        this.props.disabled = disabled;
+        return this;
+    }
+    setWarning(warning = true) {
+        return this.setSection(warning ? "danger" : this.section);
+    }
+    /** @public */
+    setIsLabel(isLabel) {
+        this.props.isLabel = isLabel;
+        return this;
+    }
+    /** @public */
+    onClick(callback) {
+        this.props.onClick = (evt) => {
+            callback(evt);
+            this.menu.setOpen(false);
+        };
+        return this;
+    }
+    /**
+     * Sets the section this menu item should belong in. To find the section IDs
+     * of an existing menu, inspect the DOM elements to see their `data-section`
+     * attribute.
+     *
+     * @public
+     */
+    setSection(section) {
+        this.props.section = section;
+        return this;
+    }
+}
+export function isMenuItem(value) {
+    return Boolean(value && typeof value === "object" && MENU_ITEM_TAG in value);
+}
+export class MenuSeparator {
+    section;
+    constructor(section = "default") {
+        this.section = section;
+    }
+}
+export class Menu {
+    component = null;
+    open = $state(false);
+    filter = $state("");
+    lastSection = "default";
+    props = {
+        noIcon: false,
+        section: "default",
+        type: "context-menu",
+        useNativeMenu: false,
+        items: {},
+        title: "",
+        onHide: () => { },
+    };
+    get noIcon() {
+        return this.props.noIcon;
+    }
+    get useNativeMenu() {
+        return this.props.useNativeMenu;
+    }
+    get items() {
+        return this.props.items ?? {};
+    }
+    get renderedItems() {
+        return trimMenuEdgeSeparators(this.items);
+    }
+    get filteredItems() {
+        const data = {};
+        for (const [id, values] of Object.entries(this.items)) {
+            const items = values
+                .map((item) => {
+                let score = 1;
+                if (isMenuItem(item) && typeof item.title === "string") {
+                    score = fuzzyMatchScore(item.title, this.filter, []);
+                }
+                return { item, score };
+            })
+                .filter((i) => i.score > 0)
+                .map((i) => i.item);
+            if (items.length) {
+                data[id] = items;
+            }
+        }
+        return trimMenuEdgeSeparators(data);
+    }
+    get title() {
+        return this.props.title;
+    }
+    get section() {
+        return this.props.section;
+    }
+    popover() {
+        this.props.type = "popover";
+        return this;
+    }
+    dropdown() {
+        this.props.type = "dropdown-menu";
+        return this;
+    }
+    search(value) {
+        this.filter = value;
+        return this;
+    }
+    clear() {
+        this.props.items = {};
+        return this;
+    }
+    /** @public */
+    constructor() { }
+    /** @public */
+    setNoIcon() {
+        this.props.noIcon = true;
+        return this;
+    }
+    setTitle(title) {
+        this.props.title = title;
+        return this;
+    }
+    setSection(section) {
+        this.props.section = section;
+        return this;
+    }
+    /**
+     * Force this menu to use native or DOM. (Only works on the desktop app)
+     *
+     * @public
+     */
+    setUseNativeMenu(useNativeMenu) {
+        this.props.useNativeMenu = useNativeMenu;
+        return this;
+    }
+    setOpen(open) {
+        const wasOpen = this.open;
+        this.open = open;
+        if (wasOpen && !open) {
+            this.props.onHide();
+        }
+        return this;
+    }
+    /**
+     * Adds a menu item. Only works when menu is not shown yet.
+     *
+     * @public
+     */
+    addItem(cb) {
+        const item = MenuItem.create(this);
+        cb(item);
+        this.lastSection = item.section;
+        this.props.items[item.section] ||= [];
+        this.props.items[item.section].push(item);
+        return this;
+    }
+    addMenu(cb) {
+        const item = new Menu();
+        cb(item);
+        this.lastSection = item.section;
+        this.props.items[item.section] ||= [];
+        this.props.items[item.section].push(item);
+        return this;
+    }
+    addGroups(...groups) {
+        groups.flat().forEach((group) => (this.props.items[group] ||= []));
+        return this;
+    }
+    /**
+     * Adds a separator. Only works when menu is not shown yet.
+     *
+     * @public
+     */
+    addSeparator(section) {
+        const items = this.props.items[section ?? this.lastSection];
+        if (!items.length || items[items.length - 1] === "separator")
+            return this;
+        items.push("separator");
+        return this;
+    }
+    /** @public */
+    hide() {
+        return this.setOpen(false);
+    }
+    /** @public */
+    close() {
+        this.setOpen(false);
+    }
+    /** @public */
+    onHide(callback) {
+        this.props.onHide = callback;
+    }
+    showAtElement(target) {
+        if (target) {
+            if (this.component && this.component.target === target) {
+                this.component.props.menu = this;
+                this.setOpen(true);
+            }
+            else {
+                this.setOpen(true);
+                this.component?.destroy();
+                this.component = mountComponent(MenuComponent, {
+                    target,
+                    props: {
+                        anchor: target,
+                        type: this.props.type,
+                        menu: this,
+                    },
+                });
+            }
+        }
+        return this;
+    }
+    showAtMouseEvent(evt) {
+        const target = evt.target;
+        return this.showAtElement(target);
+    }
+    forEvent(evt) {
+        return this.showAtMouseEvent(evt);
+    }
+    showAtPosition(position, doc) {
+        const target = (doc ?? document).elementFromPoint(position.x, position.y);
+        return this.showAtElement(target);
+    }
+}

package/dist/metadata-value.d.ts

@@ -0,0 +1,10 @@
+import type { MetadataType } from "./metadata.svelte";
+/** Infer a metadata type from a raw frontmatter value. */
+export declare function inferMetadataType(value: unknown): MetadataType;
+/** Infer a metadata type from a top-level frontmatter property name and value. */
+export declare function inferMetadataPropertyType(name: string, value: unknown): MetadataType;
+/**
+ * Best-effort normalization of a frontmatter value against a declared metadata
+ * type. Coerces when unambiguous; otherwise returns the original value.
+ */
+export declare function normalizeMetadataValue(type: MetadataType, value: unknown): unknown;