@lapis-notes/api 0.1.0

package/dist/context.svelte.js

@@ -0,0 +1,540 @@
+import { Workspace } from "./workspace.svelte";
+import { getAdapterVaultId, TFile, Vault, } from "./storage";
+import { IndexProjectionRegistry } from "./storage/index-projection";
+import { AppSettings } from "./settings.svelte";
+import { NativeDesktopCommunityPluginExecutionHost, PluginManager, } from "./plugin-manager";
+import { hasNativeDesktopCapability } from "./storage/desktop-native";
+import { Configuration } from "./configuration.svelte";
+import { CommandManager, Keymap, Scope, } from "./command.svelte";
+import { MetadataCache } from "./cache.svelte";
+import { logging } from "./logging";
+import { MetadataTypeManager } from "./metadata.svelte";
+import { FileManager } from "./file-manager";
+import { EmbedRegistry } from "./embed-registry";
+import { findOpenFileLeaf, leafFilePath, applyOpenViewStateToLeaf, } from "./open-file";
+import { LocalizationManager, localeManager, } from "./localization-manager.svelte";
+import { NotificationManager } from "./notifications";
+import { installVaultMaintenanceCommands } from "./vault-maintenance-commands";
+import { NoopTelemetryService } from "./telemetry";
+import { LanguageServiceManager, } from "./language-service";
+import { bindRuntimePluginDiagnostics } from "./diagnostics";
+import { ContextKeyService } from "./context-keys.svelte";
+import { StatusBarManager } from "./status-bar.svelte";
+import { AppUrlService } from "./app-url";
+import { WorkspaceTrustService } from "./workspace-trust";
+import { DefaultPluginDistributionManager, } from "./plugin-distribution";
+import { ConfigurationOptionSourceRegistry } from "./configuration-option-source-registry";
+import { resolveMetadataFieldValuesAsync } from "./configuration-option-source-providers";
+import { SearchDocumentProviderRegistry } from "./search-document-provider";
+import { DailyDocumentProviderRegistry } from "./daily-document-provider";
+import { AppToolRegistry } from "./agent-tools";
+import { AppSkillRegistry, AppSlashCommandRegistry, } from "./agent-skills";
+import { AppResultViewRegistry } from "./agent-result-views";
+import { MarkdownExtensionRegistry } from "./markdown-extension-registry";
+import { MarkdownFileSurfaceRegistry } from "./markdown-file-surface-registry";
+import { installApplicationCompatibility, resolveApplication, } from "./application-compatibility";
+import { provideApplicationState, useApplicationState, } from "./application-state.svelte";
+export { getApplicationCompatibility, installApplicationCompatibility, resolveApplication, } from "./application-compatibility";
+export { provideApplicationState, useApplicationState, } from "./application-state.svelte";
+/**
+ * Create the default safe mode state used for a normal startup.
+ *
+ * @public
+ */
+export function createDefaultAppSafeModeState() {
+    return {
+        active: false,
+        disableCommunityPlugins: false,
+        disableOptionalCorePlugins: false,
+        skipLayoutRestore: false,
+        disableNotebookExecution: false,
+        lastStartupFailure: null,
+    };
+}
+/**
+ * Ephemeral renderer state shared while processing a markdown view.
+ *
+ * @public
+ */
+export class RenderContext {
+    hoverPopover = null;
+}
+/**
+ * In-memory secret store used by runtime services and plugins.
+ *
+ * Hosts may replace or mirror this with stronger persisted storage, but the API
+ * surface intentionally stays small and synchronous for plugin code.
+ *
+ * @public
+ */
+export class SecretStorage {
+    secrets = {};
+    /**
+     * Store or replace a secret value.
+     *
+     * @param id - Stable identifier for the secret.
+     * @param secret - Raw secret value to store.
+     * @public
+     */
+    setSecret(id, secret) {
+        if (!/^[a-z0-9-]+$/.test(id)) {
+            throw new Error(`Invalid secret id: ${id}`);
+        }
+        this.secrets[id] = secret;
+    }
+    /**
+     * Look up a secret by id.
+     *
+     * @param id - Stable identifier for the secret.
+     * @returns The stored secret value, or `null` if no secret exists.
+     * @public
+     */
+    getSecret(id) {
+        return this.secrets[id] ?? null;
+    }
+    /**
+     * List the ids of all stored secrets.
+     *
+     * @public
+     */
+    listSecrets() {
+        return Object.keys(this.secrets);
+    }
+}
+/**
+ * Central runtime service container exposed to plugins, views, and renderer
+ * integrations.
+ *
+ * `App` owns the active vault session, workspace layout, plugin runtime,
+ * commands, metadata cache, notifications, and related shared services.
+ *
+ * @public
+ */
+export class App {
+    props;
+    i18n = localeManager;
+    workspace;
+    vault = $state();
+    appDatabase;
+    session;
+    safeMode;
+    plugins = $state();
+    scope = $state(new Scope(undefined, this));
+    keymap = $state(new Keymap(this.scope));
+    settings = $state(new AppSettings());
+    editors = new Map();
+    editorSuggest = new Map();
+    configuration;
+    fileManager = new FileManager(this);
+    contextKeys = new ContextKeyService();
+    statusBar = new StatusBarManager();
+    urls = new AppUrlService(this);
+    workspaceTrust;
+    pluginDistribution;
+    mardownPostProcessor = $state([]);
+    mardownCodeBlockPostProcessor = $state({});
+    markdownDirectiveRenderers = $state({});
+    markdownViewMenuItems = new Set();
+    metadataTypeManager = $state();
+    commands = $state(new CommandManager(this));
+    settingsOpen = $state(false);
+    settingsTabId = $state(null);
+    metadataCache = $state();
+    embedRegistry = new EmbedRegistry();
+    configurationOptionSources = new ConfigurationOptionSourceRegistry();
+    searchDocumentProviders = new SearchDocumentProviderRegistry();
+    dailyDocumentProviders = new DailyDocumentProviderRegistry();
+    indexProjections = new IndexProjectionRegistry();
+    agentTools = new AppToolRegistry();
+    agentSkills = new AppSkillRegistry();
+    agentSlashCommands = new AppSlashCommandRegistry();
+    agentResultViews = new AppResultViewRegistry();
+    markdownExtensions = new MarkdownExtensionRegistry();
+    markdownFileSurfaces = new MarkdownFileSurfaceRegistry();
+    lastEvent = $state(null);
+    renderContext = new RenderContext();
+    secretStorage = new SecretStorage();
+    notifications = $state();
+    telemetry = new NoopTelemetryService();
+    languageServices = new LanguageServiceManager({
+        onBeforeResolve: async (languageId) => {
+            await this.plugins?.activateForLanguage(languageId);
+            await this.plugins?.activateForService("language-service");
+            await this.plugins?.activateForService("lapis.languageService");
+        },
+    });
+    get internalPlugins() {
+        return this.plugins.internalPlugins;
+    }
+    logger = logging.getLogger("app");
+    /**
+     * Create the application service container for a mounted vault session.
+     *
+     * @param props - Runtime services and adapters required to bootstrap the app.
+     * @public
+     */
+    constructor(props) {
+        this.props = props;
+        const adapter = props.session?.vaultAdapter ?? props.adapter;
+        if (!adapter) {
+            throw new Error("App requires a vault adapter or vault session");
+        }
+        this.session = props.session;
+        this.safeMode = props.safeMode ?? createDefaultAppSafeModeState();
+        const appDatabase = props.session?.appDatabase ?? props.appDatabase;
+        if (!appDatabase) {
+            throw new Error(`App requires an app database for vault ${getAdapterVaultId(adapter)}`);
+        }
+        this.appDatabase = appDatabase;
+        // Workspace host setup subscribes to notification progress.
+        this.notifications = new NotificationManager(this.appDatabase);
+        this.workspace = new Workspace(this);
+        const editorViewsSource = this.configurationOptionSources.register("workspace.editorViews", {
+            label: "Workspace editor views",
+            description: "Registered editor views available for editor associations.",
+            getOptions: () => this.workspace.editorViews.getAll().map((view) => ({
+                value: view.id,
+                label: view.label,
+                description: view.description,
+            })),
+        });
+        this.workspace.editorViews.on("changed", () => {
+            editorViewsSource.invalidate();
+        });
+        this.settings.addGroup((options) => options.setId("options").setTitle("Options"));
+        this.settings.addGroup((options) => options.setId("core-plugins").setTitle("Core plugins"));
+        this.settings.addGroup((options) => options.setId("community-plugins").setTitle("Community plugins"));
+        this.configuration = new Configuration(this, props.configPath);
+        this.workspace.bindConfiguration();
+        this.vault = new Vault(adapter);
+        this.workspaceTrust = new WorkspaceTrustService(adapter);
+        this.metadataCache = new MetadataCache(this);
+        installVaultMaintenanceCommands(this);
+        this.plugins = new PluginManager(this, "/.obsidian/plugins", adapter, {
+            communityPluginHost: hasNativeDesktopCapability("plugin-sidecar")
+                ? new NativeDesktopCommunityPluginExecutionHost(adapter, undefined, props.createCommunityPluginDependencyResolver)
+                : undefined,
+            createCommunityPluginDependencyResolver: props.createCommunityPluginDependencyResolver,
+            pluginAssetServer: props.pluginAssetServer,
+        });
+        this.workspace.bindPlugins();
+        const languageServiceDiagnostics = this.workspace.diagnostics.createCollection("lapis:language-service", {
+            label: "Language service",
+            buildItemMenu: (menu, entry) => this.languageServices.buildDiagnosticItemMenu(menu, entry),
+        });
+        this.languageServices.bindDiagnostics({
+            collection: languageServiceDiagnostics,
+            applyCodeAction: (document, action) => this.applyLanguageServiceCodeAction(document, action),
+        });
+        bindRuntimePluginDiagnostics(this.plugins, this.workspace.diagnostics);
+        this.pluginDistribution = new DefaultPluginDistributionManager({
+            ...props.pluginDistributionOptions,
+            adapter,
+            appVersion: this.version,
+            platform: props.session?.runtime === "deno-desktop" ? "desktop" : "web",
+            workspaceTrusted: async () => (await this.workspaceTrust.ready()).trusted,
+            pluginManager: this.plugins,
+        });
+        this.metadataTypeManager = new MetadataTypeManager(this);
+        const metadataFieldValuesSource = this.configurationOptionSources.register("metadata.fieldValues", {
+            label: "Metadata field values",
+            description: "Known frontmatter values for a metadata field.",
+            cache: "session",
+            getOptions: (context) => resolveMetadataFieldValuesAsync((field) => this.metadataTypeManager.getValuesAsync(field), context.schema, context.query, context.limit),
+        });
+        this.metadataCache.on("changed", () => {
+            metadataFieldValuesSource.invalidate();
+        });
+        this.metadataCache.on("deleted", () => {
+            metadataFieldValuesSource.invalidate();
+        });
+        this.initializeContextKeys();
+    }
+    async applyLanguageServiceCodeAction(document, action) {
+        let value = document.text;
+        const path = document.uri.startsWith("vault:///")
+            ? decodeURI(document.uri.slice("vault:///".length))
+            : null;
+        const file = path ? this.vault.getFileByPath(path) : null;
+        if (file && action.edit && typeof action.edit === "object") {
+            const changes = action.edit.changes;
+            if (Array.isArray(changes)) {
+                const edits = changes
+                    .map((change) => {
+                    if (!change || typeof change !== "object")
+                        return null;
+                    const record = change;
+                    const from = typeof record.from === "number" ? record.from : null;
+                    const to = typeof record.to === "number" ? record.to : from;
+                    const insert = typeof record.insert === "string"
+                        ? record.insert
+                        : typeof record.text === "string"
+                            ? record.text
+                            : null;
+                    if (from === null || to === null || insert === null)
+                        return null;
+                    return { from, to, insert };
+                })
+                    .filter((edit) => edit !== null)
+                    .sort((left, right) => right.from - left.from);
+                if (edits.length) {
+                    for (const edit of edits) {
+                        value = `${value.slice(0, edit.from)}${edit.insert}${value.slice(edit.to)}`;
+                    }
+                    const openEditor = this.workspace.iterateAllLeaves((leaf) => {
+                        const view = leaf.view;
+                        return view?.editor && view.file?.path === file.path
+                            ? view.editor
+                            : undefined;
+                    });
+                    openEditor?.view.dispatch({
+                        changes: [...edits]
+                            .sort((left, right) => left.from - right.from)
+                            .map((edit) => ({
+                            from: edit.from,
+                            to: edit.to,
+                            insert: edit.insert,
+                        })),
+                        userEvent: "input.complete",
+                    });
+                    await this.vault.modify(file, value);
+                }
+            }
+        }
+        if (action.command) {
+            await this.languageServices.applyCommand({ ...document, text: value }, action.command);
+        }
+        if (!file && !action.command)
+            return;
+        if (!action.command && value === document.text)
+            return;
+        await this.languageServices.diagnostics({
+            ...document,
+            version: document.version + 1,
+            text: value,
+        });
+    }
+    initializeContextKeys() {
+        this.contextKeys.set("workspace.trusted", this.workspaceTrust.trusted);
+        this.workspaceTrust.on("changed", (state) => {
+            this.contextKeys.set("workspace.trusted", state.trusted);
+        });
+        this.contextKeys.set("safeMode.active", this.safeMode.active);
+        this.contextKeys.set("safeMode.notebookExecutionDisabled", this.safeMode.disableNotebookExecution);
+        const runtimeHost = hasNativeDesktopCapability("resource")
+            ? "desktop"
+            : "browser";
+        this.contextKeys.set("runtime.host", runtimeHost);
+        this.contextKeys.set("runtime.desktop", runtimeHost === "desktop");
+        this.contextKeys.set("runtime.browser", runtimeHost === "browser");
+        this.contextKeys.set("runtime.nativeHost", hasNativeDesktopCapability("resource"));
+        this.syncWorkspaceContextKeys();
+        this.workspace.on("active-leaf-change", () => {
+            this.syncWorkspaceContextKeys();
+        });
+        this.workspace.on("editor-updated", (editor) => {
+            if (editor === this.workspace.activeEditor?.editor) {
+                this.syncWorkspaceContextKeys();
+            }
+        });
+        void this.workspaceTrust.ready().then((state) => {
+            this.contextKeys.set("workspace.trusted", state.trusted);
+        });
+    }
+    syncWorkspaceContextKeys() {
+        const activeLeaf = this.workspace.activeLeaf;
+        const activeView = activeLeaf?.view;
+        const activeEditor = this.workspace.activeEditor?.editor;
+        this.contextKeys.set("view.focused", Boolean(activeView));
+        this.contextKeys.set("editor.active", Boolean(activeEditor));
+        this.contextKeys.set("editor.hasSelection", Boolean(activeEditor?.somethingSelected()));
+        if (activeView) {
+            this.contextKeys.set("view.id", activeView.getViewType());
+        }
+        else {
+            this.contextKeys.reset("view.id");
+        }
+        const language = this.workspace.activeEditor?.file?.extension;
+        if (language) {
+            this.contextKeys.set("editor.language", language);
+        }
+        else {
+            this.contextKeys.reset("editor.language");
+        }
+    }
+    setWorkspaceTrusted(trusted) {
+        this.contextKeys.set("workspace.trusted", trusted);
+    }
+    openFile(file, openState) {
+        return this.telemetry.measureAsync("app.open_file", async (span) => {
+            span.setAttribute("file.extension", file.extension);
+            const existingLeaf = findOpenFileLeaf(this.workspace, file);
+            if (existingLeaf) {
+                span.setAttribute("workspace.file_already_open", true);
+                await applyOpenViewStateToLeaf(existingLeaf, openState);
+                this.workspace.activateLeaf(existingLeaf, {
+                    operation: "open-existing-file",
+                });
+                return;
+            }
+            const reusedRootLeaf = Boolean(this.workspace.activeRootLeaf);
+            const leaf = this.workspace.getLeaf();
+            span.setAttribute("workspace.reused_active_leaf", reusedRootLeaf);
+            this.workspace.activeLeaf = leaf;
+            if (leafFilePath(leaf) === file.path) {
+                span.setAttribute("workspace.file_already_open", true);
+                if (openState?.state) {
+                    await applyOpenViewStateToLeaf(leaf, openState);
+                }
+                return;
+            }
+            const viewState = openState?.state
+                ? {
+                    type: this.workspace.determineViewTypeForPath(file.path) ??
+                        this.workspace.determineViewType(file.extension) ??
+                        "",
+                    state: openState.state,
+                }
+                : undefined;
+            return leaf.openFile(file, { state: viewState });
+        }, {
+            attributes: { "file.extension": file.extension },
+            slowThresholdMs: 250,
+        });
+    }
+    editorExtensions(viewType, context = {}) {
+        const extensions = [];
+        const type = this.workspace.determineViewType(viewType);
+        if (type) {
+            [...(this.editors.get(type) ?? [])].forEach((ext) => {
+                if (typeof ext === "function") {
+                    extensions.push(ext(context));
+                }
+                else {
+                    extensions.push(ext);
+                }
+            });
+        }
+        return extensions;
+    }
+    /**
+     * Registers a CodeMirror 6 extension. To reconfigure cm6 extensions for a
+     * plugin on the fly, an array should be passed in, and modified dynamically.
+     * Once this array is modified, calling {@link Workspace#updateOptions} will
+     * apply the changes.
+     *
+     * @param extension - Must be a CodeMirror 6 `Extension`, or an array of
+     *   Extensions.
+     * @public
+     */
+    registerEditorExtension(extension, viewType = "markdown") {
+        viewType = this.workspace.determineViewType(viewType) ?? "markdown";
+        if (!this.editors.get(viewType)) {
+            this.editors.set(viewType, new Set());
+        }
+        this.editors.get(viewType).add(extension);
+    }
+    unregisterEditorExtension(extension, viewType = "markdown") {
+        viewType = this.editors.has(viewType)
+            ? viewType
+            : (this.workspace.determineViewType(viewType) ?? "markdown");
+        this.editors.get(viewType)?.delete(extension);
+    }
+    registerEditorSuggest(suggest, viewType = "markdown") {
+        viewType = this.workspace.determineViewType(viewType) ?? "markdown";
+        if (!this.editorSuggest.get(viewType)) {
+            this.editorSuggest.set(viewType, new Set());
+        }
+        this.editorSuggest.get(viewType).add(suggest);
+    }
+    unregisterEditorSuggest(suggest, viewType = "markdown") {
+        viewType = this.workspace.determineViewType(viewType) ?? "markdown";
+        this.editorSuggest.get(viewType)?.delete(suggest);
+    }
+    registerMarkdownPostProcessor(postProcessor) {
+        const processors = [
+            ...new Set([...this.mardownPostProcessor, postProcessor]),
+        ].sort((a, b) => {
+            return (a.sortOrder ?? 0) - (b.sortOrder ?? 0);
+        });
+        this.mardownPostProcessor = processors;
+    }
+    unregisterMarkdownPostProcessor(postProcessor) {
+        this.mardownPostProcessor = this.mardownPostProcessor.filter((it) => it !== postProcessor);
+    }
+    registerMarkdownCodeBlockProcessor(language, postProcessor) {
+        this.mardownCodeBlockPostProcessor[language] ||= [];
+        const processors = [
+            ...new Set([
+                ...this.mardownCodeBlockPostProcessor[language],
+                postProcessor,
+            ]),
+        ].sort((a, b) => {
+            return (a.sortOrder ?? 0) - (b.sortOrder ?? 0);
+        });
+        this.mardownCodeBlockPostProcessor[language] = processors;
+    }
+    unregisterMarkdownCodeBlockProcessor(language, postProcessor) {
+        this.mardownCodeBlockPostProcessor[language] ||= [];
+        this.mardownCodeBlockPostProcessor[language] =
+            this.mardownCodeBlockPostProcessor[language].filter((it) => it !== postProcessor);
+    }
+    registerMarkdownDirectiveRenderer(directive, renderer) {
+        this.markdownDirectiveRenderers = {
+            ...this.markdownDirectiveRenderers,
+            [directive]: renderer,
+        };
+    }
+    unregisterMarkdownDirectiveRenderer(directive) {
+        const { [directive]: _removed, ...rest } = this.markdownDirectiveRenderers;
+        this.markdownDirectiveRenderers = rest;
+    }
+    registerMarkdownViewMenuItem(provider) {
+        this.markdownViewMenuItems.add(provider);
+    }
+    unregisterMarkdownViewMenuItem(provider) {
+        this.markdownViewMenuItems.delete(provider);
+    }
+    get version() {
+        return this.props.version;
+    }
+    get isDarkMode() {
+        return document.documentElement.classList.contains("theme-dark");
+    }
+    loadLocalStorage(key) {
+        return localStorage.getItem(key);
+    }
+    saveLocalStorage(key, data) {
+        localStorage.setItem(key, data);
+    }
+    /**
+     * Force mobile or desktop workspace layout and reload the app.
+     *
+     * Intended for devtools/console use when testing mobile shell behavior on
+     * desktop viewports.
+     *
+     * @param enable - When true or omitted, forces mobile layout; when false,
+     *   forces desktop layout.
+     * @public
+     */
+    async emulateMobile(enable = true) {
+        const mode = enable ? "always" : "never";
+        await this.configuration
+            .getConfiguration()
+            .update("workspace.mobile.mode", mode);
+        if (typeof window !== "undefined") {
+            window.location.reload();
+        }
+    }
+    setting(id) {
+        return this.settings.find(id);
+    }
+}
+let legacyApplicationLease = null;
+export function setApplicationState(props) {
+    const application = new App(props);
+    provideApplicationState(application);
+    legacyApplicationLease?.();
+    legacyApplicationLease = installApplicationCompatibility(application);
+    return application;
+}

package/dist/daily-document-provider.d.ts

@@ -0,0 +1,38 @@
+import type { App } from "./context.svelte";
+import { EventDispatcher } from "./events";
+import type { TFile } from "./storage";
+export declare const DEFAULT_DAILY_NOTES_FOLDER = "daily";
+export declare const DEFAULT_DAILY_NOTES_DATE_FORMAT = "yyyy-MM-dd";
+export type DailyDocumentProvider = {
+    /** Stable application-wide provider id. */
+    id: string;
+    /** Higher priorities override lower-priority providers. */
+    priority?: number;
+    /** Find the canonical daily note for a local calendar date. */
+    locate(date: string): Promise<TFile | null>;
+    /** Find or create the canonical daily note for a local calendar date. */
+    ensure(date: string): Promise<TFile>;
+};
+export type DailyDocumentProviderRegistration = {
+    readonly id: string;
+    dispose(): void;
+};
+export type DailyDocumentProviderChange = {
+    providerId: string;
+    reason: "registered" | "unregistered";
+};
+/** Public registry for the host-owned daily Markdown document policy. */
+export declare class DailyDocumentProviderRegistry extends EventDispatcher<{
+    changed: [change: DailyDocumentProviderChange];
+}> {
+    private readonly providers;
+    register(provider: DailyDocumentProvider): DailyDocumentProviderRegistration;
+    getAll(): DailyDocumentProvider[];
+    resolve(): DailyDocumentProvider;
+}
+export declare function formatDailyDocumentFilename(date: string, format: string): string;
+/**
+ * Install Lapis' default daily-note policy and its generated settings controls.
+ * Hosts call this before loading configuration and dispose it with the App.
+ */
+export declare function registerDefaultDailyDocumentProvider(app: App): DailyDocumentProviderRegistration;