@lapis-notes/api 0.1.0

package/dist/bases.js

@@ -0,0 +1,475 @@
+import { DateTime, Duration } from "luxon";
+import { mount, unmount } from "svelte";
+import { resolveApplication } from "./application-compatibility";
+import { Component } from "./view.svelte";
+export class Value {
+    static type;
+    static equals(a, b) {
+        if (!a || !b)
+            return a === b;
+        return a.equals(b);
+    }
+    static looseEquals(a, b) {
+        if (!a || !b)
+            return a === b;
+        return a.looseEquals(b);
+    }
+    equals(other) {
+        return this === other;
+    }
+    looseEquals(other) {
+        return this.equals(other);
+    }
+    renderTo(el, ctx) {
+        el.textContent = this.toString();
+    }
+}
+export class NotNullValue extends Value {
+    isTruthy() {
+        return true;
+    }
+}
+export class PrimitiveValue extends NotNullValue {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return String(this.value);
+    }
+    isTruthy() {
+        return Boolean(this.value);
+    }
+    equals(other) {
+        return other instanceof PrimitiveValue && this.value === other.value;
+    }
+}
+export class NullValue extends Value {
+    static value = new NullValue();
+    get value() {
+        return null;
+    }
+    toString() {
+        return "";
+    }
+    isTruthy() {
+        return false;
+    }
+    equals(other) {
+        return other instanceof NullValue;
+    }
+    looseEquals(other) {
+        return other instanceof NullValue;
+    }
+}
+export class BooleanValue extends PrimitiveValue {
+    static type = "boolean";
+}
+export class NumberValue extends PrimitiveValue {
+    static type = "number";
+}
+export class StringValue extends PrimitiveValue {
+    static type = "text";
+}
+export class DateValue extends PrimitiveValue {
+    static type = "date";
+    constructor(value) {
+        super(value instanceof DateTime
+            ? value
+            : value instanceof Date
+                ? DateTime.fromJSDate(value)
+                : typeof value === "number"
+                    ? DateTime.fromMillis(value)
+                    : DateTime.fromISO(value));
+    }
+    toString() {
+        return this.value.toISO()?.substring(0, 16) ?? "";
+    }
+    isTruthy() {
+        return this.value.isValid;
+    }
+    equals(other) {
+        return (other instanceof DateValue &&
+            this.value.toMillis() === other.value.toMillis());
+    }
+    looseEquals(other) {
+        if (other instanceof DateValue) {
+            return this.value.toMillis() === other.value.toMillis();
+        }
+        if (other instanceof NumberValue) {
+            return this.value.toMillis() === other.value;
+        }
+        return false;
+    }
+    dateOnly() {
+        return new DateValue(this.value.startOf("day"));
+    }
+    relative() {
+        return this.value.toRelative() ?? "";
+    }
+    static parseFromString(input) {
+        const value = DateTime.fromISO(input);
+        return value.isValid ? new DateValue(value) : null;
+    }
+}
+export class DurationValue extends PrimitiveValue {
+    static type = "duration";
+    constructor(value) {
+        super(value instanceof Duration
+            ? value
+            : typeof value === "number"
+                ? Duration.fromMillis(value)
+                : Duration.fromISO(value));
+    }
+    toString() {
+        return this.value.toString() ?? "";
+    }
+    isTruthy() {
+        return this.value.isValid;
+    }
+    equals(other) {
+        return (other instanceof DurationValue &&
+            this.getMilliseconds() === other.getMilliseconds());
+    }
+    looseEquals(other) {
+        if (other instanceof DurationValue) {
+            return this.getMilliseconds() === other.getMilliseconds();
+        }
+        if (other instanceof NumberValue) {
+            return this.getMilliseconds() === other.value;
+        }
+        return false;
+    }
+    addToDate(value, subtract) {
+        return new DateValue(subtract ? value.value.minus(this.value) : value.value.plus(this.value));
+    }
+    getMilliseconds() {
+        return this.value.toMillis();
+    }
+    static parseFromString(input) {
+        const value = Duration.fromISO(input);
+        return value.isValid ? new DurationValue(value) : null;
+    }
+    static fromMilliseconds(milliseconds) {
+        return new DurationValue(Duration.fromMillis(milliseconds));
+    }
+}
+export class FileValue extends NotNullValue {
+    value;
+    static type = "file";
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return this.value.path;
+    }
+    equals(other) {
+        return other instanceof FileValue && this.value.path === other.value.path;
+    }
+    looseEquals(other) {
+        if (other instanceof FileValue) {
+            return this.value.path === other.value.path;
+        }
+        if (other instanceof PrimitiveValue) {
+            return this.value.path === other.value;
+        }
+        return false;
+    }
+}
+export class LinkValue extends StringValue {
+}
+export class HTMLValue extends StringValue {
+}
+export class IconValue extends StringValue {
+}
+export class ImageValue extends StringValue {
+}
+export class TagValue extends StringValue {
+}
+export class UrlValue extends StringValue {
+}
+export class RegExpValue extends PrimitiveValue {
+    static type = "regexp";
+}
+export class RelativeDateValue extends DateValue {
+}
+export class ListValue extends NotNullValue {
+    static type = "list";
+    value;
+    constructor(value = []) {
+        super();
+        this.value = value
+            .map((item) => toValue(item))
+            .filter((item) => !!item);
+    }
+    toString() {
+        return this.value.map((item) => item.toString()).join(", ");
+    }
+    isTruthy() {
+        return this.value.length > 0;
+    }
+    includes(value) {
+        return this.value.some((item) => item.looseEquals(value));
+    }
+    length() {
+        return this.value.length;
+    }
+    get(index) {
+        return this.value[index] ?? NullValue.value;
+    }
+    concat(other) {
+        return new ListValue([...this.value, ...other.value]);
+    }
+    equals(other) {
+        return (other instanceof ListValue &&
+            this.value.length === other.value.length &&
+            this.value.every((item, index) => Value.equals(item, other.value[index])));
+    }
+}
+export class ObjectValue extends NotNullValue {
+    value;
+    static type = "object";
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return JSON.stringify(this.value);
+    }
+    isTruthy() {
+        return !this.isEmpty();
+    }
+    isEmpty() {
+        return Object.keys(this.value).length === 0;
+    }
+    get(key) {
+        return toValue(this.value[key]);
+    }
+}
+export function toValue(value) {
+    if (value instanceof Value)
+        return value;
+    if (value === null || value === undefined)
+        return NullValue.value;
+    if (value instanceof DateTime || value instanceof Date)
+        return new DateValue(value);
+    if (value instanceof Duration)
+        return new DurationValue(value);
+    if (value instanceof RegExp)
+        return new RegExpValue(value);
+    if (value instanceof FileValue)
+        return value;
+    if (typeof value === "boolean")
+        return new BooleanValue(value);
+    if (typeof value === "number")
+        return new NumberValue(value);
+    if (typeof value === "string")
+        return new StringValue(value);
+    if (Array.isArray(value))
+        return new ListValue(value.map(toValue).filter(Boolean));
+    if (typeof value === "object")
+        return new ObjectValue(value);
+    return null;
+}
+export class BasesEntry {
+    id;
+    file;
+    values;
+    constructor(idOrFile, fileOrValues, values = {}) {
+        if (typeof idOrFile === "string") {
+            this.id = idOrFile;
+            this.file = fileOrValues;
+            this.values = values;
+        }
+        else {
+            this.id = idOrFile.path;
+            this.file = idOrFile;
+            this.values = fileOrValues ?? {};
+        }
+    }
+    getValue(propertyId) {
+        if (propertyId.startsWith("file.") ||
+            propertyId.startsWith("note.") ||
+            propertyId.startsWith("formula.")) {
+            return this.values[propertyId] ?? null;
+        }
+        return this.values[`note.${propertyId}`] ?? this.values[propertyId] ?? null;
+    }
+}
+export class BasesEntryGroup {
+    entries;
+    key;
+    constructor(entries = [], key) {
+        this.entries = entries;
+        this.key = key;
+    }
+    hasKey() {
+        return !!this.key && this.key !== NullValue.value;
+    }
+}
+export class BasesQueryResult {
+    data;
+    propertyIds;
+    groupBy;
+    constructor(data = [], propertyIds = [], groupBy) {
+        this.data = data;
+        this.propertyIds = propertyIds;
+        this.groupBy = groupBy;
+    }
+    get groupedData() {
+        if (!this.groupBy)
+            return [new BasesEntryGroup(this.data)];
+        const groups = [];
+        for (const entry of this.data) {
+            const key = entry.getValue(this.groupBy) ?? NullValue.value;
+            let group = groups.find((candidate) => Value.looseEquals(candidate.key ?? null, key));
+            if (!group) {
+                group = new BasesEntryGroup([], key);
+                groups.push(group);
+            }
+            group.entries.push(entry);
+        }
+        return groups;
+    }
+    get properties() {
+        return this.propertyIds;
+    }
+    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.value);
+        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;
+        }
+    }
+}
+export class QueryController extends Component {
+    app;
+    constructor(application) {
+        super();
+        this.app = resolveApplication(application);
+    }
+}
+export class BasesViewConfig {
+    config;
+    columns;
+    constructor(config = { type: "", name: "" }, columns = {}) {
+        this.config = config;
+        this.columns = columns;
+    }
+    get name() {
+        return this.config.name;
+    }
+    get(key) {
+        return this.config[key];
+    }
+    getAsPropertyId(key) {
+        const value = this.get(key);
+        return typeof value === "string" ? value : null;
+    }
+    getEvaluatedFormula(view, key) {
+        return toValue(this.get(key)) ?? NullValue.value;
+    }
+    set(key, value) {
+        if (value === null)
+            delete this.config[key];
+        else
+            this.config[key] = value;
+    }
+    getOrder() {
+        return (this.config.order ?? []).filter((property) => typeof property === "string");
+    }
+    getSort() {
+        return (this.config.sort ?? []).filter((sort) => {
+            return (!!sort &&
+                typeof sort.property === "string" &&
+                (sort.direction === "ASC" || sort.direction === "DESC"));
+        });
+    }
+    getDisplayName(propertyId) {
+        return (this.columns[propertyId]?.displayName ??
+            parsePropertyId(propertyId).name.replaceAll(/[_-]+/g, " "));
+    }
+}
+export class BasesView extends Component {
+    controller;
+    mountedView = null;
+    mountedViewContainer = null;
+    app;
+    config = new BasesViewConfig();
+    allProperties = [];
+    data = new BasesQueryResult();
+    constructor(controller) {
+        super();
+        this.controller = controller;
+        this.app = controller.app;
+    }
+    mountViewComponent(component, props, containerEl) {
+        this.unmountViewComponent();
+        containerEl.replaceChildren();
+        const target = containerEl.createDiv("w-full h-full");
+        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();
+    }
+    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);
+    }
+}
+export function parsePropertyId(propertyId) {
+    const [prefix, ...rest] = propertyId.split(".");
+    if (prefix === "file" || prefix === "formula" || prefix === "note") {
+        return { type: prefix, name: rest.join(".") };
+    }
+    return { type: "note", name: propertyId };
+}