@lapis-notes/api 0.1.0

package/dist/plugin-manager.d.ts

@@ -0,0 +1,306 @@
+import type { App } from "./context.svelte";
+import type { DataAdapter } from "./storage/fs";
+import { type NativeDesktopBridge } from "./storage/desktop-native";
+import { type LapisIndexedExtension, type LapisPluginClassification, type LapisServiceProviderRegistration, type LapisSystemExtensionRegistration } from "./lapis-extension";
+import { type PluginExecutionHostId, type SelectedPluginRuntimeEntry } from "./plugin-runtime-entry";
+import { Plugin, type PluginConstructor, type PluginManifest, type PluginSource } from "./plugin";
+import { type HostedPluginCapability } from "./plugin-capability-facade";
+import { type PluginDependencyResolver, type PluginDependencyResolverFactory } from "./plugin-dependency-resolver";
+import { type PluginAssetServer } from "./plugin-asset-server";
+import type { PluginProvenance } from "./plugin-distribution/types";
+import { EventDispatcher } from "./events";
+export interface PluginLoader {
+    pluginsPath: string;
+}
+export interface StaticPluginRegistration {
+    plugin: PluginConstructor;
+    required?: boolean;
+    enabledByDefault?: boolean;
+    distribution?: CorePluginDistribution;
+    styles?: CorePluginStyles;
+}
+/** @deprecated Use {@link StaticPluginRegistration}. */
+export type CorePluginRegistration = StaticPluginRegistration;
+export type PluginProfile = readonly (PluginConstructor | StaticPluginRegistration)[];
+export type CorePluginDistribution = "bundled" | "first-party-external";
+export type CorePluginStyles = string | (() => string | Promise<string>);
+export interface CommunityPluginEvaluationRequest {
+    pluginId: string;
+    pluginPath: string;
+    modulePath: string;
+    manifest: PluginManifest;
+    selectedRuntime?: SelectedPluginRuntimeEntry | null;
+}
+export interface CommunityPluginExecutionHost {
+    readonly id: string;
+    hostIdForManifest?(manifest: PluginManifest): string;
+    registerDependencies?(deps: Record<string, any>): void;
+    evaluate(request: CommunityPluginEvaluationRequest): Promise<unknown>;
+}
+export interface PluginManagerOptions {
+    communityPluginHost?: CommunityPluginExecutionHost;
+    createCommunityPluginDependencyResolver?: PluginDependencyResolverFactory;
+    pluginAssetServer?: PluginAssetServer;
+}
+export interface PluginDataAliasMigration {
+    fromPluginId: string;
+    toPluginId: string;
+    removeSource?: boolean;
+}
+export interface PluginLoadProgress {
+    id: string;
+    name: string;
+    index: number;
+    total: number;
+}
+export interface PluginLoadOptions {
+    communityPlugins?: "configured" | "disabled";
+    optionalCorePlugins?: "configured" | "disabled";
+    onProgress?: (progress: PluginLoadProgress) => void;
+}
+export interface CommunityPluginDiagnostics {
+    pluginId: string;
+    name?: string;
+    version?: string;
+    author?: string;
+    description?: string;
+    source: PluginSource;
+    provenance: PluginProvenance;
+    classification: LapisPluginClassification;
+    hostMode: string;
+    activationMode: "code" | "manifest-only" | "not-activated";
+    activationTrigger: string | null;
+    selectedRuntimeHost: PluginExecutionHostId | null;
+    selectedRuntimeEntry: string | null;
+    moduleFormat: "esm" | "commonjs" | "node-esm" | null;
+    fallbackRuntimeEntry: string | null;
+    fallbackUsed: boolean;
+    requiresReloadOnUpdate: boolean;
+    sharedDependencies: string[];
+    usedSharedDependencies: string[];
+    undeclaredSharedDependencies: string[];
+    missingSharedDependencies: string[];
+    deprecatedSharedDependencies: string[];
+    privateSharedDependencies: string[];
+    assetUrlMode: "web" | "electron" | "custom" | null;
+    pluginAssetUrl: string | null;
+    requestedCapabilities: HostedPluginCapability[];
+    grantedCapabilities: HostedPluginCapability[];
+    privileges: string[];
+    indexedContributionCount: number;
+    contributionDiagnostics: string[];
+    lastFailureMessage: string | null;
+    state: string;
+}
+export interface CorePluginListEntry {
+    manifest: PluginManifest;
+    enabled: boolean;
+    required: boolean;
+    source: PluginSource;
+    provenance: PluginProvenance;
+    distribution: CorePluginDistribution;
+    errorMessage: string | null;
+}
+export declare class RendererCommunityPluginExecutionHost implements CommunityPluginExecutionHost {
+    private readonly adapter;
+    readonly id = "renderer";
+    private readonly resolver;
+    constructor(adapter: DataAdapter, dependenciesOrResolver: Record<string, any> | PluginDependencyResolver);
+    evaluate(request: CommunityPluginEvaluationRequest): Promise<unknown>;
+    private requireDependency;
+    private wrapDependencyForRequire;
+    private resolveLocalModulePath;
+    private readPluginModuleSources;
+}
+export declare class RendererEsmPluginExecutionHost implements CommunityPluginExecutionHost {
+    private readonly adapter;
+    private readonly pluginAssetServer;
+    private readonly diagnostics;
+    readonly id = "renderer";
+    private readonly resolver;
+    constructor(adapter: DataAdapter, pluginAssetServer: PluginAssetServer, dependenciesOrResolver: Record<string, any> | PluginDependencyResolver, diagnostics?: {
+        onPluginAssetUrl?: (pluginId: string, url: string) => void;
+    });
+    evaluate(request: CommunityPluginEvaluationRequest): Promise<unknown>;
+    registerDependencies(_deps: Record<string, any>): void;
+    private prepareDependencies;
+}
+export declare class HybridCommunityPluginExecutionHost implements CommunityPluginExecutionHost {
+    private readonly commonJsHost;
+    private readonly esmHost;
+    private readonly diagnostics;
+    readonly id: string;
+    constructor(commonJsHost: CommunityPluginExecutionHost, esmHost: RendererEsmPluginExecutionHost, diagnostics?: {
+        onFallbackUsed?: (pluginId: string, fallbackPath: string) => void;
+    });
+    hostIdForManifest(manifest: PluginManifest): string;
+    registerDependencies(deps: Record<string, any>): void;
+    evaluate(request: CommunityPluginEvaluationRequest): Promise<unknown>;
+}
+export declare class NativeDesktopCommunityPluginExecutionHost implements CommunityPluginExecutionHost {
+    private readonly adapter;
+    private readonly bridge;
+    readonly id = "electron-plugin-sidecar";
+    private prepared;
+    private readonly contextId;
+    private readonly rootPath?;
+    private readonly dependencies;
+    private readonly rendererHost;
+    constructor(adapter: DataAdapter, bridge?: NativeDesktopBridge, createRendererDependencyResolver?: PluginDependencyResolverFactory);
+    evaluate(request: CommunityPluginEvaluationRequest): Promise<unknown>;
+    hostIdForManifest(manifest: PluginManifest): string;
+    registerDependencies(deps: Record<string, any>): void;
+    private shouldUseSidecar;
+    private prepare;
+    private activate;
+    private deactivate;
+}
+export interface PluginEvents {
+    "plugins-loaded": [];
+    "css-change": [];
+    "plugin-loaded": [plugin: Plugin];
+    "plugin-enabled": [plugin: Plugin];
+    "plugin-disabled": [plugin: Plugin];
+    "community-plugin-config-pruned": [pluginIds: string[]];
+    "plugin-error": [id: string, message: string, error?: any];
+}
+export declare class PluginManager extends EventDispatcher<PluginEvents> {
+    #private;
+    readonly app: App;
+    readonly pluginsPath: string;
+    readonly adapter: DataAdapter;
+    readonly plugins: Map<string, Plugin>;
+    dependencies: Record<string, any>;
+    constructor(app: App, pluginsPath: string, adapter: DataAdapter, options?: PluginManagerOptions);
+    getPluginFolder(): string;
+    get corePlugins(): Plugin[];
+    get communityPlugins(): Plugin[];
+    isPluginEnabled(pluginId: string): boolean;
+    get corePluginEntries(): CorePluginListEntry[];
+    get communityPluginHostId(): string;
+    get pluginAssetServer(): PluginAssetServer | undefined;
+    get communityPluginDiagnostics(): CommunityPluginDiagnostics[];
+    get lapisExtensions(): LapisIndexedExtension[];
+    get systemExtensions(): LapisIndexedExtension[];
+    getLapisExtension(pluginId: string): LapisIndexedExtension | null;
+    getLapisContributionDiagnostics(pluginId: string): string[];
+    getCommunityPluginDiagnostics(pluginId: string): CommunityPluginDiagnostics | null;
+    registerDependencies(deps: Record<string, any>): void;
+    migratePluginDataAliases(migrations: PluginDataAliasMigration[]): Promise<string[]>;
+    registerStaticPlugins(profile: PluginProfile): void;
+    /** @deprecated Use {@link registerStaticPlugins}. */
+    registerCorePlugins(profile: PluginProfile): void;
+    private registerCorePluginManifestContributions;
+    registerSystemExtensions(registrations: LapisSystemExtensionRegistration[]): void;
+    loadPlugins(options?: PluginLoadOptions): Promise<void>;
+    get enabledPlugins(): string[];
+    getBasesViewRegistrations(): Map<string, any>;
+    registerBasesView(pluginId: string, viewId: string, registration: any): boolean;
+    unregisterBasesView(pluginId: string, viewId: string): boolean;
+    registerLapisServiceProvider(registration: LapisServiceProviderRegistration): () => void;
+    private getLapisServiceContribution;
+    private createLanguageServiceProviderMetadata;
+    getEnabledInternalPluginById(pluginId: string): any | null;
+    get internalPlugins(): {
+        plugins: Record<string, {
+            manifest: PluginManifest;
+        }>;
+        getEnabledPluginById: (pluginId: string) => any | null;
+    };
+    private getPluginStatePath;
+    private refreshInstalledPluginProvenance;
+    private resolveExternalPluginSource;
+    private readPluginListConfig;
+    private readCorePluginStateConfig;
+    private savePluginListConfig;
+    private saveCorePluginStateConfig;
+    private saveCommunityPluginState;
+    private saveCorePluginState;
+    flushPendingConfigWrites(): void;
+    private isCorePluginEnabled;
+    private pruneMissingConfiguredCommunityPlugins;
+    private enableConfiguredIndexedExtensions;
+    loadPlugin(pluginPath: string, options?: {
+        loadDeferredRuntime?: boolean;
+        provenance?: PluginProvenance;
+        source?: PluginSource;
+    }): Promise<Plugin | null>;
+    private registerPlugin;
+    private syncLegacyPluginData;
+    enablePlugin(pluginId: string): Promise<boolean>;
+    disablePlugin(pluginId: string): Promise<boolean>;
+    restartPlugin(pluginId: string): Promise<boolean>;
+    private capturePluginOwnedLeaves;
+    private replacePluginOwnedLeaves;
+    private restorePluginOwnedLeaves;
+    private isVersionCompatible;
+    enableAllPlugins(...pluginIds: Array<string | string[]>): Promise<void>;
+    private loadPluginStyles;
+    private loadCorePluginStyles;
+    private unloadPluginCSS;
+    private loadPluginCSS;
+    private loadPluginCSSContent;
+    private preflightManifest;
+    private reportPluginError;
+    private isRuntimeSupported;
+    private getRequestedCapabilities;
+    private getInvalidRequiredCapabilities;
+    private getGrantedCapabilities;
+    private recordCommunityPluginDiagnostics;
+    private recordCommunityPluginFailure;
+    private updatePluginDiagnosticsFromPlugin;
+    private updateCommunityPluginDependencyDiagnostics;
+    private getCommunityPluginDependencyDiagnosticsForRecord;
+    private getCommunityPluginRuntimeExecutionDiagnosticsForRecord;
+    private recordPluginAssetUrlDiagnostics;
+    private recordPluginFallbackDiagnostics;
+    private isKnownHostDependency;
+    private getHostDependencyMetadata;
+    private readCommunityPluginModuleSources;
+    private indexCommunityManifest;
+    private enableManifestOnlyExtension;
+    private enableDeferredIndexedExtension;
+    private disableManifestOnlyExtension;
+    private disposeInstalledManifestContributions;
+    private installManifestCommand;
+    private installManifestConfiguration;
+    private installManifestStatusBarItem;
+    private installManifestEditorView;
+    private installManifestService;
+    private recordIndexedExtensionDiagnostics;
+    private syncPluginContextKeys;
+    activateByEvent(event: string, trigger?: string | null): Promise<boolean>;
+    activateForViewType(viewType: string): Promise<boolean>;
+    activateForService(serviceId: string): Promise<boolean>;
+    activateForLanguage(languageId: string): Promise<boolean>;
+    activateForPath(path: string): Promise<boolean>;
+    private activateIndexedExtensionsForWorkspace;
+    private activateDeferredIndexedExtension;
+    private shouldDeferManifestActivation;
+    private shouldDeferIndexedExtensionActivation;
+    private collectIndexedExtensionActivationEvents;
+    private syncIndexedExtensionActivation;
+    private matchingPathActivationEvents;
+    findLanguageIdsForPath(path: string): string[];
+    private instantiateSystemExtensionPlugin;
+    private createSystemExtensionManifest;
+    private getSystemExtensionManifestPath;
+    private storeSystemExtensionServiceProviders;
+    private getSystemExtensionServiceProviderRegistration;
+    private isManifestOnlyLapisExtension;
+    private hasIndexedExtensionCodeEntry;
+    private getSelectedCodeEntry;
+    private getSelectedCommunityModulePath;
+    private getSelectedLapisRuntimeEntry;
+    private getHostIdForManifest;
+    private getHostIdForIndexedExtension;
+    private getSelectedRuntimeEntryForManifest;
+    private getSelectedRuntimeEntryForIndexedExtension;
+    private selectRuntimeEntryForManifest;
+    private selectRuntimeEntryForIndexedExtension;
+    private supportsRendererEsm;
+    private getRequestedPluginExecutionHost;
+    private getRequestedPluginExecutionHostForHostId;
+    private resolveValidatedRuntimeEntryPath;
+    private pathExists;
+}