@lapis-notes/api 0.1.0

package/dist/context-keys.svelte.d.ts

@@ -0,0 +1,42 @@
+import { EventDispatcher } from "./events";
+export type ContextKeyValue = string | number | boolean | null | undefined;
+export interface ContextKeyChangeEvent {
+    keys: string[];
+}
+export interface ScopedContextKey {
+    readonly key: string;
+    get(): ContextKeyValue;
+    set(value: ContextKeyValue): void;
+    reset(): void;
+}
+type WhenExpression = {
+    type: "identifier";
+    name: string;
+} | {
+    type: "literal";
+    value: string | number | boolean;
+} | {
+    type: "unary";
+    operator: "!";
+    operand: WhenExpression;
+} | {
+    type: "binary";
+    operator: "&&" | "||" | "==" | "!=";
+    left: WhenExpression;
+    right: WhenExpression;
+};
+export declare function parseWhenClause(expression: string): WhenExpression;
+export declare function evaluateWhenClause(expression: string | WhenExpression, lookup: (key: string) => ContextKeyValue): boolean;
+export declare class ContextKeyService extends EventDispatcher<{
+    change: [event: ContextKeyChangeEvent];
+}> {
+    #private;
+    constructor(initialValues?: Record<string, ContextKeyValue>);
+    get(key: string): ContextKeyValue;
+    set(key: string, value: ContextKeyValue): void;
+    reset(key: string): void;
+    evaluate(expression: string | null | undefined): boolean;
+    createScopedKey(scope: string, key: string, defaultValue?: ContextKeyValue): ScopedContextKey;
+    private bump;
+}
+export {};

package/dist/context-keys.svelte.js

@@ -0,0 +1,278 @@
+import { EventDispatcher } from "./events";
+class WhenParser {
+    tokens;
+    #index = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const expression = this.parseOr();
+        this.expect("eof");
+        return expression;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.match("||")) {
+            left = {
+                type: "binary",
+                operator: "||",
+                left,
+                right: this.parseAnd(),
+            };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseEquality();
+        while (this.match("&&")) {
+            left = {
+                type: "binary",
+                operator: "&&",
+                left,
+                right: this.parseEquality(),
+            };
+        }
+        return left;
+    }
+    parseEquality() {
+        let left = this.parseUnary();
+        while (true) {
+            if (this.match("==")) {
+                left = {
+                    type: "binary",
+                    operator: "==",
+                    left,
+                    right: this.parseUnary(),
+                };
+                continue;
+            }
+            if (this.match("!=")) {
+                left = {
+                    type: "binary",
+                    operator: "!=",
+                    left,
+                    right: this.parseUnary(),
+                };
+                continue;
+            }
+            return left;
+        }
+    }
+    parseUnary() {
+        if (this.match("!")) {
+            return {
+                type: "unary",
+                operator: "!",
+                operand: this.parseUnary(),
+            };
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        const token = this.current();
+        if (token.type === "identifier") {
+            this.#index += 1;
+            return { type: "identifier", name: token.value };
+        }
+        if (token.type === "string" ||
+            token.type === "number" ||
+            token.type === "boolean") {
+            this.#index += 1;
+            return { type: "literal", value: token.value };
+        }
+        if (this.match("(")) {
+            const expression = this.parseOr();
+            this.expect(")");
+            return expression;
+        }
+        throw new Error(`Unexpected token ${describeToken(token)}`);
+    }
+    current() {
+        return this.tokens[this.#index] ?? { type: "eof" };
+    }
+    match(type) {
+        if (this.current().type !== type) {
+            return false;
+        }
+        this.#index += 1;
+        return true;
+    }
+    expect(type) {
+        if (!this.match(type)) {
+            throw new Error(`Expected ${type}, received ${describeToken(this.current())}`);
+        }
+    }
+}
+function describeToken(token) {
+    return token.type === "identifier"
+        ? `identifier ${token.value}`
+        : token.type === "string"
+            ? `string ${JSON.stringify(token.value)}`
+            : token.type === "number"
+                ? `number ${token.value}`
+                : token.type === "boolean"
+                    ? `boolean ${token.value}`
+                    : token.type;
+}
+function tokenizeWhenClause(expression) {
+    const tokens = [];
+    let index = 0;
+    while (index < expression.length) {
+        const char = expression[index];
+        if (/\s/.test(char)) {
+            index += 1;
+            continue;
+        }
+        const pair = expression.slice(index, index + 2);
+        if (pair === "&&" || pair === "||" || pair === "==" || pair === "!=") {
+            tokens.push({ type: pair });
+            index += 2;
+            continue;
+        }
+        if (char === "!" || char === "(" || char === ")") {
+            tokens.push({ type: char });
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            const quote = char;
+            index += 1;
+            let value = "";
+            while (index < expression.length) {
+                const next = expression[index];
+                if (next === "\\") {
+                    const escaped = expression[index + 1];
+                    if (escaped === undefined) {
+                        throw new Error("Unterminated string literal");
+                    }
+                    value += escaped;
+                    index += 2;
+                    continue;
+                }
+                if (next === quote) {
+                    index += 1;
+                    tokens.push({ type: "string", value });
+                    value = "";
+                    break;
+                }
+                value += next;
+                index += 1;
+            }
+            if (value !== "") {
+                throw new Error("Unterminated string literal");
+            }
+            continue;
+        }
+        const numberMatch = expression.slice(index).match(/^\d+(?:\.\d+)?/);
+        if (numberMatch) {
+            tokens.push({ type: "number", value: Number(numberMatch[0]) });
+            index += numberMatch[0].length;
+            continue;
+        }
+        const identifierMatch = expression
+            .slice(index)
+            .match(/^[A-Za-z_][A-Za-z0-9_.-]*/);
+        if (identifierMatch) {
+            const value = identifierMatch[0];
+            if (value === "true" || value === "false") {
+                tokens.push({ type: "boolean", value: value === "true" });
+            }
+            else {
+                tokens.push({ type: "identifier", value });
+            }
+            index += value.length;
+            continue;
+        }
+        throw new Error(`Unexpected character ${JSON.stringify(char)}`);
+    }
+    tokens.push({ type: "eof" });
+    return tokens;
+}
+export function parseWhenClause(expression) {
+    return new WhenParser(tokenizeWhenClause(expression)).parse();
+}
+export function evaluateWhenClause(expression, lookup) {
+    const parsed = typeof expression === "string" ? parseWhenClause(expression) : expression;
+    return Boolean(evaluateExpression(parsed, lookup));
+}
+function evaluateExpression(expression, lookup) {
+    switch (expression.type) {
+        case "identifier":
+            return lookup(expression.name);
+        case "literal":
+            return expression.value;
+        case "unary":
+            return !Boolean(evaluateExpression(expression.operand, lookup));
+        case "binary": {
+            if (expression.operator === "&&") {
+                return (Boolean(evaluateExpression(expression.left, lookup)) &&
+                    Boolean(evaluateExpression(expression.right, lookup)));
+            }
+            if (expression.operator === "||") {
+                return (Boolean(evaluateExpression(expression.left, lookup)) ||
+                    Boolean(evaluateExpression(expression.right, lookup)));
+            }
+            const left = evaluateExpression(expression.left, lookup);
+            const right = evaluateExpression(expression.right, lookup);
+            return expression.operator === "==" ? left === right : left !== right;
+        }
+    }
+}
+export class ContextKeyService extends EventDispatcher {
+    #values = new Map();
+    #parsedExpressions = new Map();
+    #version = $state(0);
+    constructor(initialValues = {}) {
+        super();
+        for (const [key, value] of Object.entries(initialValues)) {
+            this.#values.set(key, value);
+        }
+    }
+    get(key) {
+        this.#version;
+        return this.#values.get(key);
+    }
+    set(key, value) {
+        if (this.#values.get(key) === value && this.#values.has(key)) {
+            return;
+        }
+        this.#values.set(key, value);
+        this.bump([key]);
+    }
+    reset(key) {
+        if (!this.#values.delete(key)) {
+            return;
+        }
+        this.bump([key]);
+    }
+    evaluate(expression) {
+        this.#version;
+        if (!expression?.trim()) {
+            return true;
+        }
+        try {
+            const parsed = this.#parsedExpressions.get(expression) ?? parseWhenClause(expression);
+            this.#parsedExpressions.set(expression, parsed);
+            return evaluateWhenClause(parsed, (key) => this.#values.get(key));
+        }
+        catch {
+            return false;
+        }
+    }
+    createScopedKey(scope, key, defaultValue) {
+        const scopedKey = `${scope}.${key}`;
+        if (defaultValue !== undefined) {
+            this.set(scopedKey, defaultValue);
+        }
+        return {
+            key: scopedKey,
+            get: () => this.get(scopedKey),
+            set: (value) => this.set(scopedKey, value),
+            reset: () => this.reset(scopedKey),
+        };
+    }
+    bump(keys) {
+        this.#version += 1;
+        this.emit("change", { keys });
+    }
+}

package/dist/context.svelte.d.ts

@@ -0,0 +1,247 @@
+import { Workspace } from "./workspace.svelte";
+import { TFile, Vault, type AppDatabase, type DataAdapter, type VaultSession } from "./storage";
+import { AppSettings } from "./settings.svelte";
+import type { Extension } from "@codemirror/state";
+import { PluginManager } from "./plugin-manager";
+import { Configuration } from "./configuration.svelte";
+import { CommandManager, Keymap, Scope, type UserEvent } from "./command.svelte";
+import { MetadataCache } from "./cache.svelte";
+import type { MarkdownDirectiveRenderer, MarkdownPostProcessor, MarkdownViewMenuItemProvider } from "./markdown";
+import { type Logger } from "./logging";
+import type { Component } from "./view.svelte";
+import { MetadataTypeManager } from "./metadata.svelte";
+import type { EditorSuggest } from "./suggest";
+import { FileManager } from "./file-manager";
+import { EmbedRegistry } from "./embed-registry";
+import type { OpenViewState } from "./workspace.svelte";
+import { LocalizationManager } from "./localization-manager.svelte";
+import { NotificationManager } from "./notifications";
+import { type TelemetryService } from "./telemetry";
+import { LanguageServiceManager } from "./language-service";
+import { ContextKeyService } from "./context-keys.svelte";
+import { StatusBarManager } from "./status-bar.svelte";
+import { AppUrlService } from "./app-url";
+import { WorkspaceTrustService } from "./workspace-trust";
+import { DefaultPluginDistributionManager, type DefaultPluginDistributionManagerOptions } from "./plugin-distribution";
+import type { PluginDependencyResolverFactory } from "./plugin-dependency-resolver";
+import type { PluginAssetServer } from "./plugin-asset-server";
+import { SearchDocumentProviderRegistry } from "./search-document-provider";
+import { DailyDocumentProviderRegistry } from "./daily-document-provider";
+import { AppToolRegistry } from "./agent-tools";
+import { MarkdownExtensionRegistry } from "./markdown-extension-registry";
+import { MarkdownFileSurfaceRegistry } from "./markdown-file-surface-registry";
+export interface AppWorkspaceShellApplicationProperties {
+    /** Application name shown by the shell's About surface. */
+    name?: string;
+    /** Optional application logo. Use `null` to fall back to the shell icon. */
+    logoUrl?: string | null;
+    buildTime?: string | null;
+    commitHash?: string;
+    copyright?: string;
+}
+/** Host-owned metadata and minimal static chrome for the workspace shell. */
+export interface AppWorkspaceShellProperties {
+    application?: AppWorkspaceShellApplicationProperties;
+    /** Enable design-core's notification center and status affordance. */
+    notifications?: boolean;
+}
+/**
+ * Bootstrap dependencies required to construct an {@link App} instance.
+ *
+ * @public
+ */
+export type AppStateProperties = {
+    version: string;
+    configPath: string;
+    adapter?: DataAdapter;
+    session?: VaultSession;
+    appDatabase?: AppDatabase;
+    safeMode?: AppSafeModeState;
+    createCommunityPluginDependencyResolver?: PluginDependencyResolverFactory;
+    pluginAssetServer?: PluginAssetServer;
+    pluginDistributionOptions?: AppPluginDistributionOptions;
+    workspaceShell?: AppWorkspaceShellProperties;
+    markdownRenderer: (markdown: string, el: HTMLElement, sourcePath: string, component: Component) => Promise<void>;
+};
+export type AppPluginDistributionOptions = Omit<DefaultPluginDistributionManagerOptions, "adapter" | "appVersion" | "platform" | "workspaceTrusted" | "pluginManager">;
+export type ExtType = Extension | ((context: Record<string, any>) => Extension);
+/**
+ * Details about the last startup failure that caused safe mode to activate.
+ *
+ * @public
+ */
+export interface AppSafeModeFailure {
+    task: string | null;
+    message: string;
+    detail: string;
+    pluginId: string | null;
+}
+/**
+ * Safe mode flags that disable risky startup behavior after a failed launch.
+ *
+ * @public
+ */
+export interface AppSafeModeState {
+    active: boolean;
+    disableCommunityPlugins: boolean;
+    disableOptionalCorePlugins: boolean;
+    skipLayoutRestore: boolean;
+    disableNotebookExecution: boolean;
+    lastStartupFailure: AppSafeModeFailure | null;
+}
+/**
+ * Create the default safe mode state used for a normal startup.
+ *
+ * @public
+ */
+export declare function createDefaultAppSafeModeState(): AppSafeModeState;
+/**
+ * Ephemeral renderer state shared while processing a markdown view.
+ *
+ * @public
+ */
+export declare 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 declare class SecretStorage {
+    private secrets;
+    /**
+     * Store or replace a secret value.
+     *
+     * @param id - Stable identifier for the secret.
+     * @param secret - Raw secret value to store.
+     * @public
+     */
+    setSecret(id: string, secret: string): void;
+    /**
+     * 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: string): string | null;
+    /**
+     * List the ids of all stored secrets.
+     *
+     * @public
+     */
+    listSecrets(): string[];
+}
+/**
+ * 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 declare class App {
+    readonly props: AppStateProperties;
+    readonly i18n: LocalizationManager;
+    readonly workspace: Workspace;
+    readonly vault: Vault;
+    readonly appDatabase: AppDatabase;
+    readonly session?: VaultSession;
+    readonly safeMode: AppSafeModeState;
+    plugins: PluginManager;
+    scope: Scope;
+    keymap: Keymap;
+    readonly settings: AppSettings;
+    readonly editors: Map<string, Set<ExtType>>;
+    readonly editorSuggest: Map<string, Set<EditorSuggest<any>>>;
+    readonly configuration: Configuration;
+    readonly fileManager: FileManager;
+    readonly contextKeys: ContextKeyService;
+    readonly statusBar: StatusBarManager;
+    readonly urls: AppUrlService;
+    readonly workspaceTrust: WorkspaceTrustService;
+    readonly pluginDistribution: DefaultPluginDistributionManager;
+    mardownPostProcessor: Array<MarkdownPostProcessor>;
+    mardownCodeBlockPostProcessor: Record<string, Array<MarkdownPostProcessor>>;
+    markdownDirectiveRenderers: Record<string, MarkdownDirectiveRenderer>;
+    readonly markdownViewMenuItems: Set<MarkdownViewMenuItemProvider>;
+    metadataTypeManager: MetadataTypeManager;
+    commands: CommandManager;
+    settingsOpen: boolean;
+    settingsTabId: string | null;
+    metadataCache: MetadataCache;
+    embedRegistry: EmbedRegistry;
+    readonly searchDocumentProviders: SearchDocumentProviderRegistry;
+    readonly dailyDocumentProviders: DailyDocumentProviderRegistry;
+    readonly indexProjections: import("./storage/index-projection").IndexProjectionRegistry;
+    readonly agentTools: AppToolRegistry;
+    readonly markdownExtensions: MarkdownExtensionRegistry;
+    readonly markdownFileSurfaces: MarkdownFileSurfaceRegistry;
+    readonly agentSkills: import("./agent-skills").AppSkillRegistry;
+    readonly agentSlashCommands: import("./agent-skills").AppSlashCommandRegistry;
+    readonly agentResultViews: import("./agent-result-views").AppResultViewRegistry;
+    lastEvent: UserEvent | null;
+    renderContext: RenderContext;
+    secretStorage: SecretStorage;
+    notifications: NotificationManager;
+    telemetry: TelemetryService;
+    readonly languageServices: LanguageServiceManager;
+    get internalPlugins(): {
+        plugins: Record<string, {
+            manifest: import("./plugin").PluginManifest;
+        }>;
+        getEnabledPluginById: (pluginId: string) => any | null;
+    };
+    readonly logger: Logger;
+    /**
+     * Create the application service container for a mounted vault session.
+     *
+     * @param props - Runtime services and adapters required to bootstrap the app.
+     * @public
+     */
+    constructor(props: AppStateProperties);
+    private initializeContextKeys;
+    private syncWorkspaceContextKeys;
+    setWorkspaceTrusted(trusted: boolean): void;
+    openFile(file: TFile, openState?: OpenViewState): Promise<void>;
+    editorExtensions(viewType: string, context?: Record<string, any>): Extension[];
+    /**
+     * 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: ExtType, viewType?: string): void;
+    unregisterEditorExtension(extension: ExtType, viewType?: string): void;
+    registerEditorSuggest(suggest: EditorSuggest<any>, viewType?: string): void;
+    unregisterEditorSuggest(suggest: EditorSuggest<any>, viewType?: string): void;
+    registerMarkdownPostProcessor(postProcessor: MarkdownPostProcessor): void;
+    unregisterMarkdownPostProcessor(postProcessor: MarkdownPostProcessor): void;
+    registerMarkdownCodeBlockProcessor(language: string, postProcessor: MarkdownPostProcessor): void;
+    unregisterMarkdownCodeBlockProcessor(language: string, postProcessor: MarkdownPostProcessor): void;
+    registerMarkdownDirectiveRenderer(directive: string, renderer: MarkdownDirectiveRenderer): void;
+    unregisterMarkdownDirectiveRenderer(directive: string): void;
+    registerMarkdownViewMenuItem(provider: MarkdownViewMenuItemProvider): void;
+    unregisterMarkdownViewMenuItem(provider: MarkdownViewMenuItemProvider): void;
+    get version(): string;
+    get isDarkMode(): boolean;
+    loadLocalStorage(key: string): string | null;
+    saveLocalStorage(key: string, data: string): void;
+    setting(id: "options" | "core-plugins" | "community-plugins"): import("./settings.svelte").SettingGroup;
+}
+export type AppState = App;
+declare global {
+    var app: App;
+}
+export declare function setApplicationState(props: AppStateProperties): AppState;
+export { getApplicationCompatibility, installApplicationCompatibility, resolveApplication } from "./application-compatibility";
+export { provideApplicationState, useApplicationState } from "./application-state.svelte";