@lapis-notes/bases 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Bases changelog
+
+## 0.1.0
+
+- Initial independent public package extracted from Lapis Notes without changing
+  the runtime plugin ID.

package/LICENSE.md

@@ -0,0 +1,8 @@
+# License
+
+Copyright (c) LapisMD contributors.
+
+This software is licensed under the GNU Affero General Public License, version
+3 or (at your option) any later version (`AGPL-3.0-or-later`). The complete
+license text is available from the
+[GNU Project](https://www.gnu.org/licenses/agpl-3.0.html).

package/README.md

@@ -0,0 +1,20 @@
+# Bases
+
+Bases
+
+## Install for static composition
+
+```sh
+pnpm add @lapis-notes/bases
+```
+
+Register the exported plugin class in the application's `PluginProfile`. Import
+`@lapis-notes/bases/styles.css?inline` and pass the CSS through the static
+registration so the host owns its lifecycle.
+
+The runtime plugin ID is `bases`. A matching signed
+`bases-0.1.0.lapis-plugin` archive is attached to the
+package-scoped GitHub release for manual or registry installation.
+
+See the [repository README](https://github.com/lapismd/lapis-plugins#readme) for
+development, validation, and release-gate details.

package/dist/bases-plugin.d.ts

@@ -0,0 +1,10 @@
+import { type App, Plugin, type PluginManifest } from "@lapis-notes/api";
+export declare class BasesPlugin extends Plugin {
+    constructor(app: App, manifest?: PluginManifest);
+    onload(): Promise<void>;
+    private registerReadOnlyEmbedRenderer;
+    private registerReadOnlyCodeBlockRenderer;
+    private mountReadOnlyBases;
+    private renderError;
+}
+export default BasesPlugin;

package/dist/bases-plugin.js

@@ -0,0 +1,118 @@
+import { MarkdownRenderChild, Plugin, } from "@lapis-notes/api";
+import { markupEditor } from "@lapis-notes/api/editor/core";
+import { yaml } from "@codemirror/lang-yaml";
+import { mount, unmount } from "svelte";
+import BasesComponent from "./bases-view/view.svelte";
+import { BasesView, BasesViewType, createBasesViewRegistrations, parseBasesDocument, } from "./bases-view";
+import manifestSpec from "../../manifest.json";
+export class BasesPlugin extends Plugin {
+    constructor(app, manifest = manifestSpec) {
+        super(app, manifest);
+    }
+    async onload() {
+        this.registerView(BasesViewType, (leaf) => new BasesView(leaf), {
+            kind: "file",
+        });
+        this.registerEditorView({
+            id: BasesViewType,
+            label: "Bases",
+            filenamePatterns: ["*.bases", "*.base"],
+            priority: "default",
+        });
+        this.registerExtensions(["bases", "base"], BasesViewType);
+        this.registerEditorExtension(() => [markupEditor({ language: "yaml", app: this.app }), yaml()], BasesViewType);
+        this.registerReadOnlyEmbedRenderer("base");
+        this.registerReadOnlyEmbedRenderer("bases");
+        this.registerReadOnlyCodeBlockRenderer("base");
+        this.registerReadOnlyCodeBlockRenderer("bases");
+    }
+    registerReadOnlyEmbedRenderer(extension) {
+        this.register(this.app.embedRegistry.register(extension, ({ containerEl, state }) => {
+            const file = state.file;
+            if (!file) {
+                return;
+            }
+            let activeHandle = null;
+            let disposed = false;
+            void this.app.vault
+                .read(file)
+                .then((content) => {
+                if (disposed) {
+                    return;
+                }
+                activeHandle = this.mountReadOnlyBases(containerEl, content);
+            })
+                .catch((error) => {
+                if (disposed) {
+                    return;
+                }
+                this.renderError(containerEl, error instanceof Error
+                    ? `Unable to render this embedded base: ${error.message}`
+                    : `Unable to render this embedded base: ${String(error)}`);
+            });
+            return {
+                destroy: () => {
+                    disposed = true;
+                    activeHandle?.destroy();
+                    activeHandle = null;
+                    containerEl.replaceChildren();
+                },
+            };
+        }));
+    }
+    registerReadOnlyCodeBlockRenderer(language) {
+        this.registerMarkdownCodeBlockProcessor(language, (source, el, ctx) => {
+            const handle = this.mountReadOnlyBases(el, source);
+            const child = new MarkdownRenderChild(el);
+            child.register(() => {
+                handle.destroy();
+            });
+            ctx.addChild(child);
+        });
+    }
+    mountReadOnlyBases(containerEl, content) {
+        containerEl.replaceChildren();
+        let document;
+        try {
+            document = parseBasesDocument(content);
+        }
+        catch (error) {
+            this.renderError(containerEl, error instanceof Error
+                ? `Unable to render this base: ${error.message}`
+                : `Unable to render this base: ${String(error)}`);
+            return {
+                destroy: () => {
+                    containerEl.replaceChildren();
+                },
+            };
+        }
+        const component = mount(BasesComponent, {
+            target: containerEl,
+            props: {
+                app: this.app,
+                document,
+                registrations: createBasesViewRegistrations(this.app),
+                onChange: () => { },
+                readOnly: true,
+                showHeader: false,
+            },
+        });
+        return {
+            destroy: () => {
+                void unmount(component);
+                containerEl.replaceChildren();
+            },
+        };
+    }
+    renderError(containerEl, message) {
+        containerEl.replaceChildren();
+        const wrapper = document.createElement("div");
+        wrapper.className = "bases-view-error";
+        const messageEl = document.createElement("p");
+        messageEl.className = "bases-view-error__message";
+        messageEl.textContent = message;
+        wrapper.appendChild(messageEl);
+        containerEl.appendChild(wrapper);
+    }
+}
+export default BasesPlugin;

package/dist/bases-view/app-database-query-source.d.ts

@@ -0,0 +1,30 @@
+import { type AppDatabase, type AppDatabaseIndexedMetadataQuery, type AppDatabaseIndexedMetadataRow, type CachedMetadata, type TFile } from "@lapis-notes/api";
+import { type Filters, type SortColumn } from "./models";
+type BuildBasesAppDatabaseQueryInput = {
+    documentFilter: Filters;
+    viewFilter?: Filters;
+    sort: SortColumn[];
+    limit: number | null | undefined;
+};
+type QuerySourceApp = {
+    vault: {
+        getFileByPath(path: string): TFile | null;
+    };
+};
+type QuerySourceVaultRecord = {
+    id: string;
+    checksum?: string;
+    file: TFile;
+    cache: CachedMetadata | null;
+    backlinks?: string[];
+};
+export declare function buildBasesAppDatabaseQuery(input: BuildBasesAppDatabaseQueryInput): AppDatabaseIndexedMetadataQuery;
+/**
+ * Read database candidates in bounded pages. When no pushed-down limit is
+ * available, final PEaQL sorting remains authoritative and candidates page by
+ * path so the cursor is stable across every provider.
+ */
+export declare function queryBasesAppDatabaseRows(database: Pick<AppDatabase, "queryIndexedMetadataPage">, query: AppDatabaseIndexedMetadataQuery, pageSize?: number): Promise<AppDatabaseIndexedMetadataRow[]>;
+export declare function appDatabaseRowToVaultRecord(app: QuerySourceApp, row: AppDatabaseIndexedMetadataRow): QuerySourceVaultRecord;
+export declare function appDatabaseRowsToVaultRecords(app: QuerySourceApp, rows: AppDatabaseIndexedMetadataRow[]): QuerySourceVaultRecord[];
+export {};

package/dist/bases-view/app-database-query-source.js

@@ -0,0 +1,248 @@
+import {} from "@lapis-notes/api";
+import { isFilterGroup, isFilterLine, } from "./models";
+function clone(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+function createSyntheticVaultFile(row) {
+    const pathSegments = row.file.path.split("/");
+    const name = pathSegments.at(-1) ?? row.file.path;
+    const extension = row.file.extension;
+    const suffix = extension ? `.${extension}` : "";
+    const baseName = suffix && name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;
+    return {
+        path: row.file.path,
+        name,
+        baseName,
+        extension,
+        parent: null,
+        stat: {
+            ctime: row.file.mtime,
+            mtime: row.file.mtime,
+            size: row.file.size,
+        },
+    };
+}
+function appendUnique(target, value) {
+    if (!value || target.includes(value)) {
+        return;
+    }
+    target.push(value);
+}
+function appendPropertyFilter(target, filter) {
+    if (target.some((existing) => existing.name === filter.name &&
+        existing.op === filter.op &&
+        existing.value === filter.value)) {
+        return;
+    }
+    target.push(filter);
+}
+function collectConjunctiveFilterLines(filter) {
+    if (!filter || typeof filter === "string") {
+        return [];
+    }
+    if (isFilterLine(filter)) {
+        return [filter];
+    }
+    if (!isFilterGroup(filter) || !("and" in filter)) {
+        return [];
+    }
+    return filter.and.flatMap((entry) => collectConjunctiveFilterLines(entry));
+}
+function normalizePropertyName(column) {
+    if (!column || column === "file" || column.startsWith("formula.")) {
+        return null;
+    }
+    if (column.startsWith("file.")) {
+        return null;
+    }
+    return column.startsWith("note.") ? column.slice("note.".length) : column;
+}
+function isScalarFilterValue(value) {
+    return (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
+}
+function lowerFilterLine(query, filter) {
+    if (filter.custom) {
+        return;
+    }
+    const rawValues = (Array.isArray(filter.value) ? filter.value : [filter.value]);
+    const values = rawValues.filter(isScalarFilterValue);
+    if (filter.column === "file" && filter.op === "inFolder") {
+        for (const value of values) {
+            if (typeof value === "string") {
+                appendUnique((query.pathPrefixes ??= []), value);
+            }
+        }
+        return;
+    }
+    if (filter.column === "file" && filter.op === "hasTag") {
+        for (const value of values) {
+            if (typeof value === "string") {
+                appendUnique((query.requiredTags ??= []), value);
+            }
+        }
+        return;
+    }
+    if (filter.column === "file" && filter.op === "hasProperty") {
+        for (const value of values) {
+            if (typeof value === "string") {
+                appendPropertyFilter((query.propertyFilters ??= []), {
+                    name: value,
+                    op: "exists",
+                });
+            }
+        }
+        return;
+    }
+    if (filter.column === "file" && filter.op === "!hasProperty") {
+        for (const value of values) {
+            if (typeof value === "string") {
+                appendPropertyFilter((query.propertyFilters ??= []), {
+                    name: value,
+                    op: "not-exists",
+                });
+            }
+        }
+        return;
+    }
+    if (filter.column === "file.ext" && filter.op === "=") {
+        for (const value of values) {
+            if (typeof value === "string") {
+                appendUnique((query.extensions ??= []), value);
+            }
+        }
+        return;
+    }
+    const propertyName = normalizePropertyName(filter.column);
+    if (!propertyName) {
+        return;
+    }
+    if (["=", "!=", ">", ">=", "<", "<="].includes(filter.op)) {
+        const value = values[0];
+        if (value !== undefined) {
+            appendPropertyFilter((query.propertyFilters ??= []), {
+                name: propertyName,
+                op: filter.op,
+                value,
+            });
+        }
+    }
+}
+function lowerSort(sort) {
+    if (sort.property === "file.path") {
+        return {
+            field: { kind: "file", field: "path" },
+            direction: sort.direction,
+        };
+    }
+    if (sort.property === "file.ext") {
+        return {
+            field: { kind: "file", field: "extension" },
+            direction: sort.direction,
+        };
+    }
+    if (sort.property === "file.mtime") {
+        return {
+            field: { kind: "file", field: "mtime" },
+            direction: sort.direction,
+        };
+    }
+    if (sort.property === "file.size") {
+        return {
+            field: { kind: "file", field: "size" },
+            direction: sort.direction,
+        };
+    }
+    const propertyName = normalizePropertyName(sort.property);
+    if (!propertyName) {
+        return null;
+    }
+    return {
+        field: { kind: "property", name: propertyName },
+        direction: sort.direction,
+    };
+}
+export function buildBasesAppDatabaseQuery(input) {
+    const query = {
+        excludeHiddenPaths: true,
+    };
+    for (const filter of collectConjunctiveFilterLines(input.documentFilter)) {
+        lowerFilterLine(query, filter);
+    }
+    for (const filter of collectConjunctiveFilterLines(input.viewFilter)) {
+        lowerFilterLine(query, filter);
+    }
+    const loweredSorts = input.sort
+        .map(lowerSort)
+        .filter((sort) => sort !== null);
+    if (loweredSorts.length > 0 && loweredSorts.length === input.sort.length) {
+        query.sort = loweredSorts;
+        if (input.limit && input.limit > 0) {
+            query.limit = input.limit;
+        }
+    }
+    return query;
+}
+/**
+ * Read database candidates in bounded pages. When no pushed-down limit is
+ * available, final PEaQL sorting remains authoritative and candidates page by
+ * path so the cursor is stable across every provider.
+ */
+export async function queryBasesAppDatabaseRows(database, query, pageSize = 500) {
+    if (query.limit && query.limit > 0) {
+        return (await database.queryIndexedMetadataPage({
+            query,
+            limit: query.limit,
+        })).rows;
+    }
+    const rows = [];
+    const pagedQuery = { ...query, sort: undefined, limit: undefined };
+    let after;
+    do {
+        const page = await database.queryIndexedMetadataPage({
+            query: pagedQuery,
+            after,
+            limit: pageSize,
+        });
+        rows.push(...page.rows);
+        after = page.nextCursor;
+    } while (after);
+    return rows;
+}
+export function appDatabaseRowToVaultRecord(app, row) {
+    const cache = clone((row.metadata?.metadata ?? {})) ?? {};
+    const frontmatter = { ...(cache.frontmatter ?? {}) };
+    for (const property of row.properties) {
+        if (!(property.name in frontmatter)) {
+            frontmatter[property.name] = property.value;
+        }
+    }
+    cache.frontmatter = frontmatter;
+    if ((cache.tags?.length ?? 0) === 0 && row.tags.length > 0) {
+        cache.tags = row.tags.map((tag) => ({ tag: tag.tag }));
+    }
+    if ((cache.links?.length ?? 0) === 0) {
+        cache.links = row.links
+            .filter((link) => link.type === "link")
+            .map((link) => ({ link: link.resolvedTargetPath ?? link.targetText }));
+    }
+    if ((cache.embeds?.length ?? 0) === 0) {
+        cache.embeds = row.links
+            .filter((link) => link.type === "embed")
+            .map((link) => ({ link: link.resolvedTargetPath ?? link.targetText }));
+    }
+    return {
+        id: row.file.path,
+        checksum: row.file.hash,
+        file: app.vault.getFileByPath(row.file.path) ?? createSyntheticVaultFile(row),
+        cache,
+    };
+}
+export function appDatabaseRowsToVaultRecords(app, rows) {
+    return rows.map((row) => appDatabaseRowToVaultRecord(app, row));
+}