@lapis-notes/api 0.1.0

package/dist/popover.d.ts

@@ -0,0 +1,20 @@
+import { Component } from "./view.svelte";
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare enum PopoverState {
+    Hidden = "hidden",
+    Showing = "showing",
+    Shown = "shown",
+    Hiding = "hiding"
+}
+export interface HoverParent {
+    hoverPopover: HoverPopover | null;
+}
+export declare class HoverPopover extends Component {
+    hoverEl: HTMLElement;
+    state: PopoverState;
+    constructor(parent: HoverParent, targetEl: HTMLElement | null, waitTime?: number, staticPos?: Point | null);
+    close(): void;
+}

package/dist/popover.js

@@ -0,0 +1,32 @@
+import { Component } from "./view.svelte";
+export var PopoverState;
+(function (PopoverState) {
+    PopoverState["Hidden"] = "hidden";
+    PopoverState["Showing"] = "showing";
+    PopoverState["Shown"] = "shown";
+    PopoverState["Hiding"] = "hiding";
+})(PopoverState || (PopoverState = {}));
+function createHoverEl() {
+    if (typeof document !== "undefined") {
+        return document.createElement("div");
+    }
+    return {};
+}
+export class HoverPopover extends Component {
+    hoverEl;
+    state = PopoverState.Showing;
+    constructor(parent, targetEl, waitTime, staticPos) {
+        super();
+        this.hoverEl = targetEl ?? createHoverEl();
+        parent.hoverPopover = this;
+        this.register(() => {
+            if (parent.hoverPopover === this) {
+                parent.hoverPopover = null;
+            }
+        });
+    }
+    close() {
+        this.state = PopoverState.Hidden;
+        this.unload();
+    }
+}

package/dist/promise-worker.d.ts

@@ -0,0 +1,22 @@
+export interface WorkerMessage {
+    id: string;
+    type: string;
+    data: any;
+}
+export interface WorkerResponse {
+    id: string;
+    success: boolean;
+    result?: any;
+    error?: string;
+}
+export declare class PromiseWorker {
+    readonly worker: Worker;
+    private pendingPromises;
+    private messageId;
+    constructor(worker: Worker);
+    private handleMessage;
+    private handleError;
+    private generateId;
+    postMessage<T = any>(type: string, data: any, timeout?: number): Promise<T>;
+    terminate(): void;
+}

package/dist/promise-worker.js

@@ -0,0 +1,65 @@
+export class PromiseWorker {
+    worker;
+    pendingPromises = new Map();
+    messageId = 0;
+    constructor(worker) {
+        this.worker = worker;
+        worker.onmessage = this.handleMessage.bind(this);
+        worker.onerror = this.handleError.bind(this);
+    }
+    handleMessage(event) {
+        const { id, success, result, error } = event.data;
+        const promise = this.pendingPromises.get(id);
+        if (promise) {
+            this.pendingPromises.delete(id);
+            if (success) {
+                promise.resolve(result);
+            }
+            else {
+                promise.reject(new Error(error || "Worker operation failed"));
+            }
+        }
+    }
+    handleError(error) {
+        // Reject all pending promises
+        this.pendingPromises.forEach(({ reject }) => {
+            reject(new Error("Worker encountered an error"));
+        });
+        this.pendingPromises.clear();
+    }
+    generateId() {
+        return `msg_${++this.messageId}_${Date.now()}`;
+    }
+    postMessage(type, data, timeout = 10000) {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            // Set up timeout
+            const timeoutId = setTimeout(() => {
+                this.pendingPromises.delete(id);
+                reject(new Error(`Worker operation timed out after ${timeout}ms`));
+            }, timeout);
+            // Store promise resolvers
+            this.pendingPromises.set(id, {
+                resolve: (result) => {
+                    clearTimeout(timeoutId);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timeoutId);
+                    reject(error);
+                },
+            });
+            // Send message to worker
+            const message = { id, type, data };
+            this.worker.postMessage(message);
+        });
+    }
+    terminate() {
+        this.worker.terminate();
+        // Reject all pending promises
+        this.pendingPromises.forEach(({ reject }) => {
+            reject(new Error("Worker was terminated"));
+        });
+        this.pendingPromises.clear();
+    }
+}

package/dist/prompt-confirm.d.ts

@@ -0,0 +1,9 @@
+import type { ButtonVariant } from "./design-core-button-types";
+export interface PromptConfirmOptions {
+    title?: string;
+    description: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    confirmVariant?: ButtonVariant;
+}
+export declare function promptConfirm(hostDocument: Document, options: PromptConfirmOptions): Promise<boolean>;

package/dist/prompt-confirm.js

@@ -0,0 +1,33 @@
+import ConfirmDialog from "@lapis-notes/ui/confirm-dialog";
+import { mountComponent } from "./hooks/mountComponent.svelte";
+import { dialogPortalPropsForDocument } from "./dialog-portal";
+export function promptConfirm(hostDocument, options) {
+    return new Promise((resolve) => {
+        const container = hostDocument.createElement("div");
+        hostDocument.body.appendChild(container);
+        let settled = false;
+        const settle = (confirmed) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            mounted.destroy();
+            container.remove();
+            resolve(confirmed);
+        };
+        const mounted = mountComponent(ConfirmDialog, {
+            target: container,
+            props: {
+                open: true,
+                title: options.title ?? "Confirm",
+                description: options.description,
+                confirmLabel: options.confirmLabel ?? "Continue",
+                cancelLabel: options.cancelLabel ?? "Cancel",
+                confirmVariant: options.confirmVariant ?? "default",
+                portalProps: dialogPortalPropsForDocument(hostDocument),
+                onConfirm: () => settle(true),
+                onCancel: () => settle(false),
+            },
+        });
+    });
+}

package/dist/search-document-provider.d.ts

@@ -0,0 +1,45 @@
+import type { CachedMetadata } from "./cache.svelte";
+import type { App } from "./context.svelte";
+import { EventDispatcher } from "./events";
+import type { TFile } from "./storage";
+export type SearchDocumentSource = {
+    /** Human-readable content used for snippets, lexical search, and embeddings. */
+    content: string;
+    /** Curated structured metadata included in metadata search. */
+    metadata?: Record<string, unknown>;
+    /** Tags contributed by the domain parser, with or without a leading hash. */
+    tags?: readonly string[];
+};
+export type SearchDocumentProviderContext = {
+    app: App;
+    file: TFile;
+    content: string;
+    metadata: CachedMetadata;
+};
+export type SearchDocumentProvider = {
+    /** Registry-wide provider id. Plugin helpers namespace local ids. */
+    id: string;
+    /** Projection version used to invalidate persisted Search documents. */
+    version?: string;
+    /** Higher priorities override lower-priority matching providers. */
+    priority?: number;
+    matches(file: TFile): boolean;
+    extract(context: SearchDocumentProviderContext): SearchDocumentSource | null | Promise<SearchDocumentSource | null>;
+};
+export type SearchDocumentProviderChange = {
+    providerId: string;
+    reason: "registered" | "unregistered";
+};
+export type SearchDocumentProviderRegistration = {
+    readonly id: string;
+    dispose(): void;
+};
+/** Public registry for domain-owned, Search-consumed document projections. */
+export declare class SearchDocumentProviderRegistry extends EventDispatcher<{
+    changed: [change: SearchDocumentProviderChange];
+}> {
+    private readonly providers;
+    register(provider: SearchDocumentProvider): SearchDocumentProviderRegistration;
+    getAll(): SearchDocumentProvider[];
+    resolve(file: TFile): SearchDocumentProvider | null;
+}

package/dist/search-document-provider.js

@@ -0,0 +1,54 @@
+import { EventDispatcher } from "./events";
+function validateProvider(provider) {
+    if (!provider.id.trim()) {
+        throw new Error("Search document provider id must not be empty.");
+    }
+    if (!Number.isFinite(provider.priority ?? 0)) {
+        throw new Error(`Search document provider ${provider.id} must use a finite priority.`);
+    }
+}
+/** Public registry for domain-owned, Search-consumed document projections. */
+export class SearchDocumentProviderRegistry extends EventDispatcher {
+    providers = new Map();
+    register(provider) {
+        validateProvider(provider);
+        const id = provider.id.trim();
+        if (this.providers.has(id)) {
+            throw new Error(`Search document provider already registered: ${id}`);
+        }
+        const registered = { ...provider, id };
+        this.providers.set(id, registered);
+        this.emit("changed", { providerId: id, reason: "registered" });
+        let disposed = false;
+        return {
+            id,
+            dispose: () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                if (this.providers.get(id) !== registered)
+                    return;
+                this.providers.delete(id);
+                this.emit("changed", { providerId: id, reason: "unregistered" });
+            },
+        };
+    }
+    getAll() {
+        return [...this.providers.values()];
+    }
+    resolve(file) {
+        const matches = this.getAll()
+            .filter((provider) => provider.matches(file))
+            .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0) ||
+            left.id.localeCompare(right.id));
+        const selected = matches[0];
+        if (!selected)
+            return null;
+        const conflicting = matches[1];
+        if (conflicting &&
+            (conflicting.priority ?? 0) === (selected.priority ?? 0)) {
+            throw new Error(`Ambiguous search document providers for ${file.path}: ${selected.id}, ${conflicting.id}`);
+        }
+        return selected;
+    }
+}

package/dist/search-query/index.d.ts

@@ -0,0 +1,78 @@
+import { LRLanguage, LanguageSupport } from "@codemirror/language";
+import type { SearchFilterSyntax } from "@lapismd/design-core/filter";
+import type { Tree } from "@lezer/common";
+export type SearchQueryComparisonOperator = "<" | "<=" | ">" | ">=";
+export type SearchQueryLiteralKind = "word" | "phrase" | "regex" | "null";
+export interface SearchQueryDiagnostic {
+    from: number;
+    to: number;
+    severity: "error";
+    message: string;
+    text: string;
+}
+interface SearchQueryNodeBase {
+    from: number;
+    to: number;
+    text: string;
+}
+export interface SearchQueryLiteral extends SearchQueryNodeBase {
+    type: "literal";
+    kind: SearchQueryLiteralKind;
+    value: string | null;
+}
+export interface SearchQueryGroup extends SearchQueryNodeBase {
+    type: "group";
+    expression: SearchQueryExpression | null;
+}
+export interface SearchQueryNot extends SearchQueryNodeBase {
+    type: "not";
+    operand: SearchQueryExpression | null;
+}
+export interface SearchQueryAnd extends SearchQueryNodeBase {
+    type: "and";
+    clauses: SearchQueryExpression[];
+}
+export interface SearchQueryOr extends SearchQueryNodeBase {
+    type: "or";
+    clauses: SearchQueryExpression[];
+}
+export interface SearchQueryField extends SearchQueryNodeBase {
+    type: "field";
+    name: string;
+    value: SearchQueryExpression | null;
+}
+export interface SearchQueryProperty extends SearchQueryNodeBase {
+    type: "property";
+    name: string;
+    value: SearchQueryExpression | null;
+}
+export interface SearchQueryComparison extends SearchQueryNodeBase {
+    type: "comparison";
+    operator: SearchQueryComparisonOperator;
+    value: SearchQueryLiteral | null;
+}
+export type SearchQueryExpression = SearchQueryAnd | SearchQueryComparison | SearchQueryField | SearchQueryGroup | SearchQueryLiteral | SearchQueryNot | SearchQueryOr | SearchQueryProperty;
+export interface SearchQueryAst extends SearchQueryNodeBase {
+    type: "query";
+    expression: SearchQueryExpression | null;
+    diagnostics: SearchQueryDiagnostic[];
+}
+export declare const searchQueryParser: import("@lezer/lr").LRParser;
+export declare const searchQueryLanguage: LRLanguage;
+export declare function searchQueryLanguageSupport(): LanguageSupport;
+/** Formats a dynamic field value so it round-trips through the search parser. */
+export declare function formatSearchQueryValue(value: string): string;
+export interface VaultSearchFilterValues {
+    fileNames: readonly string[];
+    paths: readonly string[];
+    tags: readonly string[];
+}
+/** Builds the shared, parser-safe field catalog for vault search surfaces. */
+export declare function createVaultSearchFilterSyntax({ fileNames, paths, tags: tagValues, }: VaultSearchFilterValues): SearchFilterSyntax;
+export declare function parseSearchQuery(input: string): Tree;
+export declare function parseSearchQueryAst(input: string): SearchQueryAst;
+export declare function canCollectSearchQueryTerms(value: SearchQueryAst | SearchQueryExpression | null): boolean;
+export declare function collectSearchQueryTerms(value: string | SearchQueryAst | SearchQueryExpression | null): string[];
+export declare function canCollectSearchQueryPropertyNames(value: SearchQueryAst | SearchQueryExpression | null): boolean;
+export declare function collectSearchQueryPropertyNames(value: string | SearchQueryAst | SearchQueryExpression | null): string[];
+export {};