@lapis-notes/api 0.1.0

package/dist/hooks/mountComponent.svelte.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type MountOptions } from "svelte";
+export declare function mountComponent<T extends Record<string, any>>(component: Component<T, Record<string, any>, any>, options: MountOptions<T>): MountComponent<T>;
+export type MountComponent<T> = {
+    props: T;
+    target: Document | Element | ShadowRoot;
+    destroy: () => void;
+};

package/dist/hooks/mountComponent.svelte.js

@@ -0,0 +1,16 @@
+import { mount, unmount } from "svelte";
+export function mountComponent(component, options) {
+    const _props = $state(options.props || {});
+    const comp = mount(component, { ...options, props: _props });
+    return {
+        destroy() {
+            unmount(comp);
+        },
+        get target() {
+            return options.target;
+        },
+        get props() {
+            return _props;
+        },
+    };
+}

package/dist/hooks/use-text-highlight.d.ts

@@ -0,0 +1,17 @@
+export type TextHighlightPart = {
+    highlighted: false;
+    text: string;
+} | {
+    highlighted: true;
+    text: string;
+};
+export declare function getTextHighlightParts(query: string, value: string): TextHighlightPart[];
+export declare function useTextHighlight(el: HTMLElement, { query, value }: {
+    query: string;
+    value: string;
+}): {
+    update({ query, value }: {
+        query: string;
+        value: string;
+    }): void;
+};

package/dist/hooks/use-text-highlight.js

@@ -0,0 +1,82 @@
+function findRanges(value, term) {
+    const ranges = [];
+    const needle = term.toLocaleLowerCase();
+    const haystack = value.toLocaleLowerCase();
+    let cursor = 0;
+    while (needle && cursor < haystack.length) {
+        const index = haystack.indexOf(needle, cursor);
+        if (index === -1) {
+            break;
+        }
+        ranges.push([index, index + needle.length]);
+        cursor = index + Math.max(needle.length, 1);
+    }
+    return ranges;
+}
+function mergeRanges(ranges) {
+    const sorted = ranges
+        .filter(([from, to]) => to > from)
+        .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const merged = [];
+    for (const [from, to] of sorted) {
+        const last = merged[merged.length - 1];
+        if (last && from <= last[1]) {
+            last[1] = Math.max(last[1], to);
+            continue;
+        }
+        merged.push([from, to]);
+    }
+    return merged;
+}
+export function getTextHighlightParts(query, value) {
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery) {
+        return [{ highlighted: false, text: value }];
+    }
+    let ranges = findRanges(value, normalizedQuery);
+    if (ranges.length === 0) {
+        ranges = normalizedQuery
+            .split(/\s+/u)
+            .filter((part) => part.length > 1)
+            .flatMap((part) => findRanges(value, part));
+    }
+    const merged = mergeRanges(ranges);
+    if (merged.length === 0) {
+        return [{ highlighted: false, text: value }];
+    }
+    const parts = [];
+    let cursor = 0;
+    for (const [from, to] of merged) {
+        if (from > cursor) {
+            parts.push({ highlighted: false, text: value.slice(cursor, from) });
+        }
+        parts.push({ highlighted: true, text: value.slice(from, to) });
+        cursor = to;
+    }
+    if (cursor < value.length) {
+        parts.push({ highlighted: false, text: value.slice(cursor) });
+    }
+    return parts;
+}
+function renderHighlight(el, query, value) {
+    const fragment = document.createDocumentFragment();
+    for (const part of getTextHighlightParts(query, value)) {
+        if (!part.highlighted) {
+            fragment.append(document.createTextNode(part.text));
+            continue;
+        }
+        const span = document.createElement("span");
+        span.className = "suggestion-highlight";
+        span.textContent = part.text;
+        fragment.append(span);
+    }
+    el.replaceChildren(fragment);
+}
+export function useTextHighlight(el, { query, value }) {
+    renderHighlight(el, query, value);
+    return {
+        update({ query, value }) {
+            renderHighlight(el, query, value);
+        },
+    };
+}

package/dist/hooks/useBoundingRect.svelte.d.ts

@@ -0,0 +1,11 @@
+type BoundingRectProps = {
+    resize: boolean;
+    scroll: boolean;
+    observe: boolean;
+};
+export declare function useBoundingRect(props?: Partial<BoundingRectProps>): {
+    ref: HTMLElement | null;
+    readonly rect: DOMRect | null;
+    update: () => void;
+};
+export {};

package/dist/hooks/useBoundingRect.svelte.js

@@ -0,0 +1,46 @@
+import { onMount } from "svelte";
+export function useBoundingRect(props = {}) {
+    const { resize = true, scroll = false, observe = false } = props;
+    let ref = $state(null);
+    let rect = $state(null);
+    let observer = new ResizeObserver(() => update());
+    const update = () => {
+        if (!ref)
+            return;
+        rect = ref.getBoundingClientRect();
+    };
+    onMount(() => {
+        if (resize) {
+            window.addEventListener("resize", update);
+        }
+        if (scroll) {
+            window.addEventListener("scroll", update);
+        }
+        update();
+        return () => {
+            window.removeEventListener("resize", update);
+            window.removeEventListener("scroll", update);
+            observer.disconnect();
+        };
+    });
+    return {
+        get ref() {
+            return ref;
+        },
+        get rect() {
+            return rect;
+        },
+        set ref(el) {
+            ref = el;
+            update();
+            if (el && observe) {
+                if (observer) {
+                    observer.disconnect();
+                }
+                observer = new ResizeObserver(update);
+                observer.observe(el);
+            }
+        },
+        update,
+    };
+}

package/dist/icons/index.d.ts

@@ -0,0 +1,57 @@
+import type { IconifyIcon, IconifyJSON } from "@iconify/types";
+import { type IconifyIconCustomisations } from "@iconify/utils";
+interface AsyncIconLoader {
+    name: string;
+    loader: () => Promise<IconifyJSON>;
+}
+interface SyncIconLoader {
+    name: string;
+    icons: IconifyJSON;
+}
+export type IconLoader = AsyncIconLoader | SyncIconLoader;
+export type IconName = string;
+export type CodiconLabelSegment = {
+    type: "text";
+    text: string;
+} | {
+    type: "codicon";
+    name: string;
+    raw: string;
+    modifier?: "spin";
+} | {
+    type: "icon";
+    name: string;
+    raw: string;
+    modifier?: "spin";
+};
+export declare const unknownIcon: IconifyIcon;
+export declare const registerIconPacks: (iconLoaders: IconLoader[]) => void;
+export declare const getSvg: (iconName: string | string[], customisations?: IconifyIconCustomisations & {
+    class?: string;
+}) => Promise<string>;
+export declare const isIconAvailable: (iconName: string) => Promise<boolean>;
+export declare function isLabelIconAvailable(iconName: string): Promise<boolean>;
+export declare function parseCodiconLabel(label: string | null | undefined): CodiconLabelSegment[];
+export declare function getIconPacks(): IconLoader[];
+export declare function getIconIds(): string[];
+/**
+ * Adds an icon to the library.
+ *
+ * @param iconId - The icon ID
+ * @param svgContent - The content of the SVG.
+ * @public
+ */
+export declare function addIcon(iconId: string, svgContent: string): void;
+export declare function removeIcon(iconId: string): void;
+export declare function getIcon(iconId: string): SVGSVGElement | null;
+/**
+ * Insert an SVG into the element from an iconId. Does nothing if no icon
+ * associated with the iconId.
+ *
+ * @param parent - The HTML element to insert the icon
+ * @param iconId - The icon ID
+ * @public
+ * @see The Obsidian icon library includes the {@link https://lucide.dev/ Lucide icon library}, any icon name from their site will work here.
+ */
+export declare function setIcon(parent: HTMLElement, iconId: string): void;
+export {};

package/dist/icons/index.js

@@ -0,0 +1,288 @@
+import { icons as lucideIcons } from "@iconify-json/lucide";
+import { iconToSVG, parseSVGContent, iconToHTML, getIconData, stringToIcon, replaceIDs, convertParsedSVG, } from "@iconify/utils";
+import { cn } from "../utils";
+import lucideTags from "lucide-static/tags.json";
+const codiconNamePattern = /^[a-z0-9-]+$/u;
+const qualifiedIconNamePattern = /^[a-z0-9-]+:[a-z0-9-]+(?:-[a-z0-9-]+)*$/u;
+const labelIconAvailabilityCache = new Map();
+const iconsStore = new Map();
+const loaderStore = new Map();
+const codiconLabelPattern = /\$\(([^)]+)\)/g;
+const customIcons = {
+    prefix: "custom",
+    aliases: {},
+    icons: {
+        blank: {
+            body: "<g></g>",
+            height: 24,
+            width: 24,
+        },
+    },
+};
+export const unknownIcon = {
+    body: '<path stroke="currentColor" d="M19.95,5.54l-3.49-3.49c-1.32-1.32-3.08-2.05-4.95-2.05H7C4.24,0,2,2.24,2,5v14c0,2.76,2.24,5,5,5h10c2.76,0,5-2.24,5-5V10.49c0-1.87-.73-3.63-2.05-4.95Zm-1.41,1.41c.32,.32,.59,.67,.81,1.05h-4.34c-.55,0-1-.45-1-1V2.66c.38,.22,.73,.49,1.05,.81l3.49,3.49ZM7,2h4.51c.16,0,.33,0,.49,.02V7c0,1.65,1.35,3,3,3h4.98c.02,.16,.02,.32,.02,.49v4.58l-2.41-2.41c-.87-.87-2.28-.87-3.15,0l-2.27,2.27c-.09,.09-.23,.09-.32,0l-2.27-2.27c-.87-.87-2.28-.87-3.15,0l-2.44,2.44V5c0-1.65,1.35-3,3-3Zm10,20H7c-1.65,0-3-1.35-3-3v-1.07l3.86-3.86c.09-.09,.23-.09,.32,0l2.27,2.27c.87,.87,2.28,.87,3.15,0l2.27-2.27c.09-.09,.23-.09,.32,0l3.83,3.83v1.1c0,1.65-1.35,3-3,3Z"/>',
+    height: 24,
+    width: 24,
+};
+export const registerIconPacks = (iconLoaders) => {
+    for (const iconLoader of iconLoaders) {
+        if (!iconLoader.name) {
+            throw new Error('Invalid icon loader. Must have a "name" property with non-empty string value.');
+        }
+        console.debug("Registering icon pack:", iconLoader.name);
+        if ("loader" in iconLoader) {
+            loaderStore.set(iconLoader.name, iconLoader.loader);
+        }
+        else if ("icons" in iconLoader) {
+            iconsStore.set(iconLoader.name, iconLoader.icons);
+        }
+        else {
+            console.error("Invalid icon loader:", iconLoader);
+            throw new Error('Invalid icon loader. Must have either "icons" or "loader" property.');
+        }
+    }
+};
+function getIconCandidates(iconName) {
+    return [
+        stringToIcon(iconName, true, false),
+        stringToIcon(`lucide:${iconName}`, true, false),
+        stringToIcon(`custom:${iconName}`, true, false),
+    ].filter(Boolean);
+}
+const getRegisteredIconData = async (iconName) => {
+    iconName ||= "";
+    const candidates = getIconCandidates(iconName);
+    let sawRegisteredPrefix = false;
+    for (const candidate of candidates) {
+        const prefix = candidate.prefix;
+        if (!prefix || (!iconsStore.has(prefix) && !loaderStore.has(prefix))) {
+            continue;
+        }
+        sawRegisteredPrefix = true;
+        let icons = iconsStore.get(prefix);
+        if (!icons) {
+            const loader = loaderStore.get(prefix);
+            if (!loader) {
+                continue;
+            }
+            try {
+                const loaded = await loader();
+                icons = { ...loaded, prefix };
+                iconsStore.set(prefix, icons);
+            }
+            catch (e) {
+                console.error(e);
+                throw new Error(`Failed to load icon set: ${prefix}`);
+            }
+        }
+        const iconData = getIconData(icons, candidate.name);
+        if (iconData) {
+            return [iconData, candidate];
+        }
+    }
+    if (!sawRegisteredPrefix) {
+        throw new Error(`Invalid icon name: ${iconName}`);
+    }
+    throw new Error(`Icon not found: ${iconName}`);
+};
+export const getSvg = async (iconName, customisations) => {
+    let icons = Array.isArray(iconName) ? iconName : [iconName];
+    let iconDef;
+    for (const icon of icons) {
+        try {
+            iconDef = await getRegisteredIconData(icon);
+            if (iconDef) {
+                break;
+            }
+        }
+        catch (e) { }
+    }
+    iconDef ||= [
+        unknownIcon,
+        {
+            name: icons.map((it) => `unknown-${it}`).join(" "),
+            prefix: "unknown",
+            provider: "unknown",
+        },
+    ];
+    const [iconData, name] = iconDef;
+    const renderData = iconToSVG(iconData, customisations);
+    let className = cn(`${name.prefix}-icon ${name.prefix}-${name.name}`, customisations?.class);
+    const svg = iconToHTML(replaceIDs(renderData.body), renderData.attributes).replace(`width=`, `class=${JSON.stringify(className)} width=`);
+    return svg;
+};
+export const isIconAvailable = async (iconName) => {
+    try {
+        await getRegisteredIconData(iconName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export function isLabelIconAvailable(iconName) {
+    const cached = labelIconAvailabilityCache.get(iconName);
+    if (cached) {
+        return cached;
+    }
+    const pending = isIconAvailable(iconName).then((available) => {
+        labelIconAvailabilityCache.set(iconName, Promise.resolve(available));
+        return available;
+    });
+    labelIconAvailabilityCache.set(iconName, pending);
+    return pending;
+}
+function parseCodiconToken(tokenBody, raw) {
+    const trimmed = tokenBody.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const [name, modifier, ...rest] = trimmed.split("~");
+    if (rest.length > 0 || (modifier && modifier !== "spin")) {
+        return null;
+    }
+    const spin = modifier ? { modifier: "spin" } : {};
+    if (qualifiedIconNamePattern.test(name)) {
+        return { type: "icon", name, raw, ...spin };
+    }
+    if (codiconNamePattern.test(name)) {
+        return { type: "codicon", name, raw, ...spin };
+    }
+    return null;
+}
+export function parseCodiconLabel(label) {
+    const value = label ?? "";
+    if (!value) {
+        return [];
+    }
+    const segments = [];
+    let lastIndex = 0;
+    for (const match of value.matchAll(codiconLabelPattern)) {
+        const raw = match[0];
+        const tokenBody = match[1] ?? "";
+        const matchIndex = match.index ?? 0;
+        if (matchIndex > lastIndex) {
+            segments.push({
+                type: "text",
+                text: value.slice(lastIndex, matchIndex),
+            });
+        }
+        const token = parseCodiconToken(tokenBody, raw);
+        if (token) {
+            segments.push(token);
+        }
+        else {
+            segments.push({ type: "text", text: raw });
+        }
+        lastIndex = matchIndex + raw.length;
+    }
+    if (lastIndex < value.length) {
+        segments.push({ type: "text", text: value.slice(lastIndex) });
+    }
+    if (segments.length === 0) {
+        return [{ type: "text", text: value }];
+    }
+    return segments.filter((segment) => segment.type === "text" ? segment.text.length > 0 : true);
+}
+function parseSvgIcon(svg) {
+    const parsed = parseSVGContent(svg);
+    if (!parsed) {
+        throw new Error("Invalid icon");
+    }
+    const icon = convertParsedSVG(parsed);
+    if (!icon) {
+        throw new Error("Invalid icon");
+    }
+    return icon;
+}
+lucideIcons.aliases = {
+    "right-triangle": { parent: "chevron-down" },
+    install: { parent: "cloud-download" },
+    ...(lucideIcons.aliases || {}),
+};
+lucideIcons.categories ||= {};
+for (const [key, tags] of Object.entries(lucideTags)) {
+    for (const tag of tags) {
+        lucideIcons.categories[tag] ||= [];
+        if (!lucideIcons.categories[tag].includes(key)) {
+            lucideIcons.categories[tag].push(key);
+        }
+        if (lucideIcons.icons[key] && !lucideIcons.aliases[tag]) {
+            lucideIcons.aliases[tag] = { parent: key };
+        }
+    }
+}
+registerIconPacks([
+    { name: "lucide", icons: lucideIcons },
+    { name: "custom", icons: customIcons },
+]);
+export function getIconPacks() {
+    const iconLoaders = [];
+    const names = new Set();
+    for (const [name, icons] of iconsStore.entries()) {
+        iconLoaders.push({ name, icons });
+        names.add(name);
+    }
+    for (const [name, loader] of loaderStore.entries()) {
+        if (names.has(name)) {
+            continue;
+        }
+        iconLoaders.push({ name, loader });
+        names.add(name);
+    }
+    return iconLoaders;
+}
+export function getIconIds() {
+    const ids = new Set();
+    for (const icons of iconsStore.values()) {
+        Object.keys(icons.icons || {}).forEach((id) => ids.add(id));
+        Object.keys(icons.aliases || {}).forEach((id) => ids.add(id));
+    }
+    return [...ids].sort();
+}
+/**
+ * Adds an icon to the library.
+ *
+ * @param iconId - The icon ID
+ * @param svgContent - The content of the SVG.
+ * @public
+ */
+export function addIcon(iconId, svgContent) {
+    const icon = parseSvgIcon(svgContent);
+    if (icon) {
+        customIcons.icons[iconId] = icon;
+    }
+}
+export function removeIcon(iconId) {
+    delete customIcons.icons[iconId];
+    delete customIcons.aliases[iconId];
+}
+export function getIcon(iconId) {
+    for (const candidate of getIconCandidates(iconId)) {
+        const icons = candidate.prefix ? iconsStore.get(candidate.prefix) : null;
+        const iconData = icons ? getIconData(icons, candidate.name) : null;
+        if (!iconData)
+            continue;
+        const renderData = iconToSVG(iconData);
+        const wrapper = document.createElement("div");
+        wrapper.innerHTML = iconToHTML(replaceIDs(renderData.body), renderData.attributes);
+        return wrapper.firstElementChild;
+    }
+    return null;
+}
+/**
+ * Insert an SVG into the element from an iconId. Does nothing if no icon
+ * associated with the iconId.
+ *
+ * @param parent - The HTML element to insert the icon
+ * @param iconId - The icon ID
+ * @public
+ * @see The Obsidian icon library includes the {@link https://lucide.dev/ Lucide icon library}, any icon name from their site will work here.
+ */
+export function setIcon(parent, iconId) {
+    getSvg(iconId, { width: "24px", height: "24px" }).then((svg) => {
+        if (svg) {
+            parent.innerHTML = svg;
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+import "./enhance";
+export * from "./editor.svelte";
+export * from "./events";
+export * from "./components/editor/extensions/autocomplete";
+export * from "./components/editor/extensions/lint";
+export * from "./components/editor/language-service";
+export * from "./menu.svelte";
+export * from "./cache.svelte";
+export * from "./plugin";
+export * from "./plugin-capability-facade";
+export * from "./plugin-asset-server";
+export * from "./plugin-dependency-resolver";
+export * from "./plugin-dependency-scanner";
+export * from "./plugin-distribution";
+export * from "./plugin-install-progress";
+export * from "./lapis-extension";
+export * from "./plugin-runtime-entry";
+export * from "./plugin-manager";
+export * from "./settings.svelte";
+export * from "./view.svelte";
+export * from "./source-text-file-view";
+export * from "./workspace.svelte";
+export * from "./hooks";
+export * from "./context.svelte";
+export * from "./application-compatibility";
+export * from "./application-state.svelte";
+export * from "./workspace-trust";
+export * from "./context-keys.svelte";
+export * from "./icons/index";
+export * from "./storage/fs";
+export * from "./storage/memory-vault-adapter";
+export * from "./storage/blob-store";
+export * from "./storage/app-database";
+export * from "./storage/task-projection";
+export * from "./storage/index-projection";
+export * from "./storage/turso-app-database";
+export * from "./storage/search-embedding-provider";
+export * from "./storage/keyval";
+export * from "./storage/path";
+export { Vault, ENOTDIR, type VaultGlobOptions } from "./storage/vault.svelte";
+export * from "./storage/vault-state";
+export * from "./storage/native-vault-bootstrap-kv";
+export * from "./storage/vault-session";
+export * from "./storage/desktop-native";
+export * from "./storage/browser";
+export * from "./storage/browser-coordinated-app-database";
+export * from "./command.svelte";
+export * from "./configuration.svelte";
+export * from "./configuration-option-source-registry";
+export * from "./configuration-option-source-providers";
+export * from "./editor-view-registry";
+export * from "./glob";
+export * from "./platform";
+export * from "./suggest";
+export * from "./markdown";
+export * from "./markdown-extension-registry";
+export * from "./markdown-file-surface-registry";
+export * from "./logging";
+export * from "./telemetry";
+export * from "./notifications";
+export * from "./status-bar.svelte";
+export * from "./app-url";
+export * from "./agent-tools";
+export * from "./agent-skills";
+export * from "./agent-result-views";
+export * from "./language-service";
+export * from "./diagnostics";
+export * from "./metadata.svelte";
+export * from "./metadata-value";
+export * from "./embed-registry";
+export * from "./file-manager";
+export * from "./links";
+export * from "./localization-manager.svelte";
+export * from "./utils";
+export { debounce, type Debouncer } from "./utils";
+export * from "./promise-worker";
+export * from "./search";
+export * from "./search-query";
+export * from "./search-document-provider";
+export * from "./daily-document-provider";
+export * from "./loaders";
+export * from "./bases";
+export * from "./open-file";
+export * from "./popover";
+export * from "./prompt-confirm";
+export * from "./compat";
+export * from "./tasks";