@lapis-notes/bases 0.1.0

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

@@ -0,0 +1,66 @@
+import { DateTime, Duration } from "luxon";
+export declare function isEmpty(obj: unknown): boolean;
+export declare function isTruthy(value: unknown): boolean;
+export declare function valueToString(value: unknown): string;
+export declare function startsWith(source: string, value: string): boolean;
+export declare function endsWith(source: string, value: string): boolean;
+export declare function contains(source: string, value: string): boolean;
+export declare function containsAnyOf(source: string, ...values: Array<string>): boolean;
+export declare function containsAny(source: string, ...values: Array<string>): boolean;
+export declare function containsAllOf(source: string, ...values: Array<string>): boolean;
+export declare function containsAll(source: string, ...values: Array<string>): boolean;
+export declare function length(obj: unknown): any;
+export declare function title(str: string): string;
+export declare function trim(value: string): string;
+export declare function split(value: string, separator: string): string[];
+export declare function replace(value: string, search: string, replacement: string): string;
+export declare function repeat(value: string, count: number): string;
+export declare function reverseString(value: string): string;
+export declare function reverseList<T>(value: T[]): T[];
+export declare function sliceString(value: string, start: number, end?: number): string;
+export declare function sliceList<T>(value: T[], start: number, end?: number): T[];
+export declare function ceil(value: number): number;
+export declare function floor(value: number): number;
+export declare function list<T>(...value: T[]): T[];
+export declare function number(value: unknown): number | null;
+type Resolvable = {
+    resolve(context: any): any;
+};
+export declare function max(...value: number[]): number;
+export declare function min(...value: number[]): number;
+export declare function random(): number;
+export declare function flat<T>(value: T[]): (T extends readonly (infer InnerArr)[] ? InnerArr : T)[];
+export declare function join(value: unknown[], separator?: string): string;
+export declare function sortList<T>(value: T[]): T[];
+export declare function unique<T>(value: T[]): T[];
+export declare function escapeHTML(value: string): string;
+export declare function date(value: string | number | Date | DateTime): DateTime<boolean>;
+export declare function duration(value: string | number | Duration): Duration<boolean>;
+export declare function html(value: string): string;
+export declare function image(value: string): string;
+export declare function link(value: string): string;
+export declare function isType(value: unknown, type: string): boolean;
+export declare function file(value: string | {
+    path: string;
+}): string;
+export declare function asFile(value: string | {
+    path: string;
+}): string;
+export declare function asLink(value: string | {
+    path: string;
+}): string;
+export declare function linksTo(value: string | {
+    path: string;
+}, target: string | {
+    path: string;
+}): boolean;
+export declare function ifValue<TTruthy, TFalsy = null>(condition: unknown, truthy: TTruthy, falsy?: TFalsy): TTruthy | NonNullable<TFalsy> | null;
+export declare function mapItems(obj: any, items: Resolvable, expr: Resolvable): any;
+export declare function filterItems(obj: any, items: Resolvable, expr: Resolvable): any;
+export declare function reduceItems(obj: any, items: Resolvable, initial: Resolvable, expr: Resolvable): any;
+export declare function keys(value: Record<string, unknown>): string[];
+export declare function values(value: Record<string, unknown>): unknown[];
+export declare function matches(value: string, pattern: string | RegExp): boolean;
+export declare function relative(date: DateTime | Date): string | null | undefined;
+export declare function time(date: DateTime | Date): string | null | undefined;
+export {};

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

@@ -0,0 +1,265 @@
+import { startCase, toLower } from "lodash-es";
+import { DateTime, Duration } from "luxon";
+import { Decimal, isNull } from "peaql";
+export function isEmpty(obj) {
+    if (obj === null || obj === undefined)
+        return true;
+    if (typeof obj === "string") {
+        return obj.length == 0;
+    }
+    else if (Array.isArray(obj)) {
+        return obj.length == 0;
+    }
+    else if (typeof obj === "number") {
+        return obj === 0;
+    }
+    else if (obj instanceof Decimal) {
+        return obj.number === 0;
+    }
+    return false;
+}
+export function isTruthy(value) {
+    return Boolean(value);
+}
+export function valueToString(value) {
+    if (value === null || value === undefined)
+        return "";
+    return String(value);
+}
+export function startsWith(source, value) {
+    return source.startsWith(value);
+}
+export function endsWith(source, value) {
+    return source.endsWith(value);
+}
+export function contains(source, value) {
+    source = (source || "").toLowerCase();
+    return source.includes(value.toLowerCase());
+}
+export function containsAnyOf(source, ...values) {
+    source = (source || "").toLowerCase();
+    return values.some((v) => source.includes(v.toLowerCase()));
+}
+export function containsAny(source, ...values) {
+    return containsAnyOf(source, ...values);
+}
+export function containsAllOf(source, ...values) {
+    source = (source || "").toLowerCase();
+    return values.every((v) => source.includes(v.toLowerCase()));
+}
+export function containsAll(source, ...values) {
+    return containsAllOf(source, ...values);
+}
+export function length(obj) {
+    if (isNull(obj))
+        return 0;
+    if (Array.isArray(obj)) {
+        return obj.length;
+    }
+    else if (typeof obj === "string") {
+        return obj.length;
+    }
+    else if (typeof obj === "object") {
+        return Object.keys(obj).length;
+    }
+    return obj.toString().length;
+}
+export function title(str) {
+    return startCase(toLower(str));
+}
+export function trim(value) {
+    return value.trim();
+}
+export function split(value, separator) {
+    return value.split(separator);
+}
+export function replace(value, search, replacement) {
+    return value.replaceAll(search, replacement);
+}
+export function repeat(value, count) {
+    return value.repeat(count);
+}
+export function reverseString(value) {
+    return [...value].reverse().join("");
+}
+export function reverseList(value) {
+    return [...value].reverse();
+}
+export function sliceString(value, start, end) {
+    return value.slice(start, end);
+}
+export function sliceList(value, start, end) {
+    return value.slice(start, end);
+}
+export function ceil(value) {
+    return Math.ceil(value);
+}
+export function floor(value) {
+    return Math.floor(value);
+}
+export function list(...value) {
+    return value;
+}
+export function number(value) {
+    if (typeof value === "number")
+        return value;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function max(...value) {
+    return Math.max(...value);
+}
+export function min(...value) {
+    return Math.min(...value);
+}
+export function random() {
+    return Math.random();
+}
+export function flat(value) {
+    return value.flat();
+}
+export function join(value, separator = ",") {
+    return value.join(separator);
+}
+export function sortList(value) {
+    return [...value].sort((left, right) => {
+        if (typeof left === "number" && typeof right === "number") {
+            return left - right;
+        }
+        return String(left).localeCompare(String(right));
+    });
+}
+export function unique(value) {
+    return [...new Set(value)];
+}
+export function escapeHTML(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+export function date(value) {
+    if (value instanceof DateTime)
+        return value;
+    if (value instanceof Date)
+        return DateTime.fromJSDate(value);
+    if (typeof value === "number")
+        return DateTime.fromMillis(value);
+    return DateTime.fromISO(value);
+}
+export function duration(value) {
+    if (value instanceof Duration)
+        return value;
+    if (typeof value === "number")
+        return Duration.fromMillis(value);
+    return Duration.fromISO(value);
+}
+export function html(value) {
+    return value;
+}
+export function image(value) {
+    return value;
+}
+export function link(value) {
+    return value;
+}
+export function isType(value, type) {
+    switch (type.toLowerCase()) {
+        case "null":
+            return value === null || value === undefined;
+        case "list":
+            return Array.isArray(value);
+        case "date":
+            return value instanceof DateTime || value instanceof Date;
+        case "duration":
+            return value instanceof Duration;
+        case "regexp":
+            return value instanceof RegExp;
+        case "number":
+        case "string":
+        case "boolean":
+            return typeof value === type.toLowerCase();
+        case "object":
+            return !!value && typeof value === "object" && !Array.isArray(value);
+        default:
+            return false;
+    }
+}
+function normalizeFileLike(value) {
+    const path = typeof value === "string" ? value : value.path;
+    return path.replaceAll(/^\[\[|\]\]$/g, "");
+}
+export function file(value) {
+    return normalizeFileLike(value);
+}
+export function asFile(value) {
+    return file(value);
+}
+export function asLink(value) {
+    return `[[${normalizeFileLike(value)}]]`;
+}
+export function linksTo(value, target) {
+    return normalizeFileLike(value) === normalizeFileLike(target);
+}
+export function ifValue(condition, truthy, falsy) {
+    return condition ? truthy : (falsy ?? null);
+}
+export function mapItems(obj, items, expr) {
+    let values = items.resolve(obj);
+    if (isNull(values))
+        return null;
+    if (!Array.isArray(values)) {
+        values = [values];
+    }
+    return values.map((value, index) => expr.resolve({ ...(obj || {}), value, index }));
+}
+export function filterItems(obj, items, expr) {
+    let values = items.resolve(obj);
+    if (isNull(values))
+        return null;
+    if (!Array.isArray(values)) {
+        values = [values];
+    }
+    return values.filter((value, index) => !!expr.resolve({ ...(obj || {}), value, index }));
+}
+export function reduceItems(obj, items, initial, expr) {
+    let values = items.resolve(obj);
+    if (isNull(values))
+        return null;
+    if (!Array.isArray(values)) {
+        values = [values];
+    }
+    let accumulator = initial.resolve(obj);
+    values.forEach((value, index) => {
+        accumulator = expr.resolve({ ...(obj || {}), accumulator, value, index });
+    });
+    return accumulator;
+}
+export function keys(value) {
+    return Object.keys(value || {});
+}
+export function values(value) {
+    return Object.values(value || {});
+}
+export function matches(value, pattern) {
+    const expression = pattern instanceof RegExp ? pattern : new RegExp(pattern);
+    return expression.test(value);
+}
+export function relative(date) {
+    if (date instanceof Date) {
+        return relative(DateTime.fromJSDate(date));
+    }
+    if (!(date instanceof DateTime))
+        return;
+    return date.toRelative();
+}
+export function time(date) {
+    if (date instanceof Date) {
+        return relative(DateTime.fromJSDate(date));
+    }
+    if (!(date instanceof DateTime))
+        return;
+    return date.toISOTime();
+}

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

@@ -0,0 +1,5 @@
+export declare class Icon {
+    readonly name: string;
+    constructor(name: string);
+    toString(): string;
+}

package/dist/bases-view/functions.js

@@ -0,0 +1,107 @@
+import { normalizePath, TFile } from "@lapis-notes/api";
+import { createFunction, Decimal, VARARG } from "peaql";
+import { VaultFile } from "./db";
+import { DateTime, Duration } from "luxon";
+import { ceil, contains, containsAll, containsAllOf, containsAny, containsAnyOf, date, duration, endsWith, escapeHTML, file, filterItems, flat, floor, html, image, ifValue, isEmpty, isTruthy, isType, join, keys, length, list, link, linksTo, max, matches, min, number, relative, random, repeat, replace, reduceItems, reverseList, reverseString, sliceList, sliceString, sortList, split, startsWith, time, title, trim, unique, values, valueToString, asFile, asLink, mapItems, } from "./functions-core";
+createFunction("isEmpty", [Object], Boolean, isEmpty, true);
+createFunction("isTruthy", [Object], Boolean, isTruthy, true);
+createFunction("toString", [Object], String, valueToString, true);
+createFunction("startsWith", [String, String], Boolean, startsWith, true);
+createFunction("endsWith", [String, String], Boolean, endsWith, true);
+createFunction("contains", [String, String], Boolean, contains, true);
+createFunction("containsAnyOf", [String, VARARG, String], Boolean, containsAnyOf, true);
+createFunction("containsAny", [String, VARARG, String], Boolean, containsAny, true);
+createFunction("containsAllOf", [String, VARARG, String], Boolean, containsAllOf, true);
+createFunction("containsAll", [String, VARARG, String], Boolean, containsAll, true);
+createFunction("inFolder", [TFile, String], Boolean, inFolder, true);
+createFunction("inFolder", [VaultFile, String], Boolean, inFolder, true);
+function inFolder(file, path) {
+    path = normalizePath(path);
+    return file.path.startsWith(`${path}/`) || path == "/" || path == "";
+}
+createFunction("hasLink", [TFile, String], Boolean, hasLink, true);
+createFunction("hasLink", [VaultFile, String], Boolean, hasLink, true);
+function hasLink(file, path) {
+    const links = file.links ?? [];
+    return links.includes(path);
+}
+createFunction("hasTag", [VaultFile, VARARG, String], Boolean, hasTag, true);
+function hasTag(file, ...tags) {
+    tags = tags.map((t) => (t.startsWith("#") ? t : `#${t}`));
+    const fileTags = file.tags ?? [];
+    return fileTags.some((tag) => tags.some((value) => value === tag || tag.startsWith(`${value}/`)));
+}
+createFunction("hasProperty", [TFile, String], Boolean, hasProperty, true);
+createFunction("hasProperty", [VaultFile, String], Boolean, hasProperty, true);
+function hasProperty(file, path) {
+    const properties = file.properties ?? {};
+    return path in properties;
+}
+createFunction("length", [Object], Number, length, true);
+createFunction("map", [Object, Object], [Object], mapItems, true, {
+    index: Number,
+    value: Object,
+});
+export class Icon {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    toString() {
+        return this.name;
+    }
+}
+createFunction("icon", [String], Icon, icon, true);
+function icon(name) {
+    return new Icon(name);
+}
+createFunction("title", [String], String, title, true);
+createFunction("trim", [String], String, trim, true);
+createFunction("split", [String, String], [String], split, true);
+createFunction("replace", [String, String, String], String, replace, true);
+createFunction("repeat", [String, Number], String, repeat, true);
+createFunction("escapeHTML", [String], String, escapeHTML, true);
+createFunction("date", [String], DateTime, date, true);
+createFunction("date", [Number], DateTime, date, true);
+createFunction("date", [Date], DateTime, date, true);
+createFunction("date", [DateTime], DateTime, date, true);
+createFunction("duration", [String], Duration, duration, true);
+createFunction("duration", [Number], Duration, duration, true);
+createFunction("duration", [Duration], Duration, duration, true);
+createFunction("file", [String], String, file, true);
+createFunction("html", [String], String, html, true);
+createFunction("image", [String], String, image, true);
+createFunction("link", [String], String, link, true);
+createFunction("if", [Object, Object, Object], Object, ifValue, true);
+createFunction("list", [VARARG, Object], [Object], list, true);
+createFunction("number", [Object], Number, number, true);
+createFunction("max", [VARARG, Number], Number, max, true);
+createFunction("min", [VARARG, Number], Number, min, true);
+createFunction("random", [], Number, random, true);
+createFunction("flat", [Array], Array, flat, true);
+createFunction("filter", [Object, Object], [Object], filterItems, true);
+createFunction("join", [Array], String, join, true);
+createFunction("join", [Array, String], String, join, true);
+createFunction("reverse", [String], String, reverseString, true);
+createFunction("reverse", [Array], Array, reverseList, true);
+createFunction("reduce", [Object, Object, Object], Object, reduceItems, true);
+createFunction("slice", [String, Number], String, sliceString, true);
+createFunction("slice", [String, Number, Number], String, sliceString, true);
+createFunction("slice", [Array, Number], Array, sliceList, true);
+createFunction("slice", [Array, Number, Number], Array, sliceList, true);
+createFunction("sort", [Array], Array, sortList, true);
+createFunction("unique", [Array], Array, unique, true);
+createFunction("ceil", [Number], Number, ceil, true);
+createFunction("floor", [Number], Number, floor, true);
+createFunction("isType", [Object, String], Boolean, isType, true);
+createFunction("asFile", [String], String, asFile, true);
+createFunction("asLink", [String], String, asLink, true);
+createFunction("linksTo", [String, String], Boolean, linksTo, true);
+createFunction("keys", [Object], [String], keys, true);
+createFunction("values", [Object], [Object], values, true);
+createFunction("matches", [String, String], Boolean, matches, true);
+createFunction("matches", [String, RegExp], Boolean, matches, true);
+createFunction("relative", [DateTime], String, relative, true);
+createFunction("relative", [Date], String, relative, true);
+createFunction("time", [DateTime], String, time, true);
+createFunction("time", [Date], String, time, true);

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

@@ -0,0 +1,6 @@
+export declare function fuzzySearch<T extends Record<string, unknown>>(items: readonly T[], query: string, options: {
+    keys: ReadonlyArray<keyof T>;
+}): Array<{
+    item: T;
+    score: number;
+}>;

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

@@ -0,0 +1,15 @@
+import { prepareFuzzySearch } from "@lapis-notes/api";
+export function fuzzySearch(items, query, options) {
+    const normalized = query.trim();
+    if (!normalized) {
+        return items.map((item) => ({ item, score: 1 }));
+    }
+    const search = prepareFuzzySearch(normalized);
+    return items
+        .map((item) => {
+        const result = search(options.keys.map((key) => String(item[key] ?? "")).join(" "));
+        return result ? { item, score: result.score } : null;
+    })
+        .filter((result) => result !== null)
+        .sort((left, right) => right.score - left.score);
+}

package/dist/bases-view/hooks/useResizeObserver.svelte.d.ts

@@ -0,0 +1,7 @@
+export declare function useResizeObserver(): {
+    ref: HTMLElement;
+    readonly size: {
+        width: number;
+        height: number;
+    };
+};

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

@@ -0,0 +1,26 @@
+export function useResizeObserver() {
+    let size = $state({ width: 0, height: 0 });
+    let ref = $state(null);
+    $effect(() => {
+        if (!ref)
+            return;
+        const observer = new ResizeObserver(([entry]) => {
+            size = {
+                width: entry.contentRect.width,
+                height: entry.contentRect.height,
+            };
+        });
+        observer.observe(ref);
+        return () => {
+            observer.disconnect();
+        };
+    });
+    return {
+        set ref(el) {
+            ref = el;
+        },
+        get size() {
+            return size;
+        },
+    };
+}

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

@@ -0,0 +1,66 @@
+import { type App, MarkdownView, TFile, WorkspaceLeaf, type CachedMetadata, type MetadataType, type ViewStateResult } from "@lapis-notes/api";
+import type { Column, RowData } from "@tanstack/table-core";
+import { type BasesDocument } from "./models";
+import type { BasesViewRegistration } from "./bases.svelte";
+export * from "./models";
+export declare const BasesViewType = "bases";
+export declare const vaultKey: unique symbol;
+export type VaultRecord = {
+    id: string;
+    checksum?: string;
+    file: TFile;
+    cache: CachedMetadata | null;
+    backlinks?: string[];
+};
+declare module "@lapis-notes/api" {
+    interface IMetadataType {
+        file: "file";
+    }
+}
+declare module "@tanstack/table-core" {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        displayName: string;
+        icon: string;
+        type: MetadataType;
+        frontmatter?: boolean;
+    }
+}
+export declare function normalizeName(name: string): string;
+export declare function columnName(column: Column<any> | undefined): string;
+export type BasesViewModeType = "source" | "preview";
+export declare function serializeBasesDocument(content: BasesDocument): string;
+/** @deprecated Use serializeBasesDocument. */
+export declare const dumpDocument: typeof serializeBasesDocument;
+export declare function registerBuiltInBasesViews(views: Map<string, BasesViewRegistration>): void;
+export declare function createBasesViewRegistrations(app: App, registrations?: ReadonlyMap<string, BasesViewRegistration>): Map<string, BasesViewRegistration>;
+export declare function parseBasesDocument(content: string): BasesDocument;
+export declare class BasesView extends MarkdownView {
+    readonly views: Map<string, BasesViewRegistration>;
+    private readonly writeQueue;
+    constructor(leaf?: WorkspaceLeaf);
+    /**
+     * 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: string, registration: BasesViewRegistration): boolean;
+    getMode(): BasesViewModeType;
+    setState(state: Record<string, unknown>, result?: ViewStateResult): Promise<void>;
+    getViewData(): string;
+    setViewData(data: string, clear?: boolean): void;
+    clear(): void;
+    canAcceptExtension(extension: string): boolean;
+    private component;
+    private previewLoadVersion;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    load(): Promise<void> | void;
+    refresh(): void;
+    onunload(): void;
+    getViewType(): string;
+    getIcon(): string;
+    getDisplayText(): string;
+}