@lapis-notes/api 0.1.0

package/dist/lapis-extension.js

@@ -0,0 +1,591 @@
+export function isLapisManifest(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return value.manifestVersion === 1;
+}
+export function classifyLapisPlugin(manifest, options = {}) {
+    if (!isRecord(manifest.lapis)) {
+        return "obsidian-compatible";
+    }
+    if (options.hasMainJs || requiresObsidianMain(manifest.lapis)) {
+        return "hybrid";
+    }
+    return "lapis-extension";
+}
+export function validateLapisManifest(pluginId, lapis) {
+    const diagnostics = [];
+    if (!isRecord(lapis)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis metadata`);
+        return diagnostics;
+    }
+    if (lapis.manifestVersion !== 1) {
+        diagnostics.push(`Plugin ${pluginId} declares unsupported lapis.manifestVersion`);
+    }
+    if (lapis.extensionKind !== undefined &&
+        !isStringArray(lapis.extensionKind)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.extensionKind`);
+    }
+    if (lapis.activationEvents !== undefined &&
+        !isStringArray(lapis.activationEvents)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.activationEvents`);
+    }
+    if (lapis.permissions !== undefined && !isStringArray(lapis.permissions)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.permissions`);
+    }
+    else {
+        const invalidPermissions = normalizeStringArray(lapis.permissions).filter((permission) => permissionToCapability(permission) === null);
+        if (invalidPermissions.length) {
+            diagnostics.push(`Plugin ${pluginId} declares unknown lapis.permissions: ${invalidPermissions.join(", ")}`);
+        }
+    }
+    if (lapis.contributes !== undefined && !isRecord(lapis.contributes)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.contributes`);
+    }
+    if (lapis.database !== undefined) {
+        if (!isRecord(lapis.database)) {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.database`);
+        }
+        else if (lapis.database.metadataAccess !== undefined &&
+            lapis.database.metadataAccess !== "queries" &&
+            lapis.database.metadataAccess !== "snapshot") {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.database.metadataAccess`);
+        }
+    }
+    if (lapis.runtime !== undefined) {
+        if (!isRecord(lapis.runtime)) {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime`);
+        }
+        else {
+            diagnostics.push(...validateLapisRuntime(pluginId, lapis.runtime));
+        }
+    }
+    return diagnostics;
+}
+export function buildLapisContributionIndex(options) {
+    const activationEvents = normalizeStringArray(options.lapis.activationEvents);
+    const permissions = normalizePermissions(options.lapis.permissions);
+    const contributions = (isRecord(options.lapis.contributes) ? options.lapis.contributes : {});
+    const indexedContributions = markDuplicateContributionEntries([
+        ...BUILT_IN_CONTRIBUTION_POINT_DESCRIPTORS.flatMap((descriptor) => descriptor.index({
+            pluginId: options.pluginId,
+            manifestPath: options.manifestPath,
+            value: contributions[descriptor.kind],
+        })),
+        ...indexUnknownContributionKeys(options.pluginId, options.manifestPath, contributions),
+    ]);
+    return {
+        pluginId: options.pluginId,
+        name: options.name,
+        source: options.source,
+        classification: options.classification,
+        manifestPath: options.manifestPath,
+        activationEvents,
+        runtime: options.lapis.runtime,
+        permissions,
+        requestedCapabilities: options.requestedCapabilities ?? permissionsToCapabilities(permissions),
+        grantedCapabilities: options.grantedCapabilities,
+        enabled: options.lapis.enabled ?? options.lapis.enabledByDefault ?? true,
+        locked: options.lapis.locked ?? false,
+        enabledByDefault: options.lapis.enabledByDefault ?? true,
+        activationErrors: [],
+        privileges: [...new Set(options.privileges ?? [])],
+        contributions: indexedContributions,
+    };
+}
+export function getLapisContributionPointDescriptor(kind) {
+    return CONTRIBUTION_POINT_DESCRIPTOR_BY_KIND.get(kind);
+}
+export function getLapisContributionPointDescriptors() {
+    return BUILT_IN_CONTRIBUTION_POINT_DESCRIPTORS;
+}
+export function getLapisWorkspaceEntry(lapis) {
+    if (!lapis?.runtime) {
+        return null;
+    }
+    return typeof lapis.runtime.workspace === "string" &&
+        lapis.runtime.workspace.trim()
+        ? lapis.runtime.workspace
+        : null;
+}
+export function getLapisDesktopEntry(lapis) {
+    if (!lapis?.runtime) {
+        return null;
+    }
+    const entry = lapis.runtime.trustedDesktop ?? lapis.runtime.desktop;
+    return typeof entry === "string" && entry.trim() ? entry : null;
+}
+export function permissionsToCapabilities(permissions) {
+    const capabilities = new Set();
+    for (const permission of permissions ?? []) {
+        const capability = permissionToCapability(permission);
+        if (capability) {
+            capabilities.add(capability);
+        }
+    }
+    return [...capabilities];
+}
+export function activationEventForContribution(pluginId, entry) {
+    if (entry.activationEvent) {
+        return entry.activationEvent;
+    }
+    return getLapisContributionPointDescriptor(entry.kind)?.activationEvent?.(entry);
+}
+export function commandContributionToCommand(contribution) {
+    return {
+        id: contribution.command,
+        title: contribution.title,
+        category: contribution.category,
+        name: contribution.category
+            ? `${contribution.category}: ${contribution.title}`
+            : contribution.title,
+        icon: contribution.icon,
+        when: contribution.when,
+        hotkeys: contribution.hotkeys,
+        argumentSchema: contribution.argumentSchema,
+    };
+}
+export function normalizeManifestCommandId(pluginId, commandId) {
+    return commandId.startsWith(`${pluginId}:`)
+        ? commandId
+        : `${pluginId}:${commandId}`;
+}
+const BUILT_IN_CONTRIBUTION_POINT_DESCRIPTORS = [
+    createContributionPointDescriptor({
+        kind: "commands",
+        manifestInstallable: true,
+        validationMessage: "expected an object with string `command` and `title` fields",
+        isContribution: isCommandContribution,
+        activationEvent: (entry) => `onCommand:${entry.id}`,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.command,
+            contribution,
+            activationEvent: contribution.activationEvent,
+            requiredPermissions: ["commands"],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "configuration",
+        manifestInstallable: true,
+        validationMessage: "expected an object contribution record",
+        isContribution: isRecord,
+        buildEntry: ({ pluginId, index, contribution }) => ({
+            id: String(contribution.id ?? `${pluginId}.configuration.${index}`),
+            contribution,
+            requiredPermissions: [],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "languages",
+        manifestInstallable: false,
+        validationMessage: "expected an object with a string `id` field",
+        isContribution: isLanguageContribution,
+        activationEvent: (entry) => `onLanguage:${entry.id}`,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            requiredPermissions: [],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "views",
+        manifestInstallable: false,
+        validationMessage: "expected an object with string `id` and `name` fields",
+        isContribution: isViewContribution,
+        activationEvent: (entry) => `onView:${entry.id}`,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            activationEvent: contribution.activationEvent,
+            requiredPermissions: [],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "editorViews",
+        manifestInstallable: true,
+        validationMessage: "expected an object with string `id`, string `label`, and non-empty string array `filenamePatterns` fields",
+        isContribution: isEditorViewContribution,
+        activationEvent: (entry) => {
+            const contribution = entry.contribution;
+            return `onView:${contribution.viewType ?? contribution.id}`;
+        },
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            activationEvent: contribution.activationEvent,
+            requiredPermissions: [],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "services",
+        manifestInstallable: false,
+        validationMessage: "expected an object with string `id` and `service` fields",
+        isContribution: isServiceContribution,
+        activationEvent: (entry) => `onService:${entry.id}`,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            activationEvent: contribution.activationEvent,
+            runtimeHost: contribution.runtime,
+            requiredPermissions: normalizePermissions(contribution.permissions),
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "notebookRenderers",
+        manifestInstallable: false,
+        validationMessage: "expected an object with string `id` and `displayName` fields",
+        isContribution: isNotebookRendererContribution,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            activationEvent: contribution.activationEvent,
+            requiredPermissions: [],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "markdownPostProcessors",
+        manifestInstallable: false,
+        validationMessage: "expected an object with a string `id` field",
+        isContribution: isMarkdownPostProcessorContribution,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            activationEvent: contribution.activationEvent,
+            requiredPermissions: [],
+        }),
+    }),
+    createContributionPointDescriptor({
+        kind: "statusBarItems",
+        manifestInstallable: true,
+        validationMessage: "expected an object with string `id` plus at least one of `text` or `icon`",
+        isContribution: isStatusBarItemContribution,
+        buildEntry: ({ contribution }) => ({
+            id: contribution.id,
+            contribution,
+            requiredPermissions: [],
+        }),
+    }),
+];
+const CONTRIBUTION_POINT_DESCRIPTOR_BY_KIND = new Map(BUILT_IN_CONTRIBUTION_POINT_DESCRIPTORS.map((descriptor) => [
+    descriptor.kind,
+    descriptor,
+]));
+function createContributionPointDescriptor(options) {
+    return {
+        kind: options.kind,
+        manifestInstallable: options.manifestInstallable,
+        activationEvent: options.activationEvent,
+        index({ pluginId, manifestPath, value }) {
+            if (value === undefined) {
+                return [];
+            }
+            if (!Array.isArray(value)) {
+                return [
+                    createInvalidContributionEntry({
+                        pluginId,
+                        manifestPath,
+                        kind: options.kind,
+                        id: options.kind,
+                        reason: `expected lapis.contributes.${options.kind} to be an array`,
+                        contribution: value,
+                    }),
+                ];
+            }
+            return value.map((contribution, index) => {
+                if (!options.isContribution(contribution)) {
+                    return createInvalidContributionEntry({
+                        pluginId,
+                        manifestPath,
+                        kind: options.kind,
+                        id: `${options.kind}[${index}]`,
+                        reason: options.validationMessage,
+                        contribution,
+                    });
+                }
+                return {
+                    pluginId,
+                    kind: options.kind,
+                    manifestPath,
+                    state: "valid",
+                    diagnostics: [],
+                    ...options.buildEntry({
+                        pluginId,
+                        manifestPath,
+                        index,
+                        contribution,
+                    }),
+                };
+            });
+        },
+    };
+}
+function createInvalidContributionEntry(options) {
+    return {
+        pluginId: options.pluginId,
+        kind: options.kind,
+        id: options.id,
+        manifestPath: options.manifestPath,
+        contribution: options.contribution,
+        requiredPermissions: [],
+        state: "invalid",
+        diagnostics: [
+            `Plugin ${options.pluginId} has invalid lapis contribution ${options.kind}:${options.id} in ${options.manifestPath}: ${options.reason}`,
+        ],
+    };
+}
+function indexUnknownContributionKeys(pluginId, manifestPath, contributions) {
+    return Object.keys(contributions)
+        .filter((kind) => !CONTRIBUTION_POINT_DESCRIPTOR_BY_KIND.has(kind))
+        .map((kind) => ({
+        pluginId,
+        kind,
+        id: kind,
+        manifestPath,
+        contribution: contributions[kind],
+        requiredPermissions: [],
+        state: "invalid",
+        diagnostics: [
+            `Plugin ${pluginId} declares unsupported lapis.contributes.${kind} in ${manifestPath}; add a contribution point descriptor before using it`,
+        ],
+    }));
+}
+function markDuplicateContributionEntries(entries) {
+    const entriesByKey = new Map();
+    for (const entry of entries) {
+        if (entry.state !== "valid") {
+            continue;
+        }
+        const key = `${entry.kind}:${entry.id}`;
+        entriesByKey.set(key, [...(entriesByKey.get(key) ?? []), entry]);
+    }
+    for (const duplicates of entriesByKey.values()) {
+        if (duplicates.length < 2) {
+            continue;
+        }
+        for (const entry of duplicates) {
+            entry.state = "invalid";
+            entry.diagnostics.push(`Plugin ${entry.pluginId} declares duplicate lapis contribution ${entry.kind}:${entry.id} in ${entry.manifestPath}`);
+        }
+    }
+    return entries;
+}
+function requiresObsidianMain(lapis) {
+    const runtime = lapis.runtime;
+    if (!isRecord(runtime)) {
+        return false;
+    }
+    return (typeof runtime.workspace === "string" && runtime.workspace === "main.js");
+}
+function validateLapisRuntime(pluginId, runtime) {
+    const diagnostics = [];
+    for (const field of ["workspace", "desktop", "trustedDesktop"]) {
+        if (runtime[field] !== undefined && typeof runtime[field] !== "string") {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.${field}`);
+        }
+    }
+    if (runtime.entries !== undefined) {
+        if (!isRecord(runtime.entries)) {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries`);
+        }
+        else {
+            diagnostics.push(...validateLapisRuntimeEntries(pluginId, runtime.entries));
+        }
+    }
+    if (runtime.sharedDependencies !== undefined) {
+        if (!isRecord(runtime.sharedDependencies)) {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.sharedDependencies`);
+        }
+        else {
+            for (const field of [
+                "workspace",
+                "electronRenderer",
+                "electronSidecar",
+                "desktop",
+            ]) {
+                if (runtime.sharedDependencies[field] !== undefined &&
+                    !isStringArray(runtime.sharedDependencies[field])) {
+                    diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.sharedDependencies.${field}`);
+                }
+            }
+        }
+    }
+    if (runtime.compatibilityOverrides !== undefined) {
+        if (!isRecord(runtime.compatibilityOverrides)) {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.compatibilityOverrides`);
+        }
+        else {
+            const deprecatedHostModules = runtime.compatibilityOverrides.deprecatedHostModules;
+            if (deprecatedHostModules !== undefined) {
+                if (!isRecord(deprecatedHostModules)) {
+                    diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.compatibilityOverrides.deprecatedHostModules`);
+                }
+                else {
+                    for (const field of [
+                        "workspace",
+                        "electronRenderer",
+                        "electronSidecar",
+                        "desktop",
+                        "trustedDesktop",
+                    ]) {
+                        if (deprecatedHostModules[field] !== undefined &&
+                            !isStringArray(deprecatedHostModules[field])) {
+                            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.compatibilityOverrides.deprecatedHostModules.${field}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return diagnostics;
+}
+function validateLapisRuntimeEntries(pluginId, entries) {
+    const diagnostics = [];
+    for (const field of [
+        "workspace",
+        "electronRenderer",
+        "electronSidecar",
+        "desktop",
+        "trustedDesktop",
+    ]) {
+        const entry = entries[field];
+        if (entry === undefined) {
+            continue;
+        }
+        if (!isRecord(entry)) {
+            diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries.${field}`);
+            continue;
+        }
+        diagnostics.push(...validateLapisRuntimeEntry(pluginId, field, entry));
+    }
+    return diagnostics;
+}
+function validateLapisRuntimeEntry(pluginId, field, entry) {
+    const diagnostics = [];
+    if (!isValidRuntimeEntryPath(entry.path)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries.${field}.path`);
+    }
+    if (entry.format !== "esm" &&
+        entry.format !== "commonjs" &&
+        entry.format !== "node-esm") {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries.${field}.format`);
+    }
+    if (entry.fallbackPath !== undefined &&
+        !isValidRuntimeEntryPath(entry.fallbackPath)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries.${field}.fallbackPath`);
+    }
+    if (entry.sharedDependencies !== undefined &&
+        !isStringArray(entry.sharedDependencies)) {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries.${field}.sharedDependencies`);
+    }
+    if (entry.requiresReloadOnUpdate !== undefined &&
+        typeof entry.requiresReloadOnUpdate !== "boolean") {
+        diagnostics.push(`Plugin ${pluginId} has invalid lapis.runtime.entries.${field}.requiresReloadOnUpdate`);
+    }
+    return diagnostics;
+}
+function isValidRuntimeEntryPath(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const normalized = value.trim();
+    return (normalized.length > 0 &&
+        !normalized.startsWith("/") &&
+        !normalized.split("/").includes("..") &&
+        /\.(?:[cm]?js)$/u.test(normalized));
+}
+function permissionToCapability(permission) {
+    switch (permission) {
+        case "vault.read":
+            return "vault:read";
+        case "vault.write":
+            return "vault:write";
+        case "plugin.data":
+            return "plugin:data";
+        case "commands":
+        case "notices":
+        case "events":
+        case "logging":
+            return permission;
+        case "settings.read":
+            return "settings";
+        case "metadata.query":
+            return "metadata:query";
+        default:
+            return null;
+    }
+}
+function normalizePermissions(permissions) {
+    return normalizeStringArray(permissions).filter((permission) => permissionToCapability(permission) !== null);
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return [
+        ...new Set(value.filter((item) => typeof item === "string")),
+    ];
+}
+function normalizeArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === "string"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCommandContribution(value) {
+    return (isRecord(value) &&
+        typeof value.command === "string" &&
+        typeof value.title === "string");
+}
+function isLanguageContribution(value) {
+    return isRecord(value) && typeof value.id === "string";
+}
+function isViewContribution(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.name === "string");
+}
+function isEditorViewContribution(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.label === "string" &&
+        Array.isArray(value.filenamePatterns) &&
+        value.filenamePatterns.length > 0 &&
+        value.filenamePatterns.every((entry) => typeof entry === "string") &&
+        (value.viewType === undefined || typeof value.viewType === "string") &&
+        (value.description === undefined ||
+            typeof value.description === "string") &&
+        (value.priority === undefined ||
+            value.priority === "default" ||
+            value.priority === "option" ||
+            value.priority === "exclusive") &&
+        (value.activationEvent === undefined ||
+            typeof value.activationEvent === "string"));
+}
+function isServiceContribution(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.service === "string");
+}
+function isNotebookRendererContribution(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.displayName === "string");
+}
+function isMarkdownPostProcessorContribution(value) {
+    return isRecord(value) && typeof value.id === "string";
+}
+function isStatusBarItemContribution(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        (typeof value.text === "string" || typeof value.icon === "string") &&
+        (value.alignment === undefined ||
+            value.alignment === "left" ||
+            value.alignment === "right") &&
+        (value.priority === undefined || typeof value.priority === "number") &&
+        (value.tooltip === undefined || typeof value.tooltip === "string") &&
+        (value.command === undefined || typeof value.command === "string") &&
+        (value.when === undefined || typeof value.when === "string"));
+}

package/dist/links.d.ts

@@ -0,0 +1,34 @@
+export type NewLinkFormat = "shortest" | "relative" | "absolute";
+export type LinkStyle = "wikilink" | "markdown";
+export interface LinkSettings {
+    newLinkFormat: NewLinkFormat;
+    useWikilinks: boolean;
+    omitMarkdownExtension: boolean;
+    useShortestUniqueSuffix?: boolean;
+}
+export declare const defaultLinkSettings: LinkSettings;
+export interface VaultIndexFile {
+    path: string;
+    basename: string;
+    extension: string;
+}
+export interface VaultIndex {
+    getFiles(): VaultIndexFile[];
+}
+export interface GenerateLinkOptions {
+    sourcePath: string;
+    targetPath: string;
+    alias?: string;
+    embed?: boolean;
+    heading?: string;
+    blockId?: string;
+    settings?: Partial<LinkSettings>;
+    vaultIndex?: VaultIndex;
+}
+export declare function normalizeVaultPath(path: string): string;
+export declare function escapeWikilinkPath(path: string): string;
+export declare function escapeWikilinkAlias(alias: string): string;
+export declare function encodeMarkdownLinkDestination(path: string): string;
+export declare function escapeMarkdownLabel(label: string): string;
+export declare function getLinkPath(targetPath: string, sourcePath: string, settings: LinkSettings, vaultIndex: VaultIndex): string;
+export declare function generateInternalLink(options: GenerateLinkOptions): string;