@lapis-notes/api 0.1.0

package/dist/plugin-dependency-resolver.js

@@ -0,0 +1,54 @@
+export class LegacyObjectDependencyResolver {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    list() {
+        return Object.keys(this.dependencies)
+            .sort()
+            .map((specifier) => ({
+            specifier,
+            platforms: ["web", "electron-renderer"],
+            public: true,
+        }));
+    }
+    async prepare() { }
+    require(specifier, context) {
+        const dependency = this.resolve(specifier);
+        if (dependency !== undefined) {
+            return dependency;
+        }
+        throw new Error(`Cannot require ${specifier} in plugin ${context.pluginId}`);
+    }
+    canResolve(specifier, _context) {
+        return this.resolve(specifier) !== undefined;
+    }
+    resolve(specifier) {
+        const direct = this.dependencies[specifier];
+        if (direct !== undefined) {
+            return direct;
+        }
+        const normalized = this.normalizeAllowedScopedSubpath(specifier);
+        return normalized ? this.dependencies[normalized] : undefined;
+    }
+    normalizeAllowedScopedSubpath(specifier) {
+        if (!this.isAllowedScopedDependency(specifier)) {
+            return null;
+        }
+        const normalized = specifier
+            .replace(/\/(?:index\.)?(?:m?js|cjs)$/i, "")
+            .replace(/\/$/, "");
+        return normalized !== specifier ? normalized : null;
+    }
+    isAllowedScopedDependency(specifier) {
+        return (specifier.startsWith("@lapis-notes/") || specifier.startsWith("@lucide/"));
+    }
+}
+export function isPluginDependencyResolver(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.list === "function" &&
+        typeof value.prepare === "function" &&
+        typeof value.require === "function" &&
+        typeof value.canResolve === "function");
+}

package/dist/plugin-dependency-scanner.d.ts

@@ -0,0 +1,9 @@
+export type PluginDependencyImportKind = "require" | "static-import" | "dynamic-import" | "export";
+export interface PluginDependencySpecifier {
+    specifier: string;
+    kind: PluginDependencyImportKind;
+    index: number;
+}
+export declare function scanPluginDependencySpecifiers(source: string): PluginDependencySpecifier[];
+export declare function scanBarePluginDependencySpecifiers(source: string): string[];
+export declare function isBarePluginDependencySpecifier(specifier: string): boolean;

package/dist/plugin-dependency-scanner.js

@@ -0,0 +1,274 @@
+export function scanPluginDependencySpecifiers(source) {
+    const matches = [];
+    let index = 0;
+    while (index < source.length) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (char === "'" || char === '"') {
+            index = consumeQuotedString(source, index, char).end;
+            continue;
+        }
+        if (char === "`") {
+            index = consumeTemplateLiteral(source, index);
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            index = consumeLineComment(source, index);
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            index = consumeBlockComment(source, index);
+            continue;
+        }
+        if (!isIdentifierStart(char)) {
+            index += 1;
+            continue;
+        }
+        const wordStart = index;
+        index = consumeIdentifier(source, index);
+        const word = source.slice(wordStart, index);
+        if (!isImportLikeKeywordStart(source, wordStart)) {
+            continue;
+        }
+        const match = word === "require"
+            ? scanRequire(source, wordStart, index)
+            : word === "import"
+                ? scanImport(source, wordStart, index)
+                : word === "export"
+                    ? scanExport(source, wordStart, index)
+                    : null;
+        if (match) {
+            matches.push({
+                specifier: match.specifier,
+                kind: match.kind,
+                index: match.index,
+            });
+            index = Math.max(index, match.end);
+        }
+    }
+    return sortSpecifierMatches(matches);
+}
+export function scanBarePluginDependencySpecifiers(source) {
+    return [
+        ...new Set(scanPluginDependencySpecifiers(source)
+            .map((match) => match.specifier)
+            .filter(isBarePluginDependencySpecifier)),
+    ].sort();
+}
+export function isBarePluginDependencySpecifier(specifier) {
+    return (specifier.length > 0 &&
+        !specifier.startsWith(".") &&
+        !specifier.startsWith("/") &&
+        !/^[a-zA-Z][a-zA-Z\d+.-]*:/u.test(specifier));
+}
+function scanRequire(source, wordStart, cursor) {
+    if (previousNonWhitespaceCharacter(source, wordStart) === "." ||
+        isOptionalRequireFallback(source, wordStart)) {
+        return null;
+    }
+    cursor = skipWhitespaceAndComments(source, cursor);
+    if (source[cursor] !== "(") {
+        return null;
+    }
+    cursor = skipWhitespaceAndComments(source, cursor + 1);
+    const string = readStringLiteral(source, cursor);
+    if (!string) {
+        return null;
+    }
+    return {
+        specifier: string.value,
+        kind: "require",
+        index: wordStart,
+        end: string.end,
+    };
+}
+function scanImport(source, wordStart, cursor) {
+    cursor = skipWhitespaceAndComments(source, cursor);
+    if (source[cursor] === ".") {
+        return null;
+    }
+    if (source[cursor] === "(") {
+        cursor = skipWhitespaceAndComments(source, cursor + 1);
+        const string = readStringLiteral(source, cursor);
+        return string
+            ? {
+                specifier: string.value,
+                kind: "dynamic-import",
+                index: wordStart,
+                end: string.end,
+            }
+            : null;
+    }
+    const sideEffect = readStringLiteral(source, cursor);
+    if (sideEffect) {
+        return {
+            specifier: sideEffect.value,
+            kind: "static-import",
+            index: wordStart,
+            end: sideEffect.end,
+        };
+    }
+    const fromString = scanDeclarationFromSpecifier(source, cursor);
+    return fromString
+        ? {
+            specifier: fromString.value,
+            kind: "static-import",
+            index: wordStart,
+            end: fromString.end,
+        }
+        : null;
+}
+function scanExport(source, wordStart, cursor) {
+    const fromString = scanDeclarationFromSpecifier(source, cursor);
+    return fromString
+        ? {
+            specifier: fromString.value,
+            kind: "export",
+            index: wordStart,
+            end: fromString.end,
+        }
+        : null;
+}
+function scanDeclarationFromSpecifier(source, cursor) {
+    while (cursor < source.length) {
+        const char = source[cursor];
+        const next = source[cursor + 1];
+        if (char === ";") {
+            return null;
+        }
+        if (char === "'" || char === '"') {
+            cursor = consumeQuotedString(source, cursor, char).end;
+            continue;
+        }
+        if (char === "`") {
+            cursor = consumeTemplateLiteral(source, cursor);
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            cursor = consumeLineComment(source, cursor);
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            cursor = consumeBlockComment(source, cursor);
+            continue;
+        }
+        if (!isIdentifierStart(char)) {
+            cursor += 1;
+            continue;
+        }
+        const wordStart = cursor;
+        cursor = consumeIdentifier(source, cursor);
+        if (source.slice(wordStart, cursor) !== "from") {
+            continue;
+        }
+        cursor = skipWhitespaceAndComments(source, cursor);
+        return readStringLiteral(source, cursor);
+    }
+    return null;
+}
+function readStringLiteral(source, index) {
+    const quote = source[index];
+    if (quote !== "'" && quote !== '"') {
+        return null;
+    }
+    return consumeQuotedString(source, index, quote);
+}
+function consumeQuotedString(source, start, quote) {
+    let value = "";
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === "\\") {
+            value += source.slice(index, index + 2);
+            index += 2;
+            continue;
+        }
+        if (char === quote) {
+            return { value: unescapeStringLiteral(value), end: index + 1 };
+        }
+        value += char;
+        index += 1;
+    }
+    return { value: unescapeStringLiteral(value), end: index };
+}
+function consumeTemplateLiteral(source, start) {
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === "\\") {
+            index += 2;
+            continue;
+        }
+        index += 1;
+        if (char === "`") {
+            break;
+        }
+    }
+    return index;
+}
+function consumeLineComment(source, start) {
+    const end = source.indexOf("\n", start + 2);
+    return end === -1 ? source.length : end;
+}
+function consumeBlockComment(source, start) {
+    const end = source.indexOf("*/", start + 2);
+    return end === -1 ? source.length : end + 2;
+}
+function skipWhitespaceAndComments(source, cursor) {
+    while (cursor < source.length) {
+        const char = source[cursor];
+        const next = source[cursor + 1];
+        if (/\s/u.test(char)) {
+            cursor += 1;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            cursor = consumeLineComment(source, cursor);
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            cursor = consumeBlockComment(source, cursor);
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+function consumeIdentifier(source, start) {
+    let index = start + 1;
+    while (index < source.length && isIdentifierPart(source[index])) {
+        index += 1;
+    }
+    return index;
+}
+function isIdentifierStart(char) {
+    return Boolean(char && /[A-Za-z_$]/u.test(char));
+}
+function isIdentifierPart(char) {
+    return Boolean(char && /[A-Za-z0-9_$]/u.test(char));
+}
+function isImportLikeKeywordStart(source, index) {
+    const previous = source[index - 1];
+    return previous !== "'" && previous !== '"' && previous !== "`";
+}
+function previousNonWhitespaceCharacter(source, index) {
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+        if (!/\s/u.test(source[cursor])) {
+            return source[cursor] ?? null;
+        }
+    }
+    return null;
+}
+function isOptionalRequireFallback(source, index) {
+    const prefix = source.slice(Math.max(0, index - 160), index);
+    const previousBlockClose = prefix.lastIndexOf("}");
+    const currentBlockPrefix = previousBlockClose === -1 ? prefix : prefix.slice(previousBlockClose + 1);
+    return (/typeof\s+require\s*(?:={2,3}|!==?)\s*["']function["']/u.test(currentBlockPrefix) ||
+        /if\s*\(\s*typeof\s+require\s*(?:={2,3}|!==?)\s*["']function["']\s*\)\s*try\s*\{[\s\S]*(?:const|let|var)\s+\{[^}]*\}\s*=\s*$/u.test(prefix));
+}
+function sortSpecifierMatches(matches) {
+    return matches.sort((left, right) => left.index - right.index);
+}
+function unescapeStringLiteral(value) {
+    return value.replace(/\\(["'\\])/g, "$1");
+}

package/dist/plugin-distribution/canonical-json.d.ts

@@ -0,0 +1 @@
+export declare const canonicalJson: (value: unknown) => string;

package/dist/plugin-distribution/canonical-json.js

@@ -0,0 +1,40 @@
+import { PluginDistributionError } from "./errors";
+export const canonicalJson = (value) => serializeCanonicalJson(value, "$");
+const serializeCanonicalJson = (value, path) => {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw invalidCanonicalValue(path, "Numbers must be finite");
+        }
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value
+            .map((item, index) => serializeCanonicalJson(item, `${path}[${index}]`))
+            .join(",")}]`;
+    }
+    if (typeof value === "object") {
+        const proto = Object.getPrototypeOf(value);
+        if (proto !== Object.prototype && proto !== null) {
+            throw invalidCanonicalValue(path, "Only plain objects are supported");
+        }
+        const objectValue = value;
+        const entries = Object.keys(objectValue)
+            .sort()
+            .map((key) => {
+            const child = objectValue[key];
+            if (typeof child === "undefined") {
+                throw invalidCanonicalValue(`${path}.${key}`, "Undefined values are not supported");
+            }
+            return `${JSON.stringify(key)}:${serializeCanonicalJson(child, `${path}.${key}`)}`;
+        });
+        return `{${entries.join(",")}}`;
+    }
+    throw invalidCanonicalValue(path, `${typeof value} values are not supported`);
+};
+const invalidCanonicalValue = (path, reason) => new PluginDistributionError("canonical-json-invalid", `Cannot canonicalize JSON at ${path}: ${reason}.`, { details: { path, reason } });

package/dist/plugin-distribution/compatibility.d.ts

@@ -0,0 +1,5 @@
+import type { PluginCatalogEntry, PluginCatalogRelease, PluginCompatibilityInput, PluginCompatibilityResult, PluginReleaseManifest } from "./types";
+export declare const checkCatalogEntryCompatibility: (entry: PluginCatalogEntry, input: PluginCompatibilityInput) => PluginCompatibilityResult;
+export declare const checkCatalogReleaseCompatibility: (release: PluginCatalogRelease, input: PluginCompatibilityInput) => PluginCompatibilityResult;
+export declare const checkReleaseManifestCompatibility: (manifest: PluginReleaseManifest, input: PluginCompatibilityInput) => PluginCompatibilityResult;
+export declare const compareVersions: (actual: string, required: string) => number;

package/dist/plugin-distribution/compatibility.js

@@ -0,0 +1,38 @@
+export const checkCatalogEntryCompatibility = (entry, input) => checkBaseCompatibility(entry.minAppVersion, entry.platforms, false, false, false, input);
+export const checkCatalogReleaseCompatibility = (release, input) => checkBaseCompatibility(release.minAppVersion, release.platforms, false, false, Boolean(release.revoked), input);
+export const checkReleaseManifestCompatibility = (manifest, input) => checkBaseCompatibility(manifest.compatibility.minAppVersion, manifest.compatibility.platforms, Boolean(manifest.compatibility.desktopOnly), Boolean(manifest.compatibility.requiresWorkspaceTrust), Boolean(manifest.revoked), input);
+const checkBaseCompatibility = (minAppVersion, platforms, desktopOnly, requiresWorkspaceTrust, revoked, input) => {
+    const reasons = [];
+    if (compareVersions(input.appVersion, minAppVersion) < 0) {
+        reasons.push("app-version-too-old");
+    }
+    if (!platforms.includes(input.platform)) {
+        reasons.push("platform-unsupported");
+    }
+    if (desktopOnly && input.platform === "web") {
+        reasons.push("desktop-only");
+    }
+    if (requiresWorkspaceTrust && !input.workspaceTrusted) {
+        reasons.push("workspace-trust-required");
+    }
+    if (revoked) {
+        reasons.push("revoked");
+    }
+    return { compatible: reasons.length === 0, reasons };
+};
+export const compareVersions = (actual, required) => {
+    const actualParts = parseVersion(actual);
+    const requiredParts = parseVersion(required);
+    const length = Math.max(actualParts.length, requiredParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (actualParts[index] ?? 0) - (requiredParts[index] ?? 0);
+        if (difference !== 0)
+            return difference > 0 ? 1 : -1;
+    }
+    return 0;
+};
+const parseVersion = (version) => version
+    .replace(/^[^\d]*/, "")
+    .split(/[.+-]/)
+    .map((part) => Number.parseInt(part, 10))
+    .filter((part) => Number.isFinite(part));

package/dist/plugin-distribution/errors.d.ts

@@ -0,0 +1,11 @@
+export type PluginDistributionErrorCode = "canonical-json-invalid" | "compatibility-failed" | "hash-mismatch" | "invalid-path" | "metadata-invalid" | "reserved-id" | "signature-invalid" | "signature-key-not-found";
+export declare class PluginDistributionError extends Error {
+    readonly code: PluginDistributionErrorCode;
+    readonly cause?: unknown;
+    readonly details?: Record<string, unknown>;
+    constructor(code: PluginDistributionErrorCode, message: string, options?: {
+        cause?: unknown;
+        details?: Record<string, unknown>;
+    });
+}
+export declare const isPluginDistributionError: (error: unknown) => error is PluginDistributionError;

package/dist/plugin-distribution/errors.js

@@ -0,0 +1,13 @@
+export class PluginDistributionError extends Error {
+    code;
+    cause;
+    details;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "PluginDistributionError";
+        this.code = code;
+        this.cause = options.cause;
+        this.details = options.details;
+    }
+}
+export const isPluginDistributionError = (error) => error instanceof PluginDistributionError;

package/dist/plugin-distribution/hashes.d.ts

@@ -0,0 +1,2 @@
+export declare const sha256Hex: (input: string | ArrayBuffer | Uint8Array) => Promise<string>;
+export declare const verifySha256: (input: string | ArrayBuffer | Uint8Array, expectedSha256: string) => Promise<void>;

package/dist/plugin-distribution/hashes.js

@@ -0,0 +1,17 @@
+import { PluginDistributionError } from "./errors";
+export const sha256Hex = async (input) => {
+    const bytes = typeof input === "string"
+        ? new TextEncoder().encode(input)
+        : toUint8(input);
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+    return [...new Uint8Array(digest)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+};
+export const verifySha256 = async (input, expectedSha256) => {
+    const actualSha256 = await sha256Hex(input);
+    if (actualSha256.toLowerCase() !== expectedSha256.toLowerCase()) {
+        throw new PluginDistributionError("hash-mismatch", `SHA-256 mismatch: expected ${expectedSha256}, got ${actualSha256}.`, { details: { expectedSha256, actualSha256 } });
+    }
+};
+const toUint8 = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);

package/dist/plugin-distribution/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./canonical-json";
+export * from "./compatibility";
+export * from "./errors";
+export * from "./hashes";
+export * from "./installed-plugin-state";
+export * from "./installer";
+export * from "./manager";
+export * from "./path-safety";
+export * from "./plugin-bundle";
+export * from "./plugin-bundle-verifier";
+export * from "./plugin-bundle-worker";
+export * from "./registry-cache";
+export * from "./registry-client";
+export * from "./reserved-ids";
+export * from "./runtime-validation";
+export * from "./schemas";
+export * from "./signing";
+export * from "./types";

package/dist/plugin-distribution/index.js

@@ -0,0 +1,18 @@
+export * from "./canonical-json";
+export * from "./compatibility";
+export * from "./errors";
+export * from "./hashes";
+export * from "./installed-plugin-state";
+export * from "./installer";
+export * from "./manager";
+export * from "./path-safety";
+export * from "./plugin-bundle";
+export * from "./plugin-bundle-verifier";
+export * from "./plugin-bundle-worker";
+export * from "./registry-cache";
+export * from "./registry-client";
+export * from "./reserved-ids";
+export * from "./runtime-validation";
+export * from "./schemas";
+export * from "./signing";
+export * from "./types";

package/dist/plugin-distribution/installed-plugin-state.d.ts

@@ -0,0 +1,20 @@
+import type { DataAdapter } from "../storage/fs";
+import type { InstalledPluginRecord, InstalledPluginsState } from "./types";
+export declare class InstalledPluginStateStore {
+    private readonly adapter;
+    private readonly options;
+    constructor(adapter: DataAdapter, options?: {
+        path?: string;
+        now?: () => Date;
+    });
+    load(): Promise<InstalledPluginsState>;
+    save(state: InstalledPluginsState): Promise<void>;
+    get(pluginId: string): Promise<InstalledPluginRecord | null>;
+    list(): Promise<InstalledPluginRecord[]>;
+    upsert(record: InstalledPluginRecord): Promise<void>;
+    remove(pluginId: string): Promise<void>;
+    private emptyState;
+    private get path();
+    private now;
+}
+export declare const ensureFolder: (adapter: DataAdapter, folderPath: string) => Promise<void>;

package/dist/plugin-distribution/installed-plugin-state.js

@@ -0,0 +1,73 @@
+import { dirname } from "../storage/path";
+import { installedPluginsStateSchema, parsePluginDistributionMetadata, } from "./schemas";
+export class InstalledPluginStateStore {
+    adapter;
+    options;
+    constructor(adapter, options = {}) {
+        this.adapter = adapter;
+        this.options = options;
+    }
+    async load() {
+        try {
+            const raw = await this.adapter.read(this.path);
+            return parsePluginDistributionMetadata(installedPluginsStateSchema, JSON.parse(raw));
+        }
+        catch {
+            return this.emptyState();
+        }
+    }
+    async save(state) {
+        const next = {
+            ...state,
+            schemaVersion: 1,
+            updatedAt: this.now(),
+            plugins: state.plugins ?? {},
+        };
+        await ensureFolder(this.adapter, dirname(this.path));
+        await this.adapter.write(this.path, JSON.stringify(next, null, 2));
+    }
+    async get(pluginId) {
+        const state = await this.load();
+        return state.plugins[pluginId] ?? null;
+    }
+    async list() {
+        const state = await this.load();
+        return Object.values(state.plugins);
+    }
+    async upsert(record) {
+        const state = await this.load();
+        await this.save({
+            ...state,
+            plugins: {
+                ...state.plugins,
+                [record.pluginId]: record,
+            },
+        });
+    }
+    async remove(pluginId) {
+        const state = await this.load();
+        const { [pluginId]: _removed, ...plugins } = state.plugins;
+        await this.save({ ...state, plugins });
+    }
+    emptyState() {
+        return {
+            schemaVersion: 1,
+            updatedAt: this.now(),
+            plugins: {},
+        };
+    }
+    get path() {
+        return this.options.path ?? ".obsidian/installed-plugins.json";
+    }
+    now() {
+        return (this.options.now?.() ?? new Date()).toISOString();
+    }
+}
+export const ensureFolder = async (adapter, folderPath) => {
+    if (folderPath === "/" || folderPath === "." || folderPath === "")
+        return;
+    if (await adapter.exists(folderPath))
+        return;
+    await ensureFolder(adapter, dirname(folderPath));
+    await adapter.mkdir(folderPath);
+};