@lapis-notes/bases 0.1.0

package/dist/bases-view/index.js

@@ -0,0 +1,231 @@
+import { FileView, MarkdownView, TFile, useLocale, View, WorkspaceLeaf, } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import {} from "./models";
+import NoteEditor from "@lapis-notes/api/editor";
+import * as yaml from "js-yaml";
+import { TableView } from "./table-view/index.svelte";
+import { UnknownView } from "./unknown-view";
+import { CardView } from "./card-view";
+import { ListView } from "./list-view";
+import { MapView } from "./map-view";
+import { normalizeBasesDocument } from "./document-core";
+import { SerializedWriteQueue } from "../serialized-write-queue";
+import { BUILT_IN_BASES_VIEW_ITEMS, } from "./view-registration-inventory";
+export * from "./models";
+export const BasesViewType = "bases";
+const { t } = useLocale("bases");
+export const vaultKey = Symbol("vaultKey");
+export function normalizeName(name) {
+    return name.replaceAll(/[^a-zA-Z0-9 ]/g, " ").trim();
+}
+export function columnName(column) {
+    if (!column)
+        return "";
+    return column.columnDef.meta?.displayName ?? normalizeName(column.id);
+}
+export function serializeBasesDocument(content) {
+    const data = yaml
+        .dump(content, {
+        noCompatMode: true,
+        schema: yaml.JSON_SCHEMA,
+    })
+        .trim();
+    return data;
+}
+/** @deprecated Use serializeBasesDocument. */
+export const dumpDocument = serializeBasesDocument;
+export function registerBuiltInBasesViews(views) {
+    const implementations = {
+        table: {
+            factory: (controller, containerEl) => new TableView(controller, containerEl),
+            options: TableView.getViewOptions,
+        },
+        unknown: {
+            factory: (controller, containerEl) => new UnknownView(controller, containerEl),
+            options: UnknownView.getViewOptions,
+        },
+        cards: {
+            factory: (controller, containerEl) => new CardView(controller, containerEl),
+            options: CardView.getViewOptions,
+        },
+        list: {
+            factory: (controller, containerEl) => new ListView(controller, containerEl),
+            options: ListView.getViewOptions,
+        },
+        map: {
+            factory: (controller, containerEl) => new MapView(controller, containerEl),
+            options: MapView.getViewOptions,
+        },
+    };
+    for (const item of BUILT_IN_BASES_VIEW_ITEMS) {
+        views.set(item.id, { ...item, ...implementations[item.id] });
+    }
+}
+export function createBasesViewRegistrations(app, registrations) {
+    const views = new Map();
+    registerBuiltInBasesViews(views);
+    for (const [viewId, registration,] of app.plugins.getBasesViewRegistrations()) {
+        views.set(viewId, registration);
+    }
+    for (const [viewId, registration] of registrations ?? []) {
+        views.set(viewId, registration);
+    }
+    return views;
+}
+export function parseBasesDocument(content) {
+    return normalizeBasesDocument(yaml.load(content));
+}
+export class BasesView extends MarkdownView {
+    views;
+    writeQueue;
+    constructor(leaf) {
+        super(leaf);
+        this.state["mode"] ||= "preview";
+        this.views = createBasesViewRegistrations(this.app);
+        this.writeQueue = new SerializedWriteQueue(({ file, content }) => this.app.vault.modify(file, content));
+    }
+    /**
+     * Register a Base view handler that can be used to render data from property
+     * queries.
+     *
+     * @since 1.10.0
+     * @returns False if bases are not enabled in this vault.
+     * @public
+     */
+    registerBasesView(viewId, registration) {
+        this.views.set(viewId, registration);
+        return true;
+    }
+    getMode() {
+        return this.getState()["mode"] || "preview";
+    }
+    setState(state, result) {
+        const previous = { ...this.getState() };
+        return super.setState(state, result).then(() => {
+            if (state.mode !== previous.mode) {
+                this.load();
+            }
+        });
+    }
+    getViewData() {
+        return this.editor.getValue();
+    }
+    setViewData(data, clear) {
+        this.editor.setValue(data);
+    }
+    clear() {
+        this.editor.setValue("");
+    }
+    canAcceptExtension(extension) {
+        return ["bases", "base"].includes(extension);
+    }
+    component;
+    previewLoadVersion = 0;
+    onOpen() {
+        return Promise.resolve();
+    }
+    async onClose() {
+        await this.writeQueue.flush();
+    }
+    load() {
+        if (this.containerEl) {
+            const loadVersion = ++this.previewLoadVersion;
+            this.unload();
+            this.containerEl.empty();
+            this.actions = [];
+            const mode = this.getMode();
+            if (mode === "preview") {
+                this.containerEl.addClass("mod-loader");
+                this.addAction("pencil", `${t("Current view: preview")}\n${t("Click to edit")}\n${t("⌘+Click to open to the right")}`, (evt) => {
+                    if (evt.metaKey || evt.ctrlKey) {
+                        const leaf = this.app.workspace.getLeaf("split", "horizontal");
+                        const state = { ...this.leaf.state };
+                        state.state ||= {};
+                        state.state["mode"] = "source";
+                        leaf.setViewState(state);
+                    }
+                    else {
+                        this.setState({ ...this.getState(), mode: "source" });
+                    }
+                    this.app.workspace.requestSaveLayout();
+                });
+                const doc = parseBasesDocument(this.editor.getValue());
+                void import("./view.svelte").then(({ default: BasesComponent }) => {
+                    if (loadVersion !== this.previewLoadVersion ||
+                        this.getMode() !== "preview" ||
+                        !this.containerEl) {
+                        return;
+                    }
+                    this.component = mount(BasesComponent, {
+                        target: this.containerEl,
+                        props: {
+                            app: this.app,
+                            host: this,
+                            registrations: this.views,
+                            onChange: (doc) => {
+                                const content = serializeBasesDocument(doc);
+                                this.editor.setValue(content);
+                                if (this.file) {
+                                    this.writeQueue.enqueue({
+                                        file: this.file,
+                                        content,
+                                    });
+                                }
+                            },
+                            readOnly: false,
+                            showHeader: true,
+                            document: doc,
+                        },
+                    });
+                });
+            }
+            else {
+                this.containerEl.removeClass("mod-loader");
+                this.editor.updateExtensions(this.app.editorExtensions(BasesViewType, {
+                    file: this.file?.path,
+                    mode: "source",
+                }));
+                this.addAction("book-open", `${t("Current view: editing")}\n${t("Click to read")}\n${t("⌘+Click to open to the right")}`, (evt) => {
+                    if (evt.metaKey || evt.ctrlKey) {
+                        const leaf = this.app.workspace.getLeaf("split", "horizontal");
+                        const state = { ...this.leaf.state };
+                        state.state ||= {};
+                        state.state["mode"] = "preview";
+                        leaf.setViewState(state);
+                    }
+                    else {
+                        this.setState({ ...this.getState(), mode: "preview" });
+                    }
+                    this.app.workspace.requestSaveLayout();
+                });
+                this.component = mount(NoteEditor, {
+                    target: this.containerEl,
+                    props: {
+                        app: this.app,
+                        leaf: this.leaf,
+                        editor: this.editor,
+                    },
+                });
+            }
+        }
+    }
+    refresh() {
+        this.load();
+    }
+    onunload() {
+        void this.writeQueue.flush();
+        if (this.component) {
+            unmount(this.component);
+            this.component = null;
+        }
+    }
+    getViewType() {
+        return BasesViewType;
+    }
+    getIcon() {
+        return "lucide-database";
+    }
+    getDisplayText() {
+        return this.file?.baseName ?? t("Bases");
+    }
+}

package/dist/bases-view/list-view/index.d.ts

@@ -0,0 +1,10 @@
+import type { BasesOptions } from "@lapis-notes/api";
+import { BasesView, QueryController } from "../bases.svelte";
+export declare class ListView extends BasesView {
+    readonly controller: QueryController;
+    readonly scrollEl: HTMLElement;
+    type: string;
+    constructor(controller: QueryController, scrollEl: HTMLElement);
+    onDataUpdated(): void;
+    static getViewOptions(): BasesOptions[];
+}

package/dist/bases-view/list-view/index.js

@@ -0,0 +1,17 @@
+import { BasesView, QueryController } from "../bases.svelte";
+import ListViewComponent from "./list.svelte";
+export class ListView extends BasesView {
+    controller;
+    scrollEl;
+    type = "list";
+    constructor(controller, scrollEl) {
+        super(controller);
+        this.controller = controller;
+        this.scrollEl = scrollEl;
+        this.mountViewComponent(ListViewComponent, { view: this }, scrollEl);
+    }
+    onDataUpdated() { }
+    static getViewOptions() {
+        return [];
+    }
+}

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

@@ -0,0 +1,156 @@
+<script lang="ts">
+  import type { MetadataType } from "@lapis-notes/api";
+  import ChevronDown from "@lucide/svelte/icons/chevron-down";
+  import ChevronRight from "@lucide/svelte/icons/chevron-right";
+  import Cell from "../cell.svelte";
+  import type { BasesView } from "../bases.svelte";
+  import SummaryStrip from "../components/summary-strip.svelte";
+  import { getMetadataTypeInfo } from "../metadata-type-info";
+
+  let {
+    view,
+  }: {
+    view: BasesView;
+  } = $props();
+
+  let groups = $derived(view.data.groupedData);
+  let groupBy = $derived(view.data.groupBy);
+  let groupLabel = $derived.by(() => {
+    if (!groupBy) return "";
+    return view.config.getDisplayName(groupBy) || groupBy;
+  });
+  let types = $derived.by(() => {
+    return view.allProperties.reduce<Record<string, { type: MetadataType }>>(
+      (acc, id) => {
+        if (id.startsWith("note.")) {
+          const key = id.substring(5);
+          acc[id] = {
+            type: getMetadataTypeInfo(
+              key,
+              "text",
+              view.controller.app,
+            ).type,
+          };
+        } else {
+          acc[id] = { type: "text" };
+        }
+        return acc;
+      },
+      {},
+    );
+  });
+  let visibleProperties = $derived(view.config.getOrder());
+  let showsFileIdentity = $derived.by(() => {
+    return visibleProperties.some((id) =>
+      [
+        "file",
+        "file.name",
+        "file.basename",
+        "file.file",
+        "file.fullname",
+      ].includes(id),
+    );
+  });
+  let collapsedGroups = $state<Record<string, boolean>>({});
+
+  function groupId(
+    group: { key?: { toString(): string } | null },
+    index: number,
+  ) {
+    return `${groupBy || "ungrouped"}:${group.key?.toString() ?? `ungrouped_${index}`}`;
+  }
+
+  function isCollapsed(
+    group: { key?: { toString(): string } | null },
+    index: number,
+  ) {
+    return !!collapsedGroups[groupId(group, index)];
+  }
+
+  function toggleGroup(
+    group: { key?: { toString(): string } | null },
+    index: number,
+  ) {
+    const key = groupId(group, index);
+    collapsedGroups = {
+      ...collapsedGroups,
+      [key]: !collapsedGroups[key],
+    };
+  }
+</script>
+
+<div
+  class="bases-card-grid bases-style-h-full-668b21 bases-style-overflow-auto-73fc3f bases-style-px-4-f0faeb bases-style-pb-10-cbd82b"
+  data-layout="list"
+  data-ui-component="bases-list-view"
+  data-ui-part="viewport"
+>
+  <SummaryStrip
+    {view}
+    class="bases-card-grid__summary sticky bases-style-top-0-216740 bases-style-z-20-145745 bases-style-border-b-65fdba bases-style-px-1-d8e0e3 bases-style-py-3-1b2d54 backdrop-blur"
+  />
+  {#each groups as group, index (index)}
+    {#if groupBy}
+      <div
+        class="bases-card-grid__group-header sticky bases-style-top-0-216740 bases-style-z-10-236812 bases-style-border-b-65fdba bases-style-px-1-d8e0e3 bases-style-py-3-1b2d54 bases-style-text-xs-359090 bases-style-font-semibold-e83a70 bases-style-tracking-0-18em-a82f6f uppercase backdrop-blur"
+      >
+        <button
+          type="button"
+          data-ui-part="group-toggle"
+          class="bases-style-flex-60fbb7 bases-style-w-full-6da6a3 bases-style-items-center-3960ff bases-style-gap-2-77a2a2 bases-style-text-left-2eba0d"
+          aria-expanded={!isCollapsed(group, index)}
+          onclick={() => toggleGroup(group, index)}
+        >
+          {#if isCollapsed(group, index)}
+            <ChevronRight class="bases-style-size-4-f7b5fa bases-style-shrink-0-012fbd" />
+          {:else}
+            <ChevronDown class="bases-style-size-4-f7b5fa bases-style-shrink-0-012fbd" />
+          {/if}
+          <span>{groupLabel}</span>
+          <span class="bases-card-grid__group-value">
+            {#if group.hasKey()}
+              {group.key?.toString()}
+            {:else}
+              Ungrouped
+            {/if}
+          </span>
+        </button>
+      </div>
+    {/if}
+
+    {#if !isCollapsed(group, index)}
+      <ul class="bases-style-marker-text-muted-foreground-ff5bf1 bases-style-list-disc-1f33b4 bases-style-space-y-2-6f7e01 bases-style-py-3-1b2d54 bases-style-pl-6-9079b6">
+        {#each group.entries as row (row.id)}
+          <li
+            class="bases-style-text-card-foreground-0474d7 bases-style-text-sm-fc7473 bases-style-leading-6-18550d"
+            data-ui-part="row"
+          >
+            {#if !showsFileIdentity}
+              <span class="bases-style-font-medium-2689f3">{row.file.basename}</span>
+              {#if visibleProperties.length > 0}
+                <span class="bases-style-text-muted-foreground-bfa603">, </span>
+              {/if}
+            {/if}
+
+            {#each visibleProperties as id, index (id)}
+              <span class="bases-style-inline-block-bb0c4b bases-style-align-baseline-8d378d">
+                <Cell
+                  app={view.controller.app}
+                  name={id}
+                  file={row.file}
+                  readOnly={view.controller.readOnly}
+                  type={types[id]?.type}
+                  value={row.getValue(id)}
+                  class="bases-style-inline-block-bb0c4b bases-style-h-auto-b8f0a0 bases-style-w-auto-23e1f6 bases-style-align-baseline-8d378d"
+                />
+              </span>
+              {#if index < visibleProperties.length - 1}
+                <span class="bases-style-text-muted-foreground-bfa603">, </span>
+              {/if}
+            {/each}
+          </li>
+        {/each}
+      </ul>
+    {/if}
+  {/each}
+</div>

package/dist/bases-view/list-view/list.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { BasesView } from "../bases.svelte";
+type $$ComponentProps = {
+    view: BasesView;
+};
+declare const List: import("svelte").Component<$$ComponentProps, {}, "">;
+type List = ReturnType<typeof List>;
+export default List;

package/dist/bases-view/map-view/index.d.ts

@@ -0,0 +1,10 @@
+import type { BasesOptions } from "@lapis-notes/api";
+import { BasesView, QueryController } from "../bases.svelte";
+export declare class MapView extends BasesView {
+    readonly controller: QueryController;
+    readonly scrollEl: HTMLElement;
+    type: string;
+    constructor(controller: QueryController, scrollEl: HTMLElement);
+    onDataUpdated(): void;
+    static getViewOptions(): BasesOptions[];
+}

package/dist/bases-view/map-view/index.js

@@ -0,0 +1,17 @@
+import { BasesView, QueryController } from "../bases.svelte";
+import MapViewComponent from "./view.svelte";
+export class MapView extends BasesView {
+    controller;
+    scrollEl;
+    type = "map";
+    constructor(controller, scrollEl) {
+        super(controller);
+        this.controller = controller;
+        this.scrollEl = scrollEl;
+        this.mountViewComponent(MapViewComponent, { view: this }, scrollEl);
+    }
+    onDataUpdated() { }
+    static getViewOptions() {
+        return [];
+    }
+}

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

@@ -0,0 +1,28 @@
+<script lang="ts">
+  import type { BasesView } from "../bases.svelte";
+  import SummaryStrip from "../components/summary-strip.svelte";
+
+  let {
+    view,
+  }: {
+    view: BasesView;
+  } = $props();
+</script>
+
+<div
+  class="bases-style-flex-60fbb7 bases-style-h-full-668b21 bases-style-flex-col-8dddea bases-style-gap-3-1004c0 bases-style-border-t-b950dd bases-style-px-4-f0faeb bases-style-py-5-c9b99c bases-style-text-sm-fc7473"
+  data-layout="map"
+  data-ui-component="bases-map-view"
+  data-ui-part="unavailable"
+>
+  <SummaryStrip {view} />
+  <div class="bases-style-font-medium-2689f3">Map view is not available in this runtime yet.</div>
+  <p class="bases-style-text-muted-foreground-bfa603">
+    This Base can keep a `map` layout in its config, but the current runtime
+    only provides an explicit fallback state until map capability is
+    implemented.
+  </p>
+  <p class="bases-style-text-muted-foreground-bfa603">
+    Current result count: {view.data.data.length}
+  </p>
+</div>

package/dist/bases-view/map-view/view.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { BasesView } from "../bases.svelte";
+type $$ComponentProps = {
+    view: BasesView;
+};
+declare const View: import("svelte").Component<$$ComponentProps, {}, "">;
+type View = ReturnType<typeof View>;
+export default View;

package/dist/bases-view/metadata-invalidation-core.d.ts

@@ -0,0 +1,34 @@
+import type { BasesPropertyId, CachedMetadata } from "@lapis-notes/api";
+import { type Filters, type SortColumn } from "./models";
+export type MetadataDependencySet = {
+    custom: boolean;
+    tags: boolean;
+    links: boolean;
+    backlinks: boolean;
+    properties: Set<string>;
+    propertyPresence: boolean;
+    staticFileFields: Set<string>;
+    dynamicFileFields: Set<string>;
+};
+type MetadataDependencyInput = {
+    documentFilter: Filters;
+    viewFilter: Filters | undefined;
+    order: BasesPropertyId[];
+    sort: SortColumn[];
+    groupByProperty?: BasesPropertyId | null;
+    imageProperty?: BasesPropertyId | null;
+    formulas: Record<string, string>;
+};
+type MetadataInvalidationInput = {
+    changedPath: string;
+    currentResultPaths: string[];
+    cache: CachedMetadata | null;
+    prevCache: CachedMetadata | null;
+    dependencies: MetadataDependencySet;
+    isDirectlyAffectedByPathChange: (watchedPath: string, changedPath: string) => boolean;
+};
+export declare function createMetadataDependencySet(): MetadataDependencySet;
+export declare function collectMetadataDependencies(input: MetadataDependencyInput): MetadataDependencySet;
+export declare function cacheMatchesDependencies(cache: CachedMetadata | null | undefined, dependencies: MetadataDependencySet): boolean;
+export declare function shouldReloadForMetadataChange(input: MetadataInvalidationInput): boolean;
+export {};

package/dist/bases-view/metadata-invalidation-core.js

@@ -0,0 +1,162 @@
+import { isFilterGroup, isFilterLine, } from "./models";
+const DYNAMIC_FILE_FIELDS = new Set(["file.mtime", "file.size"]);
+export function createMetadataDependencySet() {
+    return {
+        custom: false,
+        tags: false,
+        links: false,
+        backlinks: false,
+        properties: new Set(),
+        propertyPresence: false,
+        staticFileFields: new Set(),
+        dynamicFileFields: new Set(),
+    };
+}
+function trackPropertyDependency(dependencies, propertyId) {
+    if (!propertyId) {
+        return;
+    }
+    if (propertyId === "file") {
+        return;
+    }
+    if (propertyId.startsWith("formula.")) {
+        dependencies.custom = true;
+        return;
+    }
+    if (propertyId === "file.tags") {
+        dependencies.tags = true;
+        return;
+    }
+    if (propertyId === "file.links" ||
+        propertyId === "file.embeds") {
+        dependencies.links = true;
+        return;
+    }
+    if (propertyId === "file.backlinks") {
+        dependencies.links = true;
+        dependencies.backlinks = true;
+        return;
+    }
+    if (propertyId === "file.properties") {
+        dependencies.propertyPresence = true;
+        return;
+    }
+    if (propertyId.startsWith("file.")) {
+        if (DYNAMIC_FILE_FIELDS.has(propertyId)) {
+            dependencies.dynamicFileFields.add(propertyId);
+        }
+        else {
+            dependencies.staticFileFields.add(propertyId);
+        }
+        return;
+    }
+    const normalized = propertyId.startsWith("note.")
+        ? propertyId.slice("note.".length)
+        : propertyId;
+    if (normalized.length > 0) {
+        dependencies.properties.add(normalized);
+    }
+}
+function trackFilterLineDependencies(dependencies, filter) {
+    if (filter.custom || filter.column.startsWith("formula.")) {
+        dependencies.custom = true;
+        return;
+    }
+    trackPropertyDependency(dependencies, filter.column);
+    if (filter.op === "hasTag" || filter.op === "!hasTag") {
+        dependencies.tags = true;
+    }
+    if (filter.op === "hasLink" || filter.op === "!hasLink") {
+        dependencies.links = true;
+    }
+    if (filter.op === "hasProperty" || filter.op === "!hasProperty") {
+        dependencies.propertyPresence = true;
+        const values = Array.isArray(filter.value) ? filter.value : [filter.value];
+        for (const value of values) {
+            if (typeof value === "string" && value.trim().length > 0) {
+                dependencies.properties.add(value.trim());
+            }
+        }
+    }
+    if (filter.op === "inFolder" || filter.op === "!inFolder") {
+        dependencies.staticFileFields.add("file.folder");
+    }
+}
+function collectFilterDependencies(dependencies, filter) {
+    if (!filter) {
+        return;
+    }
+    if (typeof filter === "string") {
+        if (filter.trim().length > 0) {
+            dependencies.custom = true;
+        }
+        return;
+    }
+    if (isFilterLine(filter)) {
+        trackFilterLineDependencies(dependencies, filter);
+        return;
+    }
+    if (isFilterGroup(filter)) {
+        const values = "and" in filter ? filter.and : "or" in filter ? filter.or : filter.not;
+        for (const entry of values) {
+            collectFilterDependencies(dependencies, entry);
+        }
+    }
+}
+export function collectMetadataDependencies(input) {
+    const dependencies = createMetadataDependencySet();
+    collectFilterDependencies(dependencies, input.documentFilter);
+    collectFilterDependencies(dependencies, input.viewFilter);
+    for (const propertyId of input.order) {
+        trackPropertyDependency(dependencies, propertyId);
+    }
+    for (const sort of input.sort) {
+        trackPropertyDependency(dependencies, sort.property);
+    }
+    trackPropertyDependency(dependencies, input.groupByProperty ?? null);
+    trackPropertyDependency(dependencies, input.imageProperty ?? null);
+    if (Object.keys(input.formulas).length > 0) {
+        dependencies.custom = true;
+    }
+    return dependencies;
+}
+export function cacheMatchesDependencies(cache, dependencies) {
+    if (!cache) {
+        return false;
+    }
+    if (dependencies.tags && (cache.tags?.length ?? 0) > 0) {
+        return true;
+    }
+    if (dependencies.links &&
+        ((cache.links?.length ?? 0) > 0 || (cache.embeds?.length ?? 0) > 0)) {
+        return true;
+    }
+    const frontmatter = cache.frontmatter ?? {};
+    if (dependencies.propertyPresence && Object.keys(frontmatter).length > 0) {
+        return true;
+    }
+    for (const property of dependencies.properties) {
+        if (property in frontmatter) {
+            return true;
+        }
+    }
+    return false;
+}
+export function shouldReloadForMetadataChange(input) {
+    if (input.currentResultPaths.includes(input.changedPath)) {
+        return true;
+    }
+    if (input.dependencies.links) {
+        for (const path of input.currentResultPaths) {
+            if (input.isDirectlyAffectedByPathChange(path, input.changedPath)) {
+                return true;
+            }
+        }
+    }
+    if (input.dependencies.custom ||
+        input.dependencies.dynamicFileFields.size > 0) {
+        return true;
+    }
+    return (cacheMatchesDependencies(input.cache, input.dependencies) ||
+        cacheMatchesDependencies(input.prevCache, input.dependencies));
+}