@lapis-notes/api 0.1.0

package/dist/language-service/virtual-document.js

@@ -0,0 +1,45 @@
+export function createVirtualDocument(document) {
+    return {
+        ...document,
+        version: document.version ?? 0,
+    };
+}
+export function offsetToLanguageServicePosition(text, offset) {
+    const boundedOffset = Math.max(0, Math.min(offset, text.length));
+    let line = 0;
+    let lineStart = 0;
+    for (let index = 0; index < boundedOffset; index += 1) {
+        if (text[index] === "\n") {
+            line += 1;
+            lineStart = index + 1;
+        }
+    }
+    return { line, character: boundedOffset - lineStart };
+}
+export function languageServicePositionToOffset(text, position) {
+    const targetLine = Math.max(0, position.line);
+    const targetCharacter = Math.max(0, position.character);
+    let line = 0;
+    let lineStart = 0;
+    for (let index = 0; index < text.length && line < targetLine; index += 1) {
+        if (text[index] === "\n") {
+            line += 1;
+            lineStart = index + 1;
+        }
+    }
+    const lineEnd = text.indexOf("\n", lineStart);
+    const end = lineEnd === -1 ? text.length : lineEnd;
+    return Math.min(lineStart + targetCharacter, end);
+}
+export function languageServiceRangeToOffsets(text, range) {
+    return {
+        from: languageServicePositionToOffset(text, range.start),
+        to: languageServicePositionToOffset(text, range.end),
+    };
+}
+export function offsetsToLanguageServiceRange(text, from, to) {
+    return {
+        start: offsetToLanguageServicePosition(text, from),
+        end: offsetToLanguageServicePosition(text, to),
+    };
+}

package/dist/language-service/worker-protocol.d.ts

@@ -0,0 +1,63 @@
+import type { LanguageServiceCodeAction, LanguageServiceCompletionList, LanguageServiceDiagnostic, LanguageServiceGlobalDeclaration, LanguageServiceHover, LanguageServiceLocation, LanguageServicePosition, LanguageServiceRange, VirtualDocument } from "./types";
+export type LanguageServiceWorkerRequest = {
+    type: "document/update";
+    document: VirtualDocument;
+    globals?: LanguageServiceGlobalDeclaration[];
+} | {
+    type: "diagnostics";
+    document: VirtualDocument;
+    globals?: LanguageServiceGlobalDeclaration[];
+    rules?: Record<string, unknown>;
+} | {
+    type: "completion";
+    document: VirtualDocument;
+    position: LanguageServicePosition;
+    globals?: LanguageServiceGlobalDeclaration[];
+} | {
+    type: "hover";
+    document: VirtualDocument;
+    position: LanguageServicePosition;
+    globals?: LanguageServiceGlobalDeclaration[];
+} | {
+    type: "definition";
+    document: VirtualDocument;
+    position: LanguageServicePosition;
+    globals?: LanguageServiceGlobalDeclaration[];
+} | {
+    type: "code-actions";
+    document: VirtualDocument;
+    range: LanguageServiceRange;
+    globals?: LanguageServiceGlobalDeclaration[];
+    rules?: Record<string, unknown>;
+};
+export type LanguageServiceWorkerResponse = {
+    type: "document/update";
+    ok: true;
+} | {
+    type: "diagnostics";
+    diagnostics: LanguageServiceDiagnostic[];
+} | {
+    type: "completion";
+    completions: LanguageServiceCompletionList | null;
+} | {
+    type: "hover";
+    hover: LanguageServiceHover | null;
+} | {
+    type: "definition";
+    locations: LanguageServiceLocation[];
+} | {
+    type: "code-actions";
+    actions: LanguageServiceCodeAction[];
+};
+export interface LanguageServiceWorkerEnvelope<T> {
+    id: string;
+    payload: T;
+}
+export type LanguageServiceWorkerMessage = LanguageServiceWorkerEnvelope<LanguageServiceWorkerRequest>;
+export type LanguageServiceWorkerResult = (LanguageServiceWorkerEnvelope<LanguageServiceWorkerResponse> & {
+    ok: true;
+}) | {
+    id: string;
+    ok: false;
+    error: string;
+};

package/dist/language-service/worker-protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/language-service/worker-provider.d.ts

@@ -0,0 +1,9 @@
+import type { LanguageServiceWorkerRequest, LanguageServiceWorkerResponse } from "./worker-protocol";
+export declare class LanguageServiceWorkerClient {
+    private readonly worker;
+    private readonly pending;
+    constructor(worker: Worker);
+    request(payload: LanguageServiceWorkerRequest): Promise<LanguageServiceWorkerResponse>;
+    dispose(): void;
+    private readonly handleMessage;
+}

package/dist/language-service/worker-provider.js

@@ -0,0 +1,38 @@
+export class LanguageServiceWorkerClient {
+    worker;
+    pending = new Map();
+    constructor(worker) {
+        this.worker = worker;
+        worker.addEventListener("message", this.handleMessage);
+    }
+    request(payload) {
+        const id = crypto.randomUUID();
+        const message = { id, payload };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.worker.postMessage(message);
+        });
+    }
+    dispose() {
+        this.worker.removeEventListener("message", this.handleMessage);
+        this.worker.terminate();
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error("Language service worker disposed"));
+        }
+        this.pending.clear();
+    }
+    handleMessage = (event) => {
+        const response = event.data;
+        const pending = this.pending.get(response.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(response.id);
+        if (response.ok) {
+            pending.resolve(response.payload);
+        }
+        else {
+            pending.reject(new Error(response.error));
+        }
+    };
+}

package/dist/lapis-extension.d.ts

@@ -0,0 +1,244 @@
+import type { Command, Hotkey } from "./command.svelte";
+import type { HostedPluginCapability } from "./plugin-capability-facade";
+import type { LanguageServiceProviderMetadata } from "./language-service";
+export type LapisPluginClassification = "obsidian-compatible" | "lapis-extension" | "hybrid";
+export type LapisExtensionKind = "workspace" | "browserWorker" | "trustedDesktop";
+export type LapisExtensionRuntimeHost = "workspace" | "desktop";
+export type LapisPluginModuleFormat = "esm" | "commonjs" | "node-esm";
+export interface LapisRuntimeEntryDescriptor {
+    path: string;
+    format: LapisPluginModuleFormat;
+    fallbackPath?: string;
+    sharedDependencies?: string[];
+    requiresReloadOnUpdate?: boolean;
+}
+export interface LapisRuntimeEntryMap {
+    workspace?: LapisRuntimeEntryDescriptor;
+    electronRenderer?: LapisRuntimeEntryDescriptor;
+    electronSidecar?: LapisRuntimeEntryDescriptor;
+    desktop?: LapisRuntimeEntryDescriptor;
+    trustedDesktop?: LapisRuntimeEntryDescriptor;
+}
+export type LapisExtensionPermission = "vault.read" | "vault.write" | "plugin.data" | "commands" | "notices" | "settings.read" | "metadata.query" | "events" | "logging";
+export interface LapisCommandContribution {
+    command: string;
+    title: string;
+    category?: string;
+    icon?: string;
+    when?: string;
+    hotkeys?: Hotkey[];
+    activationEvent?: string;
+    argumentSchema?: Record<string, unknown>;
+}
+export interface LapisConfigurationContribution {
+    id?: string;
+    title?: string;
+    properties?: Record<string, unknown>;
+}
+export interface LapisLanguageContribution {
+    id: string;
+    aliases?: string[];
+    extensions?: string[];
+    filenames?: string[];
+    mimetypes?: string[];
+}
+export interface LapisViewContribution {
+    id: string;
+    name: string;
+    icon?: string;
+    side?: "left" | "right";
+    activationEvent?: string;
+}
+export interface LapisEditorViewContribution {
+    id: string;
+    viewType?: string;
+    label: string;
+    description?: string;
+    filenamePatterns: string[];
+    priority?: "default" | "option" | "exclusive";
+    pluginId?: string;
+    source?: "core" | "plugin" | "manifest" | "compat";
+    activationEvent?: string;
+}
+export interface LapisServiceContribution {
+    id: string;
+    service: string;
+    languages?: string[];
+    runtime?: LapisExtensionRuntimeHost | string;
+    priority?: number;
+    capabilities?: Record<string, boolean>;
+    activationEvent?: string;
+    permissions?: LapisExtensionPermission[];
+}
+export interface LapisNotebookRendererContribution {
+    id: string;
+    displayName: string;
+    mimeTypes?: string[];
+    activationEvent?: string;
+}
+export interface LapisMarkdownPostProcessorContribution {
+    id: string;
+    language?: string;
+    sortOrder?: number;
+    activationEvent?: string;
+}
+export interface LapisStatusBarItemContribution {
+    id: string;
+    text?: string;
+    icon?: string;
+    alignment?: "left" | "right";
+    priority?: number;
+    tooltip?: string;
+    command?: string;
+    when?: string;
+}
+export interface LapisExtensionContributions {
+    commands?: LapisCommandContribution[];
+    configuration?: LapisConfigurationContribution[];
+    languages?: LapisLanguageContribution[];
+    views?: LapisViewContribution[];
+    editorViews?: LapisEditorViewContribution[];
+    services?: LapisServiceContribution[];
+    notebookRenderers?: LapisNotebookRendererContribution[];
+    markdownPostProcessors?: LapisMarkdownPostProcessorContribution[];
+    statusBarItems?: LapisStatusBarItemContribution[];
+}
+export interface LapisExtensionManifest {
+    manifestVersion: 1;
+    extensionKind?: LapisExtensionKind[];
+    contributes?: LapisExtensionContributions;
+    activationEvents?: string[];
+    runtime?: {
+        workspace?: string;
+        desktop?: string;
+        trustedDesktop?: string;
+        entries?: LapisRuntimeEntryMap;
+        sharedDependencies?: {
+            workspace?: string[];
+            electronRenderer?: string[];
+            electronSidecar?: string[];
+            desktop?: string[];
+        };
+        compatibilityOverrides?: {
+            deprecatedHostModules?: {
+                workspace?: string[];
+                electronRenderer?: string[];
+                electronSidecar?: string[];
+                desktop?: string[];
+                trustedDesktop?: string[];
+            };
+        };
+    };
+    database?: {
+        /** Query-native access avoids the one-release full MetadataCache snapshot lease. */
+        metadataAccess?: "queries" | "snapshot";
+    };
+    permissions?: LapisExtensionPermission[];
+    source?: "community" | "official" | "system";
+    enabled?: boolean;
+    locked?: boolean;
+    enabledByDefault?: boolean;
+}
+export type LapisBuiltInContributionKind = keyof Required<LapisExtensionContributions>;
+export type LapisContributionKind = LapisBuiltInContributionKind | (string & {});
+export interface LapisContributionIndexEntry<T = unknown> {
+    pluginId: string;
+    kind: LapisContributionKind;
+    id: string;
+    manifestPath: string;
+    contribution: T;
+    activationEvent?: string;
+    runtimeHost?: string;
+    requiredPermissions: LapisExtensionPermission[];
+    state: "valid" | "invalid";
+    diagnostics: string[];
+}
+interface LapisContributionPointIndexOptions {
+    pluginId: string;
+    manifestPath: string;
+    value: unknown;
+}
+export interface LapisContributionPointDescriptor {
+    kind: LapisBuiltInContributionKind;
+    manifestInstallable: boolean;
+    activationEvent?: (entry: LapisContributionIndexEntry) => string | undefined;
+    index(options: LapisContributionPointIndexOptions): LapisContributionIndexEntry[];
+}
+export interface LapisIndexedExtension {
+    pluginId: string;
+    name?: string;
+    source: "community" | "official" | "system";
+    classification: LapisPluginClassification;
+    manifestPath: string;
+    activationEvents: string[];
+    runtime: LapisExtensionManifest["runtime"];
+    permissions: LapisExtensionPermission[];
+    requestedCapabilities: HostedPluginCapability[];
+    grantedCapabilities: HostedPluginCapability[];
+    enabled: boolean;
+    locked: boolean;
+    enabledByDefault: boolean;
+    activationErrors: string[];
+    contributions: LapisContributionIndexEntry[];
+    privileges: string[];
+}
+export interface LapisServiceProviderRegistration {
+    pluginId: string;
+    service: string;
+    id: string;
+    metadata?: LanguageServiceProviderMetadata | Record<string, unknown>;
+    provider: unknown;
+    dispose?: () => void | Promise<void>;
+}
+export interface LapisSystemServiceProviderRegistration {
+    id: string;
+    service: string;
+    metadata?: LanguageServiceProviderMetadata | Record<string, unknown>;
+    provider?: unknown;
+    createProvider?: (app: import("./context.svelte").App) => unknown;
+    dispose?: () => void | Promise<void>;
+}
+export interface LapisSystemExtensionRegistration {
+    manifest: {
+        id: string;
+        name: string;
+        author?: string;
+        version: string;
+        minAppVersion?: string;
+        description?: string;
+        lapis: LapisExtensionManifest;
+    };
+    plugin?: new (app: import("./context.svelte").App) => import("./plugin").Plugin;
+    basePath?: string;
+    enabledByDefault?: boolean;
+    locked?: boolean;
+    privileges?: string[];
+    serviceProviders?: LapisSystemServiceProviderRegistration[];
+}
+export declare function isLapisManifest(value: unknown): value is LapisExtensionManifest;
+export declare function classifyLapisPlugin(manifest: {
+    lapis?: unknown;
+}, options?: {
+    hasMainJs?: boolean;
+}): LapisPluginClassification;
+export declare function validateLapisManifest(pluginId: string, lapis: unknown): string[];
+export declare function buildLapisContributionIndex(options: {
+    pluginId: string;
+    name?: string;
+    manifestPath: string;
+    classification: LapisPluginClassification;
+    source: "community" | "official" | "system";
+    lapis: LapisExtensionManifest;
+    grantedCapabilities: HostedPluginCapability[];
+    requestedCapabilities?: HostedPluginCapability[];
+    privileges?: string[];
+}): LapisIndexedExtension;
+export declare function getLapisContributionPointDescriptor(kind: string): LapisContributionPointDescriptor | undefined;
+export declare function getLapisContributionPointDescriptors(): readonly LapisContributionPointDescriptor[];
+export declare function getLapisWorkspaceEntry(lapis: LapisExtensionManifest | undefined): string | null;
+export declare function getLapisDesktopEntry(lapis: LapisExtensionManifest | undefined): string | null;
+export declare function permissionsToCapabilities(permissions: readonly string[] | undefined): HostedPluginCapability[];
+export declare function activationEventForContribution(pluginId: string, entry: LapisContributionIndexEntry): string | undefined;
+export declare function commandContributionToCommand(contribution: LapisCommandContribution): Command;
+export declare function normalizeManifestCommandId(pluginId: string, commandId: string): string;
+export {};