@lapis-notes/bases 0.1.0

package/dist/bases-view/metadata-type-info.d.ts

@@ -0,0 +1,7 @@
+import type { App, MetadataType } from "@lapis-notes/api";
+type MetadataTypeInfo = {
+    type: MetadataType;
+    icon: string;
+};
+export declare function getMetadataTypeInfo(key: string, fallbackType?: MetadataType, app?: Pick<App, "metadataTypeManager">): MetadataTypeInfo;
+export {};

package/dist/bases-view/metadata-type-info.js

@@ -0,0 +1,10 @@
+export function getMetadataTypeInfo(key, fallbackType = "text", app) {
+    const metadataTypeManager = app?.metadataTypeManager;
+    const type = metadataTypeManager?.properties?.[key]?.type ?? fallbackType;
+    const icon = metadataTypeManager?.registeredTypeWidgets?.[type ?? ""]?.icon ??
+        "lucide-file";
+    return {
+        type,
+        icon,
+    };
+}

package/dist/bases-view/models.d.ts

@@ -0,0 +1,90 @@
+import type { MetadataType } from "@lapis-notes/api";
+import type { BasesPropertyId } from "@lapis-notes/api";
+import type { ColumnDefinition } from "./columns";
+export type SortColumn = {
+    property: BasesPropertyId;
+    direction: "ASC" | "DESC";
+};
+export type FilterLine = {
+    column: string;
+    op: string;
+    value: string | Array<string>;
+    custom?: string | null;
+};
+export type Filters = {
+    and: Array<Filters | FilterLine | string>;
+} | {
+    or: Array<Filters | FilterLine | string>;
+} | {
+    not: Array<Filters | FilterLine | string>;
+};
+export declare function filterGroupType(filter: Filters): "and" | "or" | "not" | "";
+export declare function filterGroupValues(filter: Filters): Array<Filters | FilterLine | string>;
+export declare function filterCount(filter: Filters): number;
+export declare const filterLabels: Partial<Record<MetadataType, Array<{
+    label: string;
+    value: string;
+    type: string;
+}>>>;
+export declare function filterTypeFor(column: ColumnDefinition | null | undefined): Array<{
+    label: string;
+    value: string;
+    type: string;
+}>;
+export declare function filterLineFor(column: ColumnDefinition | null | undefined, value?: string): FilterLine;
+export declare function isFilterGroup(obj: unknown): obj is Filters;
+export declare function isFilterLine(obj: unknown): obj is FilterLine;
+export interface BasesViewBase {
+    name: string;
+    order: Array<string>;
+    sort: Array<SortColumn>;
+    groupBy?: SortColumn;
+    summaries?: Record<string, string>;
+    limit: number | null;
+    filter: Filters;
+    type: string;
+    [key: string]: unknown;
+}
+export interface BasesView<T extends keyof BasesViewMap = keyof BasesViewMap> extends BasesViewBase {
+    type: T;
+}
+export interface BasesViewMap {
+    table: TableView;
+    cards: CardsView;
+    list: ListView;
+    map: MapView;
+}
+export type BasesViewType = keyof BasesViewMap;
+export interface TableView extends BasesView<"table"> {
+    columnSize: Record<string, number>;
+    layout: "table" | "cards";
+    rowHeight?: "short" | "medium" | "tall" | "extra";
+    cardSize?: number;
+    image?: string;
+    imageFit?: "contain" | "cover";
+    imageAspectRatio: number;
+}
+export interface ListView extends BasesView<"list"> {
+}
+export interface CardsView extends BasesView<"cards"> {
+    cardSize?: number;
+    image?: string;
+    imageFit?: "contain" | "cover";
+    imageAspectRatio: number;
+}
+export interface MapView extends BasesView<"map"> {
+}
+export interface CustomBasesView extends BasesViewBase {
+    type: string;
+}
+export type AnyBasesView = BasesViewMap[keyof BasesViewMap] | CustomBasesView;
+export type BasesDocument = {
+    filters: Filters;
+    properties?: Record<string, {
+        displayName: string;
+    }>;
+    formulas?: Record<string, string>;
+    summaries?: Record<string, string>;
+    activeView: string;
+    views: Array<AnyBasesView>;
+};

package/dist/bases-view/models.js

@@ -0,0 +1,133 @@
+import { toSQL } from "./filter-parser";
+export function filterGroupType(filter) {
+    if (!filter)
+        return "";
+    if ("or" in filter)
+        return "or";
+    if ("not" in filter)
+        return "not";
+    if ("and" in filter)
+        return "and";
+    return "";
+}
+export function filterGroupValues(filter) {
+    if (!filter)
+        return [];
+    if ("and" in filter)
+        return filter.and;
+    if ("or" in filter)
+        return filter.or;
+    if ("not" in filter)
+        return filter.not;
+    return [];
+}
+export function filterCount(filter) {
+    let count = 0;
+    for (const predicate of filterGroupValues(filter)) {
+        if (typeof predicate === "string" && predicate.length) {
+            count += 1;
+        }
+        else if (isFilterLine(predicate)) {
+            count += 1;
+        }
+        else if (isFilterGroup(predicate)) {
+            count += filterCount(predicate);
+        }
+    }
+    return count;
+}
+export const filterLabels = {
+    datetime: [
+        { label: "on", value: "=", type: "datetime" },
+        { label: "not on", value: "!=", type: "datetime" },
+        { label: "before", value: "<", type: "datetime" },
+        { label: "on or before", value: "<=", type: "datetime" },
+        { label: "after", value: ">", type: "datetime" },
+        { label: "on or after", value: ">=", type: "datetime" },
+        { label: "is empty", value: "isEmpty", type: "none" },
+        { label: "is not empty", value: "!isEmpty", type: "none" },
+    ],
+    checkbox: [
+        { label: "is", value: "=", type: "checkbox" },
+        { label: "is not", value: "!=", type: "checkbox" },
+    ],
+    number: [
+        { label: "=", value: "=", type: "number" },
+        { label: "≠", value: "!=", type: "number" },
+        { label: "<", value: "<", type: "number" },
+        { label: "≤", value: "<=", type: "number" },
+        { label: ">", value: ">", type: "number" },
+        { label: "≥", value: ">=", type: "number" },
+        { label: "is empty", value: "isEmpty", type: "none" },
+        { label: "is not empty", value: "!isEmpty", type: "none" },
+    ],
+    text: [
+        { label: "is", value: "=", type: "text" },
+        { label: "is not", value: "!=", type: "text" },
+        { label: "starts with", value: "startsWith", type: "text" },
+        { label: "ends with", value: "endsWith", type: "text" },
+        { label: "is empty", value: "isEmpty", type: "none" },
+        { label: "contains", value: "contains", type: "text" },
+        { label: "contains any of", value: "containsAnyOf", type: "multitext" },
+        { label: "contains all of", value: "containsAllOf", type: "multitext" },
+        { label: "does not start with", value: "!startsWith", type: "text" },
+        { label: "does not end with", value: "!endsWith", type: "text" },
+        { label: "is not empty", value: "!isEmpty", type: "none" },
+        { label: "does not contain", value: "!contains", type: "text" },
+        {
+            label: "does not contain any of",
+            value: "!containsAnyOf",
+            type: "multitext",
+        },
+        {
+            label: "does not contain all of",
+            value: "!containsAllOf",
+            type: "multitext",
+        },
+    ],
+    file: [
+        { label: "links to", value: "hasLink", type: "file" },
+        { label: "in folder", value: "inFolder", type: "folder" },
+        { label: "has tag", value: "hasTag", type: "tags" },
+        { label: "has property", value: "hasProperty", type: "properties" },
+        { label: "does not link to", value: "!hasLink", type: "file" },
+        { label: "is not in folder", value: "!inFolder", type: "folder" },
+        { label: "does not have tag", value: "!hasTag", type: "tags" },
+        {
+            label: "does not have property",
+            value: "!hasProperty",
+            type: "properties",
+        },
+    ],
+    unknown: [
+        { label: "is", value: "=", type: "any" },
+        { label: "is not", value: "!=", type: "any" },
+        { label: "is truthy", value: "isTruthy", type: "none" },
+        { label: "is not truthy", value: "!isTruthy", type: "none" },
+        { label: "is empty", value: "isEmpty", type: "none" },
+        { label: "is not empty", value: "!isEmpty", type: "none" },
+    ],
+};
+export function filterTypeFor(column) {
+    const type = column?.type ?? "unknown";
+    return filterLabels[type] ?? filterLabels["unknown"] ?? [];
+}
+export function filterLineFor(column, value = "") {
+    const filterTypes = filterTypeFor(column);
+    return {
+        column: column?.id || "",
+        op: filterTypes[0].value || "",
+        value,
+    };
+}
+export function isFilterGroup(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return false;
+    const keys = Object.keys(obj);
+    return keys.length === 1 && ["and", "or", "not"].includes(keys[0]);
+}
+export function isFilterLine(obj) {
+    if (typeof obj !== "object" || obj === null || obj === undefined)
+        return false;
+    return "column" in obj && "op" in obj;
+}

package/dist/bases-view/query-result-core.d.ts

@@ -0,0 +1,8 @@
+export type GroupableEntry<TPropertyId extends string, TValue> = {
+    getValue(propertyId: TPropertyId): TValue | null;
+};
+export type GroupedEntries<TEntry, TValue> = {
+    entries: TEntry[];
+    key: TValue | null;
+};
+export declare function groupEntries<TPropertyId extends string, TValue, TEntry extends GroupableEntry<TPropertyId, TValue>>(entries: TEntry[], groupBy?: TPropertyId | null, equals?: (a: TValue | null, b: TValue | null) => boolean): GroupedEntries<TEntry, TValue>[];

package/dist/bases-view/query-result-core.js

@@ -0,0 +1,16 @@
+export function groupEntries(entries, groupBy, equals = Object.is) {
+    if (!groupBy) {
+        return [{ entries, key: null }];
+    }
+    const groups = [];
+    for (const entry of entries) {
+        const key = entry.getValue(groupBy) ?? null;
+        let group = groups.find((candidate) => equals(candidate.key, key));
+        if (!group) {
+            group = { entries: [], key };
+            groups.push(group);
+        }
+        group.entries.push(entry);
+    }
+    return groups;
+}

package/dist/bases-view/resource-url.d.ts

@@ -0,0 +1,2 @@
+import type { App, TFile } from "@lapis-notes/api";
+export declare function loadBasesResourceUrl(app: Pick<App, "vault">, file: TFile, onReady: (url: string) => void): () => void;

package/dist/bases-view/resource-url.js

@@ -0,0 +1,21 @@
+export function loadBasesResourceUrl(app, file, onReady) {
+    let disposed = false;
+    let currentUrl = "";
+    void app.vault
+        .getResourceUrl(file)
+        .then((url) => {
+        if (disposed) {
+            app.vault.revokeResourceUrl(url);
+            return;
+        }
+        currentUrl = url;
+        onReady(url);
+    })
+        .catch(() => { });
+    return () => {
+        disposed = true;
+        if (currentUrl) {
+            app.vault.revokeResourceUrl(currentUrl);
+        }
+    };
+}

package/dist/bases-view/search-core.d.ts

@@ -0,0 +1,9 @@
+type SearchValue = {
+    toString(): string;
+};
+type SearchEntry<TPropertyId extends string = string> = {
+    getValue(propertyId: TPropertyId): SearchValue | null;
+};
+export declare function matchesSearch<TPropertyId extends string, TEntry extends SearchEntry<TPropertyId>>(entry: TEntry, properties: TPropertyId[], query: string): boolean;
+export declare function filterEntriesBySearch<TPropertyId extends string, TEntry extends SearchEntry<TPropertyId>>(entries: TEntry[], properties: TPropertyId[], query: string): TEntry[];
+export {};

package/dist/bases-view/search-core.js

@@ -0,0 +1,20 @@
+function normalizeQuery(query) {
+    return query.trim().toLocaleLowerCase();
+}
+export function matchesSearch(entry, properties, query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (!normalizedQuery)
+        return true;
+    return properties.some((propertyId) => {
+        const value = entry.getValue(propertyId);
+        return value
+            ? value.toString().toLocaleLowerCase().includes(normalizedQuery)
+            : false;
+    });
+}
+export function filterEntriesBySearch(entries, properties, query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (!normalizedQuery)
+        return entries;
+    return entries.filter((entry) => matchesSearch(entry, properties, normalizedQuery));
+}

package/dist/bases-view/summary-core.d.ts

@@ -0,0 +1,7 @@
+export type SummaryConfig = Record<string, string> | undefined;
+export type ConfiguredSummary = {
+    propertyId: string;
+    summaryKey: string;
+};
+export declare function resolveConfiguredSummaries(order: string[], baseSummaries?: SummaryConfig, viewSummaries?: SummaryConfig): ConfiguredSummary[];
+export declare function formatSummaryLabel(summaryKey: string): string;

package/dist/bases-view/summary-core.js

@@ -0,0 +1,17 @@
+export function resolveConfiguredSummaries(order, baseSummaries, viewSummaries) {
+    const merged = {
+        ...(baseSummaries ?? {}),
+        ...(viewSummaries ?? {}),
+    };
+    return order.flatMap((propertyId) => {
+        const summaryKey = merged[propertyId];
+        return summaryKey ? [{ propertyId, summaryKey }] : [];
+    });
+}
+export function formatSummaryLabel(summaryKey) {
+    if (!summaryKey)
+        return "";
+    return summaryKey
+        .replaceAll(/[-_]+/g, " ")
+        .replace(/\b\w/g, (character) => character.toUpperCase());
+}