@lapis-notes/bases 0.1.0

package/dist/bases-view/bases.svelte.js

@@ -0,0 +1,910 @@
+import { BasesViewConfig as SharedBasesViewConfig, Component, TFile, } from "@lapis-notes/api";
+import { DateTime, Duration } from "luxon";
+import { Context, Decimal, parseDateTime, parseDuration, } from "peaql";
+import {} from "./models";
+import { BasesTable, VaultFile } from "./db";
+import { columnsFor, frontMatterTypesForColumns, } from "./columns";
+import { generateQuery } from "./filter-parser";
+import { isEqual } from "lodash-es";
+import { groupEntries } from "./query-result-core";
+import { filterEntriesBySearch } from "./search-core";
+import { collectMetadataDependencies, } from "./metadata-invalidation-core";
+import { appDatabaseRowsToVaultRecords, buildBasesAppDatabaseQuery, queryBasesAppDatabaseRows, } from "./app-database-query-source";
+import { mount, unmount } from "svelte";
+export { BasesViewConfig } from "@lapis-notes/api";
+/**
+ * Represent a single "row" or file in a base.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class BasesEntry {
+    id;
+    file;
+    context;
+    constructor(id, file, context = {}) {
+        this.id = id;
+        this.file = file;
+        this.context = context;
+    }
+    /**
+     * Get the value of the property.
+     *
+     * @since 1.10.0
+     * @throws Error if the property is a formula and cannot be evaluated.
+     * @public
+     */
+    getValue(propertyId) {
+        if (propertyId.startsWith("file.") ||
+            propertyId.startsWith("note.") ||
+            propertyId.startsWith("formula.")) {
+            return this.context[propertyId] ?? null;
+        }
+        return (this.context[`note.${propertyId}`] ?? this.context[propertyId] ?? null);
+    }
+}
+/**
+ * Container type for data which can expose functions for retrieving, comparing,
+ * and rendering the data. Most commonly used in conjunction with formulas for
+ * Bases. Values can be used as formula parameters, intermediate values, and the
+ * result of evaluation.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class Value {
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    static equals(a, b) {
+        if (!a || !b)
+            return a === b;
+        return a.equals(b);
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    static looseEquals(a, b) {
+        if (!a || !b)
+            return a == b;
+        return a.looseEquals(b);
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    equals(other) {
+        if (!(other instanceof Value))
+            return false;
+        return this === other;
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    looseEquals(other) {
+        if (!(other instanceof Value))
+            return false;
+        return this == other;
+    }
+    /**
+     * Render this value into the provided HTMLElement.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    renderTo(el, ctx) { }
+}
+/**
+ * Base type for all non-null {@link Values}.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class NotNullValue extends Value {
+}
+/**
+ * {@link Value} which represents null. NullValue is a singleton and
+ * `NullValue.value` should be used instead of calling the constructor.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class NullValue extends Value {
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    static value = new NullValue();
+    get value() {
+        return null;
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    toString() {
+        return "";
+    }
+    isTruthy() {
+        return false;
+    }
+    equals(other) {
+        return other === null || other === undefined;
+    }
+    looseEquals(other) {
+        return other == null || other == undefined;
+    }
+}
+/**
+ * Base type for {@link Values} which wrap a single primitive.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class PrimitiveValue extends NotNullValue {
+    value;
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    toString() {
+        return this.value?.toString();
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    isTruthy() {
+        return this.value ? true : false;
+    }
+    equals(other) {
+        if (!(other instanceof PrimitiveValue))
+            return false;
+        return this.value === other.value;
+    }
+    looseEquals(other) {
+        if (!(other instanceof PrimitiveValue))
+            return false;
+        return this.value == other.value;
+    }
+}
+/**
+ * {@link Value} wrapping a boolean.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class BooleanValue extends PrimitiveValue {
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    static type = "boolean";
+    looseEquals(other) {
+        if (other instanceof BooleanValue) {
+            return this.value === other.value;
+        }
+        else if (other instanceof PrimitiveValue) {
+            if (typeof other.value === "number") {
+                return other.value > 0;
+            }
+            else if (typeof other.value === "string") {
+                return other.value.toLowerCase() === this.toString();
+            }
+        }
+        return false;
+    }
+}
+/**
+ * {@link Value} wrapping a number.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class NumberValue extends PrimitiveValue {
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    static type = "number";
+    equals(other) {
+        return this.number === other.number;
+    }
+    looseEquals(other) {
+        if (other instanceof NumberValue) {
+            return this.number === other.number;
+        }
+        return false;
+    }
+    toString() {
+        return this.number.toString();
+    }
+    get number() {
+        if (typeof this.value === "number") {
+            return this.value;
+        }
+        return this.value.number;
+    }
+}
+/**
+ * {@link Value} wrapping a string.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class StringValue extends PrimitiveValue {
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    static type = "string";
+}
+export class DateValue extends NotNullValue {
+    value;
+    constructor(value) {
+        super();
+        if (value instanceof DateTime) {
+            this.value = value;
+        }
+        else if (value instanceof Date) {
+            this.value = DateTime.fromJSDate(value);
+        }
+        else if (typeof value === "number") {
+            this.value = DateTime.fromMillis(value);
+        }
+        else {
+            this.value = parseDateTime(value);
+        }
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    toString() {
+        return this.value.toISO()?.substring(0, 16) ?? "";
+    }
+    /**
+     * @since 1.10.0
+     * @returns A new DateValue with any time portion in this DateValue removed.
+     * @public
+     */
+    dateOnly() {
+        return new DateValue(this.value.startOf("day"));
+    }
+    /**
+     * @since 1.10.0
+     * @returns A new {@link RelativeDateValue} based on this DateValue.
+     * @public
+     */
+    relative() {
+        return this.value.toRelative() ?? "";
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    isTruthy() {
+        return this.value.isValid;
+    }
+    equals(other) {
+        if (!(other instanceof DateValue))
+            return false;
+        return this.value.toMillis() === other.value.toMillis();
+    }
+    looseEquals(other) {
+        if (other instanceof DateValue) {
+            return this.value.toMillis() === other.value.toMillis();
+        }
+        else if (other instanceof NumberValue) {
+            return this.value.toMillis() === other.number;
+        }
+        return false;
+    }
+    /**
+     * Create new DateValue from an input string.
+     *
+     * @since 1.10.0
+     * @example
+     *   parseFromString("2025-12-31");
+     *   parseFromString("2025-12-31T23:59");
+     *   parseFromString("2025-12-31T23:59:59");
+     *   parseFromString("2025-12-31T23:59:59Z-07");
+     *
+     * @param input - An ISO 8601 date or datetime string.
+     * @public
+     */
+    static parseFromString(input) {
+        try {
+            return new DateValue(parseDateTime(input));
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+export class DurationValue extends NotNullValue {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    toString() {
+        return this.value.toString();
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    isTruthy() {
+        return this.value.isValid;
+    }
+    /**
+     * Modifies the provided {@DateValue} by this duration.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    addToDate(value, subtract) {
+        return new DateValue(subtract ? value.value.minus(this.value) : value.value.plus(this.value));
+    }
+    /**
+     * Convert this duration into milliseconds.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    getMilliseconds() {
+        return this.value.toMillis();
+    }
+    equals(other) {
+        if (!(other instanceof DurationValue))
+            return false;
+        return this.getMilliseconds() === other.getMilliseconds();
+    }
+    looseEquals(other) {
+        if (other instanceof DurationValue) {
+            return this.getMilliseconds() === other.getMilliseconds();
+        }
+        else if (other instanceof NumberValue) {
+            return this.getMilliseconds() === other.number;
+        }
+        return false;
+    }
+    /**
+     * Create a new DurationValue using an ISO 8601 duration. See
+     * {@link https://en.wikipedia.org/wiki/ISO_8601#Durations} for duration format
+     * details.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    static parseFromString(input) {
+        try {
+            return new DurationValue(parseDuration(input));
+        }
+        catch (_) { }
+        return null;
+    }
+    /**
+     * Create a new DurationValue from milliseconds.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    static fromMilliseconds(milliseconds) {
+        return new DurationValue(Duration.fromMillis(milliseconds));
+    }
+}
+export class FileValue extends NotNullValue {
+    file;
+    constructor(file) {
+        super();
+        this.file = file;
+    }
+    get value() {
+        return this.file;
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    toString() {
+        return this.file.path;
+    }
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    isTruthy() {
+        return true;
+    }
+    equals(other) {
+        if (!(other instanceof FileValue))
+            return false;
+        return this.file.path === other.file.path;
+    }
+    looseEquals(other) {
+        if (other instanceof FileValue) {
+            return other.file.path === this.file.path;
+        }
+        else if (other instanceof PrimitiveValue) {
+            return this.file.path === other.value;
+        }
+        return false;
+    }
+}
+export class ObjectValue extends NotNullValue {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    equals(other) {
+        if (!(other instanceof ObjectValue))
+            return false;
+        return isEqual(this, other);
+    }
+    looseEquals(other) {
+        return isEqual(this, other);
+    }
+    toString() {
+        return this.value.toString();
+    }
+    isTruthy() {
+        return true;
+    }
+}
+function unknownView(type) {
+    return {
+        name: "Unknown",
+        type: type ?? "unknown",
+        filter: { and: [] },
+        order: [],
+        sort: [],
+        limit: 0,
+    };
+}
+function toEntry(value, type) {
+    if (value instanceof Value) {
+        return value;
+    }
+    if (value === null || value === undefined) {
+        return NullValue.value;
+    }
+    else if (type === String) {
+        return new StringValue(value);
+    }
+    else if (type === Number || type == Decimal || typeof value === "number") {
+        return new NumberValue(value);
+    }
+    else if (type === DateTime || type === Date) {
+        return new DateValue(value);
+    }
+    else if (type === Boolean) {
+        return new BooleanValue(value);
+    }
+    else if (type === Duration) {
+        return new DurationValue(value);
+    }
+    else if (type === TFile || type == VaultFile) {
+        return new FileValue(value);
+    }
+    return new ObjectValue(value);
+}
+function convertEntries(dataset) {
+    const entries = [];
+    const [rows, types] = dataset;
+    for (const row of rows) {
+        const record = row["$rowId"];
+        if (!record)
+            continue;
+        const context = {};
+        for (const key of Object.keys(row)) {
+            if (key === "$rowId")
+                continue;
+            const id = key;
+            context[id] = toEntry(row[id], types[id]);
+        }
+        entries.push(new BasesEntry(record.id, record.file, context));
+    }
+    return entries;
+}
+export class QueryController extends Component {
+    views;
+    readOnly;
+    app;
+    data = $state([]);
+    loadError = $state(null);
+    doc = $state();
+    properties = $state({});
+    formulas = $state({});
+    searchQuery = $state("");
+    searchPanelOpen = $state(false);
+    columns = $derived(columnsFor(this.data, this.properties, this.formulas, this.app));
+    frontMatterTypes = $derived(frontMatterTypesForColumns(this.columns));
+    db = $derived(Context.create(new BasesTable("bases")
+        .withApp(this.app)
+        .withPropertyColumns(this.frontMatterTypes)
+        .data(() => this.data)).withDefaultTable("bases"));
+    selectedView = $state();
+    #view = $state();
+    prevDoc = "";
+    lastViewResults = new WeakMap();
+    query = $derived(generateQuery(this.selectedView, this.formulas, this.doc.filters));
+    metadataDependencies = $derived.by(() => {
+        return collectMetadataDependencies({
+            documentFilter: this.doc.filters,
+            viewFilter: this.selectedView?.filter,
+            order: (this.selectedView?.order ?? []),
+            sort: this.selectedView?.sort ?? [],
+            groupByProperty: this.selectedView?.groupBy?.property ?? null,
+            imageProperty: typeof this.selectedView?.image === "string"
+                ? this.selectedView.image
+                : null,
+            formulas: this.formulas,
+        });
+    });
+    reloadSignature = $derived.by(() => {
+        return JSON.stringify({
+            documentFilter: $state.snapshot(this.doc.filters),
+            viewFilter: $state.snapshot(this.selectedView?.filter),
+            sort: $state.snapshot(this.selectedView?.sort ?? []),
+            limit: this.selectedView?.limit ?? 0,
+        });
+    });
+    dataset = $state([
+        [],
+        {},
+    ]);
+    queryResult = $derived.by(() => {
+        const visibleProperties = (this.selectedView?.order ??
+            []);
+        const entries = filterEntriesBySearch(convertEntries(this.dataset), visibleProperties, this.searchQuery);
+        return new BasesQueryResult(entries, this.getAllColumns().map((it) => it.id), this.selectedView?.groupBy?.property);
+    });
+    constructor(app, document, views, onChange, readOnly = false) {
+        super();
+        this.views = views;
+        this.readOnly = readOnly;
+        this.app = app;
+        this.doc = document;
+        this.properties = this.doc.properties || {};
+        this.formulas = this.doc.formulas || {};
+        this.selectedView =
+            this.doc.views.find((it) => it.name === this.doc.activeView) ||
+                this.doc.views[0] ||
+                unknownView();
+        this.prevDoc = JSON.stringify(document);
+        $effect(() => {
+            if (!this.selectedView)
+                return;
+            this.doc.activeView = this.selectedView.name;
+        });
+        $effect(() => {
+            const props = {
+                ...$state.snapshot(this.doc),
+                properties: $state.snapshot(this.properties),
+                formulas: $state.snapshot(this.formulas),
+            };
+            const content = JSON.stringify(props);
+            if (content !== this.prevDoc) {
+                onChange(props);
+                this.prevDoc = content;
+            }
+        });
+        $effect(() => {
+            if (!this.#view)
+                return;
+            this.syncViewData(this.#view, this.queryResult);
+        });
+        $effect(() => {
+            this.reloadSignature;
+            void this.reload();
+        });
+        $effect(() => {
+            this.dataset = this.getRecords(this.query);
+        });
+        this.registerEvent(this.app.metadataCache.on("index-changed", (change) => {
+            if (change.reset || change.domains.includes("metadata"))
+                void this.reload();
+        }));
+        this.registerEvent(this.app.metadataCache.on("loaded", () => {
+            void this.reload();
+        }));
+    }
+    get view() {
+        return this.#view;
+    }
+    set view(view) {
+        this.#view = view;
+    }
+    syncViewData(view, result) {
+        if (this.lastViewResults.get(view) === result) {
+            return;
+        }
+        this.lastViewResults.set(view, result);
+        view.data = result;
+        view.onDataUpdated();
+    }
+    get viewConfig() {
+        return this.views.get(this.selectedView.type) ?? this.views.get("unknown");
+    }
+    getRecords(qs) {
+        const types = {};
+        try {
+            const [columns, data] = this.db.execute(qs);
+            columns.forEach((col) => {
+                types[col.name.description] = col.type;
+            });
+            const dataset = data.map((row) => {
+                return columns.reduce((acc, value, i) => {
+                    acc[value.name.description] = row[i];
+                    return acc;
+                }, {});
+            });
+            return [dataset, types];
+        }
+        catch (e) {
+            console.error("Error executing query", e);
+            return [[], types];
+        }
+    }
+    getAllColumns() {
+        return Object.values(this.columns);
+    }
+    isVisible(id) {
+        return this.selectedView && this.selectedView.order.includes(id);
+    }
+    toggleVisibility(id) {
+        if (this.selectedView) {
+            const index = this.selectedView.order.findIndex((it) => it === id);
+            if (index === -1) {
+                this.selectedView.order.push(id);
+                return;
+            }
+            this.selectedView.order.splice(index, 1);
+        }
+    }
+    getColumn(id) {
+        return this.columns[id];
+    }
+    get count() {
+        return this.dataset[0].length;
+    }
+    get searchCount() {
+        return this.queryResult.data.length;
+    }
+    toggleSearchPanel() {
+        this.searchPanelOpen = !this.searchPanelOpen;
+    }
+    async reload() {
+        const generation = (this
+            ._reloadGeneration ?? 0) + 1;
+        this._reloadGeneration = generation;
+        try {
+            const rows = await queryBasesAppDatabaseRows(this.app.appDatabase, buildBasesAppDatabaseQuery({
+                documentFilter: this.doc.filters,
+                viewFilter: this.selectedView?.filter,
+                sort: this.selectedView?.sort ?? [],
+                limit: this.selectedView?.limit ?? 0,
+            }));
+            if (this
+                ._reloadGeneration !== generation) {
+                return;
+            }
+            const records = appDatabaseRowsToVaultRecords(this.app, rows);
+            if (this.metadataDependencies.backlinks && records.length) {
+                const backlinks = new Map();
+                for (let offset = 0; offset < records.length; offset += 400) {
+                    const links = await this.app.metadataCache.queryLinks({
+                        direction: "incoming",
+                        paths: records.slice(offset, offset + 400).map((record) => record.id),
+                        resolution: "resolved",
+                        limit: 100_000,
+                    });
+                    for (const link of links) {
+                        if (!link.resolvedTargetPath)
+                            continue;
+                        const sources = backlinks.get(link.resolvedTargetPath) ?? new Set();
+                        sources.add(link.sourcePath);
+                        backlinks.set(link.resolvedTargetPath, sources);
+                    }
+                }
+                for (const record of records) {
+                    record.backlinks = [...(backlinks.get(record.id) ?? [])];
+                }
+            }
+            this.loadError = null;
+            this.data = records;
+        }
+        catch (error) {
+            console.error("Error loading Bases rows from AppDatabase", error);
+            if (this
+                ._reloadGeneration !== generation) {
+                return;
+            }
+            this.loadError = error instanceof Error ? error.message : String(error);
+            this.data = [];
+        }
+    }
+}
+export class BasesView extends Component {
+    controller;
+    mountedView = null;
+    mountedViewContainer = null;
+    /**
+     * @since 1.10.0
+     * @public
+     */
+    app;
+    /**
+     * The config object for this view.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    config = $state(new SharedBasesViewConfig({
+        type: "unknown",
+        sort: [],
+        order: [],
+        limit: 0,
+        name: "Unknown",
+        filter: { and: [] },
+    }, {}));
+    /**
+     * The most recent output from executing the bases query, applying filters,
+     * and evaluating formulas. This object will be replaced with a new result set
+     * when changes to the vault or Bases config occur, so views should not keep a
+     * reference to it. Also note the contained BasesEntry objects will be
+     * recreated.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    data = $state(new BasesQueryResult([], []));
+    constructor(controller) {
+        super();
+        this.controller = controller;
+    }
+    mountViewComponent(component, props, containerEl) {
+        this.unmountViewComponent();
+        containerEl.replaceChildren();
+        const target = containerEl.createDiv("bases-view__renderer");
+        this.mountedViewContainer = target;
+        this.mountedView = mount(component, {
+            props,
+            target,
+        });
+    }
+    unmountViewComponent() {
+        if (this.mountedView) {
+            unmount(this.mountedView);
+            this.mountedView = null;
+        }
+        this.mountedViewContainer?.remove();
+        this.mountedViewContainer = null;
+    }
+    onunload() {
+        this.unmountViewComponent();
+    }
+    /**
+     * All available properties from the dataset.
+     *
+     * @since 1.10.0
+     * @public
+     */
+    get allProperties() {
+        if (!this.data)
+            return [];
+        return this.data.properties;
+    }
+    async createFileForView(baseFileName, frontmatterProcessor) {
+        const fileName = (baseFileName?.trim() || "Untitled").replace(/\.md$/i, "");
+        const path = this.app.fileManager.getAvailablePathForAttachment(`${fileName}.md`, "");
+        const file = await this.app.vault.create(path, "");
+        if (frontmatterProcessor) {
+            await this.app.fileManager.processFrontMatter(file, frontmatterProcessor);
+        }
+        await this.app.openFile(file);
+    }
+}
+/**
+ * A group of BasesEntry objects for a given value of the groupBy key. If there
+ * are entries in the results which do not have a value for the groupBy key, the
+ * key will be the {@link NullValue}.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class BasesEntryGroup {
+    entries;
+    key;
+    constructor(entries, key) {
+        this.entries = entries;
+        this.key = key;
+    }
+    /**
+     * @since 1.10.0
+     * @returns True iff this entry group has a non-null key.
+     * @public
+     */
+    hasKey() {
+        if (this.key === null || this.key === undefined) {
+            return false;
+        }
+        return this.key.isTruthy();
+    }
+}
+/**
+ * The BasesQueryResult contains all of the available information from executing
+ * the bases query, applying filters, and evaluating formulas. The `data` or
+ * `groupedData` should be displayed by your view.
+ *
+ * @since 1.10.0
+ * @public
+ */
+export class BasesQueryResult {
+    data;
+    properties;
+    groupBy;
+    constructor(data, properties, groupBy) {
+        this.data = data;
+        this.properties = properties;
+        this.groupBy = groupBy;
+    }
+    get groupedData() {
+        return groupEntries(this.data, this.groupBy, (left, right) => Value.looseEquals(left, right)).map((group) => new BasesEntryGroup(group.entries, group.key ?? undefined));
+    }
+    getSummaryValue(queryController, entries, prop, summaryKey) {
+        const values = entries
+            .map((entry) => entry.getValue(prop))
+            .filter((value) => !!value && !(value instanceof NullValue));
+        const numbers = values
+            .filter((value) => value instanceof NumberValue)
+            .map((value) => value.number);
+        switch (summaryKey.toLowerCase()) {
+            case "count":
+                return new NumberValue(entries.length);
+            case "count-empty":
+                return new NumberValue(entries.length - values.length);
+            case "count-non-empty":
+            case "count-filled":
+                return new NumberValue(values.length);
+            case "sum":
+                return numbers.length
+                    ? new NumberValue(numbers.reduce((total, value) => total + value, 0))
+                    : NullValue.value;
+            case "average":
+            case "avg":
+                return numbers.length
+                    ? new NumberValue(numbers.reduce((total, value) => total + value, 0) /
+                        numbers.length)
+                    : NullValue.value;
+            case "min":
+                return numbers.length
+                    ? new NumberValue(Math.min(...numbers))
+                    : NullValue.value;
+            case "max":
+                return numbers.length
+                    ? new NumberValue(Math.max(...numbers))
+                    : NullValue.value;
+            default:
+                return NullValue.value;
+        }
+    }
+}