@lapis-notes/api 0.1.0

package/dist/metadata-value.js

@@ -0,0 +1,173 @@
+import { DateTime } from "luxon";
+const DATE_PATTERN = /^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$/;
+const DATETIME_PATTERN = /^([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])[T ](2[0-3]|[01][0-9]):?([0-5][0-9])(:?([0-5][0-9]))?$/;
+function coerceCheckbox(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.toLowerCase().trim();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return value;
+}
+function coerceNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "") {
+            return value;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return value;
+}
+function matchesDate(value) {
+    return typeof value === "string" && DATE_PATTERN.test(value.trim());
+}
+function matchesDateTime(value) {
+    return typeof value === "string" && DATETIME_PATTERN.test(value.trim());
+}
+function coerceDate(value) {
+    if (matchesDate(value)) {
+        return typeof value === "string" ? value.trim() : value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    if (value instanceof DateTime) {
+        return value.toISODate() ?? value;
+    }
+    return value;
+}
+function coerceDateTime(value) {
+    if (matchesDateTime(value)) {
+        return typeof value === "string" ? value.trim() : value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 19);
+    }
+    if (value instanceof DateTime) {
+        return value.toISO()?.slice(0, 19) ?? value;
+    }
+    return value;
+}
+function coerceStringList(value) {
+    if (Array.isArray(value)) {
+        if (value.every((item) => typeof item === "string")) {
+            return value;
+        }
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "") {
+            return [];
+        }
+        if (/[,;]/.test(trimmed)) {
+            return trimmed
+                .split(/[,;]+/)
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+        }
+        return [trimmed];
+    }
+    return value;
+}
+const TAGS_PATTERN = /^(#[/a-zA-Z0-9_-]+\s*,\s*)*(#[/a-zA-Z0-9_-]+\s*)?$/;
+function isPrimitiveMetadataArray(value) {
+    return value.every((item) => typeof item === "string" || typeof item === "number");
+}
+/** Infer a metadata type from a raw frontmatter value. */
+export function inferMetadataType(value) {
+    if (typeof value === "number") {
+        return "number";
+    }
+    else if (value instanceof Date) {
+        return "date";
+    }
+    else if (value instanceof DateTime) {
+        return "datetime";
+    }
+    else if (typeof value === "boolean") {
+        return "checkbox";
+    }
+    else if (typeof value === "string") {
+        if (["true", "false"].includes(value.toLowerCase().trim())) {
+            return "checkbox";
+        }
+        else if (value.match(TAGS_PATTERN)) {
+            return "tags";
+        }
+        else if (value.trim().match(DATE_PATTERN)) {
+            return "date";
+        }
+        else if (value.trim().match(DATETIME_PATTERN)) {
+            return "datetime";
+        }
+        else if (value.trim().match(/^[0-9]+$/)) {
+            return "number";
+        }
+        return "text";
+    }
+    else if (Array.isArray(value)) {
+        return isPrimitiveMetadataArray(value) ? "multitext" : "array";
+    }
+    else if (value === undefined || value === null) {
+        return "text";
+    }
+    else if (typeof value === "object") {
+        return "object";
+    }
+    return "unknown";
+}
+/** Infer a metadata type from a top-level frontmatter property name and value. */
+export function inferMetadataPropertyType(name, value) {
+    const id = name.toLowerCase().trim();
+    if (id === "tags" || id === "tag") {
+        return "tags";
+    }
+    if (id === "aliases" || id === "alias") {
+        return "aliases";
+    }
+    return inferMetadataType(value);
+}
+/**
+ * Best-effort normalization of a frontmatter value against a declared metadata
+ * type. Coerces when unambiguous; otherwise returns the original value.
+ */
+export function normalizeMetadataValue(type, value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (type) {
+        case "checkbox":
+            return coerceCheckbox(value);
+        case "number":
+            return coerceNumber(value);
+        case "date":
+            return coerceDate(value);
+        case "datetime":
+            return coerceDateTime(value);
+        case "aliases":
+        case "multitext":
+        case "tags":
+            return coerceStringList(value);
+        case "array":
+        case "object":
+        case "text":
+        case "unknown":
+        default:
+            return value;
+    }
+}

package/dist/metadata.svelte.d.ts

@@ -0,0 +1,106 @@
+import type { CachedMetadata } from "./cache.svelte";
+import type { App } from "./context.svelte";
+import { type TFile } from "./storage";
+export interface IMetadataType {
+    text: "text";
+    checkbox: "checkbox";
+    number: "number";
+    multitext: "multitext";
+    date: "date";
+    datetime: "datetime";
+    aliases: "aliases";
+    tags: "tags";
+    array: "array";
+    object: "object";
+    unknown: "unknown";
+}
+export type MetadataType = keyof IMetadataType;
+export interface MetadataTypeDef {
+    name: string;
+    type: MetadataType;
+}
+export interface MetadataTypeProperty extends MetadataTypeDef {
+    count: number;
+    files: Set<string>;
+}
+export interface MetadataRenameFailure {
+    path: string;
+    message: string;
+}
+export interface MetadataRenameResult {
+    updatedFiles: string[];
+    failedFiles: MetadataRenameFailure[];
+}
+export type MetadataBulkOperationFailure = MetadataRenameFailure;
+export interface MetadataBulkOperationResult {
+    updatedFiles: string[];
+    failedFiles: MetadataBulkOperationFailure[];
+}
+export interface MetadataBulkOperationProgress {
+    current: number;
+    total: number;
+    path: string;
+}
+export interface MetadataBulkOperationOptions {
+    onProgress?: (progress: MetadataBulkOperationProgress) => void;
+    signal?: AbortSignal;
+}
+export type TypeWidget = {
+    default: (value?: unknown) => any;
+    icon: string;
+    name: string;
+    type: MetadataType;
+    validate: (value: unknown) => boolean;
+    render: (el: HTMLElement, props: {
+        type: MetadataTypeDef;
+        value: any;
+        onChange: (type: MetadataTypeDef, value: any, event: Event) => void;
+    }) => void;
+};
+export declare class MetadataTypeManager {
+    readonly app: App;
+    readonly types: Record<string, MetadataTypeDef>;
+    readonly registeredTypeWidgets: Record<string, TypeWidget>;
+    readonly properties: Record<string, MetadataTypeProperty>;
+    readonly topLevelPropertyNames: Set<string>;
+    readonly propertyValues: Record<string, unknown[]>;
+    propertiesLoading: boolean;
+    queryError: string | null;
+    constructor(app: App);
+    getAllProperties(): {
+        [x: string]: MetadataTypeProperty;
+    };
+    updateProperties(): Promise<void>;
+    load(): Promise<void>;
+    readonly save: import("lodash-es").DebouncedFunc<() => Promise<void> | undefined>;
+    toJSON(): {
+        types: Record<string, string>;
+    };
+    setType(field: string, type: MetadataType): void;
+    registerTypeWidget(widget: TypeWidget): void;
+    unregisterTypeWidget(widget: TypeWidget): void;
+    private collectPropertyEntries;
+    private getEntriesForFrontmatter;
+    private getFrontmatterPropertyValue;
+    private refreshProperty;
+    private syncFileProperties;
+    private getFilesForProperty;
+    private getFilesForTopLevelProperty;
+    private reportBulkProgress;
+    private throwIfBulkCancelled;
+    rename(prevId: string, newId: string): Promise<MetadataRenameResult>;
+    renameProperty(files: Set<string>, prevId: string, newId: string): Promise<MetadataRenameResult>;
+    renameTopLevelProperty(prevId: string, newId: string, options?: MetadataBulkOperationOptions): Promise<MetadataBulkOperationResult>;
+    deleteTopLevelProperty(path: string, options?: MetadataBulkOperationOptions): Promise<MetadataBulkOperationResult>;
+    deleteProperty(path: string, options?: MetadataBulkOperationOptions): Promise<MetadataBulkOperationResult>;
+    setTopLevelPropertyType(path: string, type: MetadataType, options?: MetadataBulkOperationOptions): Promise<MetadataBulkOperationResult>;
+    setPropertyType(path: string, type: MetadataType, options?: MetadataBulkOperationOptions): Promise<MetadataBulkOperationResult>;
+    processChange(file: TFile, cache: CachedMetadata): void;
+    getValues(key: string): unknown[];
+    getValuesAsync(key: string, limit?: number): Promise<unknown[]>;
+    processDelete(file: TFile): void;
+    trackChanges(): () => void;
+    reload(): void;
+    determineType(value: unknown): MetadataType;
+    determinePropertyType(name: string, value: unknown): MetadataType;
+}