@lapis-notes/api 0.1.0

package/dist/command.svelte.js

@@ -0,0 +1,571 @@
+import { EventDispatcher } from "./events";
+import { resolveApplication } from "./application-compatibility";
+const HOTKEYS_PATH = "/.obsidian/hotkeys.json";
+const MODIFIER_ORDER = ["Mod", "Ctrl", "Meta", "Alt", "Shift"];
+const WORKSPACE_ROOT_COMMAND_HOST_ID = "root";
+function isModifierValue(value) {
+    return (value === "Mod" ||
+        value === "Ctrl" ||
+        value === "Meta" ||
+        value === "Shift" ||
+        value === "Alt");
+}
+function normalizeStoredHotkey(hotkey) {
+    const modifiers = Array.from(new Set(hotkey.modifiers.filter(isModifierValue))).sort((a, b) => MODIFIER_ORDER.indexOf(a) - MODIFIER_ORDER.indexOf(b));
+    return {
+        modifiers,
+        key: hotkey.key.length === 1 ? hotkey.key.toUpperCase() : hotkey.key,
+    };
+}
+function parseHotkey(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        !Array.isArray(value.modifiers) ||
+        typeof value.key !== "string" ||
+        !value.key.trim()) {
+        return null;
+    }
+    return normalizeStoredHotkey({
+        modifiers: value.modifiers.filter(isModifierValue),
+        key: value.key.trim(),
+    });
+}
+function getPlatformMod() {
+    const navigatorLike = globalThis.navigator;
+    const platform = navigatorLike?.userAgentData?.platform ?? navigatorLike?.platform ?? "";
+    return /mac/i.test(platform) ? "Meta" : "Ctrl";
+}
+function normalizeHotkey(hotkey) {
+    return {
+        ...hotkey,
+        modifiers: hotkey.modifiers.map((modifier) => modifier === "Mod" ? getPlatformMod() : modifier),
+    };
+}
+function keyId(hotkey) {
+    const normalized = normalizeHotkey(hotkey);
+    const parts = [];
+    parts.push(...normalized.modifiers.slice().sort());
+    if (normalized.key) {
+        parts.push(normalized.key.length === 1
+            ? normalized.key.toUpperCase()
+            : normalized.key);
+    }
+    return parts.join("+");
+}
+export function getHotkeyId(hotkey) {
+    return keyId(hotkey);
+}
+export class CommandManager extends EventDispatcher {
+    app;
+    open = $state(false);
+    openHostId = $state(WORKSPACE_ROOT_COMMAND_HOST_ID);
+    commands = $state({});
+    editorCommands = $state({});
+    bindings = $state({});
+    hotkeyOverrides = $state({});
+    constructor(app) {
+        super();
+        this.app = app;
+    }
+    currentHostId() {
+        return (this.app.workspace?.getFocusedCommandHostId?.() ??
+            WORKSPACE_ROOT_COMMAND_HOST_ID);
+    }
+    isOpenForHost(hostId) {
+        return this.open && this.openHostId === hostId;
+    }
+    resolveExecutionContext(hostId = this.currentHostId()) {
+        const activeLeaf = this.app.workspace?.getCommandHostLeaf?.(hostId) ??
+            this.app.workspace?.activeLeaf;
+        const view = activeLeaf?.view;
+        return {
+            view,
+            editor: view?.editor,
+        };
+    }
+    hasExecutableHandler(command) {
+        return Boolean(command.callback ||
+            command.checkCallback ||
+            command.editorCallback ||
+            command.editorCheckCallback);
+    }
+    toCommandMetadata(command) {
+        return {
+            id: command.id,
+            label: command.name,
+            title: command.title ?? command.name,
+            category: command.category,
+            icon: command.icon,
+            hotkeys: this.getEffectiveHotkeys(command.id),
+            sourcePlugin: command.sourcePlugin,
+            activationEvent: command.activationEvent,
+            argumentSchema: command.argumentSchema,
+            when: command.when,
+        };
+    }
+    hasHotkeyOverride(commandId) {
+        return Object.hasOwn(this.hotkeyOverrides, commandId);
+    }
+    bindCommandHotkeys(command) {
+        if (!this.hasExecutableHandler(command)) {
+            return;
+        }
+        for (const key of this.getEffectiveHotkeys(command.id)) {
+            const id = keyId(key);
+            this.bindings[id] ||= [];
+            this.bindings[id].push(command);
+        }
+    }
+    rebuildBindings() {
+        for (const id of Object.keys(this.bindings)) {
+            delete this.bindings[id];
+        }
+        for (const command of this.getAllCommands()) {
+            this.bindCommandHotkeys(command);
+        }
+    }
+    readHotkeyOverrideFile() {
+        return (this.app.vault?.getFileByPath?.(HOTKEYS_PATH) ?? null);
+    }
+    normalizeOverrides(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return {};
+        }
+        const overrides = {};
+        for (const [commandId, hotkeys] of Object.entries(value)) {
+            if (!Array.isArray(hotkeys)) {
+                continue;
+            }
+            const parsed = hotkeys
+                .map((hotkey) => parseHotkey(hotkey))
+                .filter((hotkey) => Boolean(hotkey));
+            overrides[commandId] = this.dedupeHotkeys(parsed);
+        }
+        return overrides;
+    }
+    dedupeHotkeys(hotkeys) {
+        const seen = new Set();
+        const deduped = [];
+        for (const hotkey of hotkeys.map(normalizeStoredHotkey)) {
+            const id = keyId(hotkey);
+            if (seen.has(id)) {
+                continue;
+            }
+            seen.add(id);
+            deduped.push(hotkey);
+        }
+        return deduped;
+    }
+    async loadHotkeys() {
+        const file = this.readHotkeyOverrideFile();
+        if (!file) {
+            this.replaceHotkeyOverrides({});
+            return;
+        }
+        try {
+            const raw = await this.app.vault.read(file);
+            this.replaceHotkeyOverrides(this.normalizeOverrides(JSON.parse(raw)));
+        }
+        catch (error) {
+            console.warn("Unable to load hotkeys.json; ignoring custom hotkeys", error);
+            this.replaceHotkeyOverrides({});
+        }
+    }
+    async saveHotkeys() {
+        const data = JSON.stringify(this.hotkeyOverrides, null, 2);
+        const file = this.readHotkeyOverrideFile();
+        if (file) {
+            await this.app.vault.modify(file, data);
+            return;
+        }
+        await this.app.vault.mkpath("/.obsidian");
+        await this.app.vault.create(HOTKEYS_PATH, data);
+    }
+    replaceHotkeyOverrides(overrides) {
+        for (const id of Object.keys(this.hotkeyOverrides)) {
+            delete this.hotkeyOverrides[id];
+        }
+        for (const [id, hotkeys] of Object.entries(overrides)) {
+            this.hotkeyOverrides[id] = this.dedupeHotkeys(hotkeys);
+        }
+        this.rebuildBindings();
+        this.emit("hotkeys-updated", {
+            hotkeys: this.hotkeyOverrides,
+        });
+    }
+    getDefaultHotkeys(commandId) {
+        return [...(this.commands[commandId]?.hotkeys ?? [])].map(normalizeStoredHotkey);
+    }
+    getEffectiveHotkeys(commandId) {
+        if (this.hasHotkeyOverride(commandId)) {
+            return [...this.hotkeyOverrides[commandId]];
+        }
+        return this.getDefaultHotkeys(commandId);
+    }
+    isHotkeyCustomized(commandId) {
+        return this.hasHotkeyOverride(commandId);
+    }
+    async setHotkeys(commandId, hotkeys) {
+        this.hotkeyOverrides[commandId] = this.dedupeHotkeys(hotkeys);
+        this.rebuildBindings();
+        this.emit("hotkeys-updated", {
+            commandId,
+            hotkeys: this.hotkeyOverrides,
+        });
+        await this.saveHotkeys();
+    }
+    async addHotkey(commandId, hotkey) {
+        await this.setHotkeys(commandId, [
+            ...this.getEffectiveHotkeys(commandId),
+            hotkey,
+        ]);
+    }
+    async removeHotkey(commandId, hotkey) {
+        const removeId = keyId(hotkey);
+        await this.setHotkeys(commandId, this.getEffectiveHotkeys(commandId).filter((candidate) => keyId(candidate) !== removeId));
+    }
+    async resetHotkeys(commandId) {
+        delete this.hotkeyOverrides[commandId];
+        this.rebuildBindings();
+        this.emit("hotkeys-updated", {
+            commandId,
+            hotkeys: this.hotkeyOverrides,
+        });
+        await this.saveHotkeys();
+    }
+    getHotkeyAssignments() {
+        return this.getAllCommands().map((command) => ({
+            command,
+            commandId: command.id,
+            defaultHotkeys: this.getDefaultHotkeys(command.id),
+            hotkeys: this.getEffectiveHotkeys(command.id),
+            customized: this.isHotkeyCustomized(command.id),
+        }));
+    }
+    getHotkeyConflicts() {
+        const byHotkey = new Map();
+        for (const assignment of this.getHotkeyAssignments()) {
+            for (const hotkey of assignment.hotkeys) {
+                const id = keyId(hotkey);
+                const existing = byHotkey.get(id);
+                if (existing) {
+                    existing.commandIds.push(assignment.commandId);
+                }
+                else {
+                    byHotkey.set(id, {
+                        hotkey,
+                        commandIds: [assignment.commandId],
+                    });
+                }
+            }
+        }
+        return Array.from(byHotkey.entries())
+            .filter(([, conflict]) => conflict.commandIds.length > 1)
+            .map(([hotkeyId, conflict]) => ({
+            hotkeyId,
+            hotkey: conflict.hotkey,
+            commandIds: conflict.commandIds,
+        }));
+    }
+    registerCommand(command) {
+        if (!this.commands[command.id]) {
+            this.commands[command.id] = command;
+            if (!this.editorCommands[command.id] &&
+                (command.editorCallback || command.editorCheckCallback)) {
+                this.editorCommands[command.id] = command;
+            }
+            this.bindCommandHotkeys(command);
+            this.emit("register", command);
+        }
+    }
+    unregisterCommand(id) {
+        const cmd = this.commands[id];
+        if (cmd) {
+            delete this.commands[id];
+            if ((cmd.editorCallback || cmd.editorCheckCallback) &&
+                this.editorCommands[id]) {
+                delete this.editorCommands[id];
+            }
+            this.rebuildBindings();
+            this.emit("unregister", cmd);
+            return true;
+        }
+        return false;
+    }
+    getCommand(id) {
+        return this.commands[id];
+    }
+    getCommandMetadata(id) {
+        const command = this.getCommand(id);
+        return command ? this.toCommandMetadata(command) : undefined;
+    }
+    isCommandAvailable(id, hostId = this.currentHostId()) {
+        const command = this.getCommand(id);
+        if (!command) {
+            return false;
+        }
+        const context = this.resolveExecutionContext(hostId);
+        if (!this.app.contextKeys.evaluate(command.when)) {
+            return false;
+        }
+        if (command.editorCheckCallback) {
+            return Boolean(context.editor &&
+                command.editorCheckCallback(true, context.editor, context.view));
+        }
+        if (command.checkCallback) {
+            return Boolean(command.checkCallback(true));
+        }
+        if (command.editorCallback) {
+            return Boolean(context.editor);
+        }
+        return Boolean(command.callback);
+    }
+    getAvailableCommands(hostId = this.currentHostId()) {
+        return this.getAllCommands().filter((command) => this.isCommandAvailable(command.id, hostId));
+    }
+    getAvailableCommandMetadata(hostId = this.currentHostId()) {
+        return this.getAvailableCommands(hostId).map((command) => this.toCommandMetadata(command));
+    }
+    async executeCommandWithHost(id, hostId, ...rest) {
+        const command = this.commands[id];
+        if (!command) {
+            return Promise.reject(new Error(`Invalid command: '${id}'`));
+        }
+        const context = this.resolveExecutionContext(hostId);
+        let response;
+        if (!this.app.contextKeys.evaluate(command.when)) {
+            return Promise.reject(new Error(`Command unavailable: '${id}'`));
+        }
+        if (command.editorCheckCallback) {
+            if (!context.editor ||
+                !command.editorCheckCallback(true, context.editor, context.view)) {
+                return Promise.reject(new Error(`Command unavailable: '${id}'`));
+            }
+            response = (await command.editorCheckCallback(false, context.editor, context.view));
+        }
+        else if (command.checkCallback) {
+            if (!command.checkCallback(true)) {
+                return Promise.reject(new Error(`Command unavailable: '${id}'`));
+            }
+            response = (await command.checkCallback(false));
+        }
+        else if (command.editorCallback) {
+            if (!context.editor) {
+                return Promise.reject(new Error(`Command unavailable: '${id}'`));
+            }
+            response = (await command.editorCallback(context.editor, context.view));
+        }
+        else if (command.callback) {
+            response = (await command.callback(...rest));
+        }
+        else {
+            return Promise.reject(new Error(`Command unavailable: '${id}'`));
+        }
+        this.emit("executed", command);
+        return response;
+    }
+    async executeCommand(id, ...rest) {
+        return this.executeCommandWithHost(id, this.currentHostId(), ...rest);
+    }
+    async executeCommandForHost(id, hostId, ...rest) {
+        return this.executeCommandWithHost(id, hostId, ...rest);
+    }
+    show(hostId = this.currentHostId()) {
+        this.openHostId = hostId;
+        this.open = true;
+    }
+    hide(hostId) {
+        if (hostId && this.openHostId !== hostId) {
+            return;
+        }
+        this.open = false;
+    }
+    toggle(hostId = this.currentHostId()) {
+        if (this.isOpenForHost(hostId)) {
+            this.hide(hostId);
+            return;
+        }
+        this.show(hostId);
+    }
+    commandsFor(key) {
+        const id = keyId(key);
+        return this.bindings[id] || [];
+    }
+    getAllCommands() {
+        return Array.from(Object.values(this.commands));
+    }
+    getAllCommandMetadata() {
+        return this.getAllCommands().map((command) => this.toCommandMetadata(command));
+    }
+}
+export class Keymap {
+    scopes = [];
+    constructor(defaultScope) {
+        if (defaultScope) {
+            this.scopes.push(defaultScope);
+        }
+    }
+    pushScope(scope) {
+        if (!this.scopes.includes(scope)) {
+            this.scopes.push(scope);
+        }
+    }
+    popScope(scope) {
+        this.scopes = this.scopes.filter((item) => item !== scope);
+    }
+    handleAdditionalScopes(event) {
+        for (let i = this.scopes.length - 1; i >= 1; i--) {
+            if (this.scopes[i].handleEvent(event)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    handleEvent(event) {
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            if (this.scopes[i].handleEvent(event)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static isModifier(evt, modifier) {
+        switch (modifier) {
+            case "Mod":
+                return Keymap.isModEvent(evt);
+            case "Ctrl":
+                return evt.ctrlKey;
+            case "Meta":
+                return evt.metaKey;
+            case "Shift":
+                return evt.shiftKey;
+            case "Alt":
+                return evt.altKey;
+        }
+    }
+    static isModEvent(evt) {
+        return navigator.platform.toLowerCase().includes("mac")
+            ? evt.metaKey
+            : evt.ctrlKey;
+    }
+}
+export class Scope {
+    keyBindings = new Map();
+    isMacOS = false;
+    application;
+    /** @public */
+    constructor(parent, application) {
+        this.application = application ?? parent?.application;
+        if (parent) {
+            for (const [key, value] of parent.keyBindings.entries()) {
+                const handlers = value.map((h) => ({ ...h, scope: this }));
+                this.keyBindings.set(key, handlers);
+            }
+        }
+    }
+    get keys() {
+        return this.keyBindings.keys();
+    }
+    /**
+     * Add a keymap event handler to this scope.
+     *
+     * @param modifiers - `Mod`, `Ctrl`, `Meta`, `Shift`, or `Alt`. `Mod`
+     *   translates to `Meta` on macOS and `Ctrl` otherwise. Pass `null` to
+     *   capture all events matching the `key`, regardless of modifiers.
+     * @param key - Keycode from
+     *   https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key%5FValues
+     * @param func - The callback that will be called when a user triggers the
+     *   keybind.
+     * @public
+     */
+    register(modifiers, key, func) {
+        const binding = {
+            modifiers: modifiers?.sort().join("+") ?? "",
+            key,
+            scope: this,
+        };
+        const id = this.getId(binding);
+        if (!this.keyBindings.has(id)) {
+            this.keyBindings.set(id, []);
+        }
+        this.keyBindings.get(id).push({ ...binding, handler: func });
+        return binding;
+    }
+    /**
+     * Remove an existing keymap event handler.
+     *
+     * @public
+     */
+    unregister(handler) {
+        const id = this.getId(handler);
+        let handlers = this.keyBindings.get(id);
+        if (!handlers) {
+            return;
+        }
+        handlers = handlers.filter((binding) => {
+            !(binding.modifiers === handler.modifiers && binding.key === handler.key);
+        });
+        handlers.length == 0
+            ? this.keyBindings.delete(id)
+            : this.keyBindings.set(id, handlers);
+    }
+    handleEvent(event) {
+        const hotkey = { modifiers: [], key: "" };
+        if (event.ctrlKey)
+            hotkey.modifiers.push("Ctrl");
+        if (event.altKey)
+            hotkey.modifiers.push("Alt");
+        if (event.shiftKey)
+            hotkey.modifiers.push("Shift");
+        if (event.metaKey)
+            hotkey.modifiers.push("Meta");
+        const key = event.key;
+        if (key !== "Control" &&
+            key !== "Alt" &&
+            key !== "Shift" &&
+            key !== "Meta") {
+            hotkey.key = key;
+        }
+        const handlerIds = [
+            keyId(hotkey),
+            keyId({ modifiers: hotkey.modifiers, key: "" }),
+            keyId({ modifiers: [], key: hotkey.key }),
+            keyId({ modifiers: [], key: "" }),
+        ];
+        const handlers = handlerIds.flatMap((id) => this.keyBindings.get(id) || []);
+        if (handlers.length) {
+            for (const handler of handlers) {
+                const response = handler.handler(event, { ...handler, vkey: "" });
+                if (response === false) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+                if (event.defaultPrevented) {
+                    return true;
+                }
+            }
+        }
+        const application = resolveApplication(this.application);
+        const commands = application.commands.commandsFor(hotkey);
+        for (const command of commands) {
+            if (!application.commands.isCommandAvailable(command.id)) {
+                continue;
+            }
+            void application.commands
+                .executeCommand(command.id)
+                .catch((error) => {
+                console.warn(`Unable to execute command hotkey: ${command.id}`, error);
+            });
+            event.preventDefault();
+            event.stopPropagation();
+            return true;
+        }
+        return false;
+    }
+    getId(handler) {
+        return keyId({
+            modifiers: (handler.modifiers || "").split("+"),
+            key: handler.key || "",
+        });
+    }
+}

package/dist/compat.d.ts

@@ -0,0 +1,29 @@
+import type { App } from "./context.svelte";
+import { BaseComponent } from "./settings.svelte";
+export type HexString = string;
+export type Side = "left" | "right";
+export interface CliData {
+    [key: string]: string | "true";
+}
+export interface CliFlag {
+    value?: string;
+    description: string;
+    required?: boolean;
+}
+export type CliFlags = Record<string, CliFlag>;
+export type CliHandler = (params: CliData) => string | Promise<string>;
+export interface ObsidianProtocolData {
+    action: string;
+    [key: string]: string | "true";
+}
+export type ObsidianProtocolHandler = (params: ObsidianProtocolData) => unknown;
+export declare const moment: any;
+export declare class SecretComponent extends BaseComponent {
+    readonly app: App;
+    private readonly input;
+    constructor(app: App, containerEl: HTMLElement);
+    get disabled(): boolean;
+    setDisabled(disabled: boolean): this;
+    setValue(value: string): this;
+    onChange(cb: (value: string) => unknown): this;
+}

package/dist/compat.js

@@ -0,0 +1,30 @@
+import { BaseComponent, TextComponent } from "./settings.svelte";
+export const moment = globalThis.moment ??
+    ((value) => {
+        return value;
+    });
+export class SecretComponent extends BaseComponent {
+    app;
+    input;
+    constructor(app, containerEl) {
+        super();
+        this.app = app;
+        this.input = new TextComponent(containerEl);
+        this.input.setType("password");
+    }
+    get disabled() {
+        return this.input.disabled;
+    }
+    setDisabled(disabled) {
+        this.input.setDisabled(disabled);
+        return this;
+    }
+    setValue(value) {
+        this.input.setValue(value);
+        return this;
+    }
+    onChange(cb) {
+        this.input.onChange(cb);
+        return this;
+    }
+}