@lapismd/mira 0.0.4 → 0.1.0

package/dist/preview/frontmatter/frontmatter.test.js

@@ -1,190 +0,0 @@
-import { describe, expect, it } from "vitest";
-import remarkFrontmatter from "remark-frontmatter";
-import { createParser } from "../renderer/utils";
-import { coerceFrontmatterValue, createFrontmatterPropertyManager, createFrontmatterReplacement, FrontmatterController, frontmatterProperties, mergeFrontmatterRecordProperties, parseFrontmatterYaml, removeFrontmatterRecordProperty, resolveFrontmatterWidget, serializeFrontmatterRecord, } from ".";
-import { remarkFrontmatterToHast, remarkPositionsToData } from "../remark";
-describe("frontmatter utilities", () => {
-    it("parses, mutates, and serializes portable YAML properties", () => {
-        const parsed = parseFrontmatterYaml("title: Demo\npublished: true\ncount: 2\ntags:\n  - mira\n");
-        expect(parsed.ok).toBe(true);
-        if (!parsed.ok) {
-            return;
-        }
-        const yaml = serializeFrontmatterRecord({
-            ...parsed.value,
-            title: "Updated",
-        });
-        expect(yaml).toContain("title: Updated");
-        expect(createFrontmatterReplacement(yaml)).toMatch(/^---\n/);
-    });
-    it("derives Lapis-style property types and icons", () => {
-        const properties = frontmatterProperties({
-            aliases: ["Mira"],
-            count: 2,
-            draft: false,
-            nested: { child: true },
-            published: "2026-06-27",
-            tags: ["mira", "editor"],
-            title: "Demo",
-        });
-        expect(properties.map((property) => [property.key, property.type])).toEqual([
-            ["aliases", "aliases"],
-            ["count", "number"],
-            ["draft", "checkbox"],
-            ["nested", "object"],
-            ["published", "date"],
-            ["tags", "tags"],
-            ["title", "text"],
-        ]);
-        expect(properties.find((property) => property.key === "tags")?.icon).toBe("lucide-hash");
-        expect(properties.find((property) => property.key === "nested")?.children[0]
-            ?.type).toBe("checkbox");
-    });
-    it("applies configured frontmatter property types and widgets", () => {
-        const properties = frontmatterProperties({
-            status: "draft",
-            title: "Demo",
-        }, {
-            types: {
-                status: {
-                    type: "workflow-state",
-                    label: "Workflow state",
-                    icon: "lucide-workflow",
-                    fallbackKind: "text",
-                    defaultValue: "draft",
-                    normalize: (value) => String(value).toUpperCase(),
-                },
-            },
-            widgets: [
-                {
-                    type: "workflow-state",
-                    label: "Workflow state",
-                    icon: "lucide-workflow",
-                    fallbackKind: "text",
-                    render: () => undefined,
-                },
-            ],
-        });
-        const status = properties.find((property) => property.key === "status");
-        expect(status?.type).toBe("workflow-state");
-        expect(status?.icon).toBe("lucide-workflow");
-        expect(resolveFrontmatterWidget({ widgets: [] }, "missing")).toBeNull();
-        expect(coerceFrontmatterValue("draft", "workflow-state", {
-            widgets: [
-                {
-                    type: "workflow-state",
-                    normalize: (value) => String(value).toUpperCase(),
-                },
-            ],
-        })).toBe("DRAFT");
-    });
-    it("removes nested object and array properties immutably", () => {
-        const source = {
-            nested: { keep: true, remove: "value" },
-            values: ["first", "second"],
-        };
-        expect(removeFrontmatterRecordProperty(source, ["nested", "remove"])).toEqual({
-            nested: { keep: true },
-            values: ["first", "second"],
-        });
-        expect(removeFrontmatterRecordProperty(source, ["values", 0])).toEqual({
-            nested: { keep: true, remove: "value" },
-            values: ["second"],
-        });
-        expect(source.nested.remove).toBe("value");
-    });
-    it("merges pasted properties into a portable parent record", () => {
-        const source = {
-            nested: { keep: true },
-            title: "Demo",
-        };
-        expect(mergeFrontmatterRecordProperties(source, ["nested"], {
-            owner: "[[Ada]]",
-            status: "ready",
-        })).toEqual({
-            nested: {
-                keep: true,
-                owner: "[[Ada]]",
-                status: "ready",
-            },
-            title: "Demo",
-        });
-    });
-    it("renders frontmatter as a component with source offsets", () => {
-        const parser = createParser([
-            remarkFrontmatter,
-            remarkFrontmatterToHast,
-            remarkPositionsToData,
-        ]);
-        const ast = parser("---\ntitle: Demo\n---\n\n# Heading");
-        const frontmatter = ast.children.find((node) => node.type === "element" && node.tagName === "frontmatter");
-        expect(frontmatter?.properties?.value).toBe("title: Demo");
-        expect(frontmatter?.properties?.["data-offset"]).toBe(0);
-        expect(frontmatter?.properties?.["data-offset-end"]).toBe(19);
-    });
-    it("creates a property manager that resolves widgets and setType", () => {
-        const manager = createFrontmatterPropertyManager({
-            types: {
-                status: {
-                    type: "workflow-state",
-                    label: "Workflow",
-                    icon: "lucide-workflow",
-                    fallbackKind: "text",
-                },
-            },
-            widgets: [
-                {
-                    type: "workflow-state",
-                    fallbackKind: "text",
-                    validate: (value) => typeof value === "string",
-                },
-            ],
-        });
-        expect(manager.resolveType("status", "status", "draft")).toBe("workflow-state");
-        expect(manager.resolveWidget("workflow-state")?.label).toBeUndefined();
-        expect(manager.typeOptions().some((option) => option.type === "text")).toBe(true);
-        manager.setType("priority", "number");
-        expect(manager.resolveType("priority", "priority", "1")).toBe("number");
-    });
-    it("commits controller record mutations through onRecordChange", async () => {
-        const commits = [];
-        const controller = new FrontmatterController({
-            record: { title: "Demo", count: 1 },
-            onRecordChange(commit) {
-                commits.push(commit.record);
-            },
-        });
-        controller.updateProperty(["title"], "Updated");
-        expect(controller.getRecord().title).toBe("Updated");
-        expect(commits.at(-1)).toEqual({ title: "Updated", count: 1 });
-        const added = controller.addProperty("text");
-        expect(added).toBeTruthy();
-        expect(Object.keys(controller.getRecord())).toContain(added);
-        controller.renameProperty([added], "subtitle");
-        expect(controller.getRecord()).toHaveProperty("subtitle");
-        expect(controller.getRecord()).not.toHaveProperty(added);
-        const title = controller.propertyManager
-            .properties(controller.getRecord())
-            .find((property) => property.key === "title");
-        expect(title).toBeTruthy();
-        controller.changePropertyKind(title, "checkbox");
-        expect(controller.getRecord().title).toBe(true);
-        expect(commits.length).toBeGreaterThan(3);
-    });
-    it("splices YAML into markdown through controller document adapters", () => {
-        const markdown = "---\ntitle: Demo\n---\n\nBody\n";
-        let nextValue = markdown;
-        const controller = new FrontmatterController({
-            yaml: "title: Demo",
-            getMarkdown: () => markdown,
-            dataOffset: 0,
-            dataOffsetEnd: 19,
-            onFrontmatterChange(_yaml, value) {
-                nextValue = value;
-            },
-        });
-        controller.updateProperty(["title"], "Updated");
-        expect(nextValue).toContain("title: Updated");
-        expect(nextValue).toContain("Body");
-    });
-});

package/dist/preview/frontmatter/suggestions.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=suggestions.test.d.ts.map

package/dist/preview/frontmatter/suggestions.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suggestions.test.d.ts","sourceRoot":"","sources":["../../../src/preview/frontmatter/suggestions.test.ts"],"names":[],"mappings":""}

package/dist/preview/frontmatter/suggestions.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { filterFrontmatterPropertySuggestions, filterFrontmatterValueSuggestions, parseFrontmatterPillWikilink, readFrontmatterPropertySuggestions, readFrontmatterValueSuggestions, } from "./suggestions";
-describe("frontmatter property suggestions", () => {
-    it("loads lazy suggestions and derives configured icons", async () => {
-        const suggestions = await readFrontmatterPropertySuggestions({
-            propertySuggestions: async () => [
-                "status",
-                { name: "owner", kind: "aliases" },
-                "status",
-            ],
-        });
-        expect(suggestions).toEqual([
-            { name: "status", icon: undefined },
-            { name: "owner", kind: "aliases", icon: "lucide-at-sign" },
-        ]);
-    });
-    it("filters, ranks prefixes, and excludes existing names", () => {
-        expect(filterFrontmatterPropertySuggestions([{ name: "review-status" }, { name: "status" }, { name: "state" }], "sta", ["state"]).map((suggestion) => suggestion.name)).toEqual(["status", "review-status"]);
-    });
-});
-describe("frontmatter value suggestions", () => {
-    it("loads keyed values and ranks prefix matches", async () => {
-        const suggestions = await readFrontmatterValueSuggestions({
-            valueSuggestions: (key, query) => key === "tags" && query.startsWith("p")
-                ? ["project/alpha", "inbox", "project/beta"]
-                : [],
-        }, "tags", "pro");
-        expect(suggestions).toEqual(["project/alpha", "project/beta"]);
-    });
-    it("excludes current pills and empty values", () => {
-        expect(filterFrontmatterValueSuggestions(["demo", "ideas", "demo", ""], "dem", [
-            "demo",
-        ])).toEqual([]);
-        expect(filterFrontmatterValueSuggestions(["ideas", "demo"], "ide", ["demo"])).toEqual(["ideas"]);
-    });
-});
-describe("frontmatter wikilink pills", () => {
-    it("recognizes only whole-value wikilinks", () => {
-        expect(parseFrontmatterPillWikilink("[[Project|Roadmap]]")).toEqual({
-            target: "Project",
-            text: "Roadmap",
-        });
-        expect(parseFrontmatterPillWikilink("See [[Project]]")).toBeNull();
-    });
-});

package/dist/preview/outline.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=outline.test.d.ts.map

package/dist/preview/outline.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outline.test.d.ts","sourceRoot":"","sources":["../../src/preview/outline.test.ts"],"names":[],"mappings":""}

package/dist/preview/outline.test.js

@@ -1,98 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { activeMarkdownOutlineId, findMarkdownOutlineScrollRoot, } from "./outline";
-function setVerticalLayout(element, layout) {
-    Object.defineProperties(element, {
-        clientHeight: { configurable: true, value: layout.clientHeight },
-        scrollHeight: { configurable: true, value: layout.scrollHeight },
-    });
-    element.getBoundingClientRect = () => ({
-        top: layout.top ?? 0,
-        bottom: (layout.top ?? 0) + layout.clientHeight,
-        height: layout.clientHeight,
-        left: 0,
-        right: 0,
-        width: 0,
-        x: 0,
-        y: layout.top ?? 0,
-        toJSON: () => ({}),
-    });
-}
-describe("Markdown outline scroll tracking", () => {
-    it("uses Mira's preview when it owns the scroll range", () => {
-        const outer = document.createElement("div");
-        const preview = document.createElement("div");
-        const heading = document.createElement("h1");
-        outer.style.overflowY = "auto";
-        preview.style.overflowY = "auto";
-        outer.append(preview);
-        preview.append(heading);
-        setVerticalLayout(outer, { clientHeight: 400, scrollHeight: 800 });
-        setVerticalLayout(preview, { clientHeight: 300, scrollHeight: 700 });
-        expect(findMarkdownOutlineScrollRoot(heading, preview)).toBe(preview);
-    });
-    it("finds a consumer scroll owner when the preview overflow is visible", () => {
-        const viewport = document.createElement("div");
-        const preview = document.createElement("div");
-        const heading = document.createElement("h1");
-        viewport.style.overflowY = "scroll";
-        preview.style.overflowY = "visible";
-        viewport.append(preview);
-        preview.append(heading);
-        setVerticalLayout(viewport, { clientHeight: 300, scrollHeight: 900 });
-        setVerticalLayout(preview, { clientHeight: 900, scrollHeight: 900 });
-        expect(findMarkdownOutlineScrollRoot(heading, preview)).toBe(viewport);
-    });
-    it("selects the last heading that crosses the active-section threshold", () => {
-        const items = [
-            { id: "intro", text: "Intro", level: 1 },
-            { id: "details", text: "Details", level: 2 },
-            { id: "finish", text: "Finish", level: 2 },
-        ];
-        const scrollRoot = document.createElement("div");
-        setVerticalLayout(scrollRoot, {
-            clientHeight: 300,
-            scrollHeight: 900,
-            top: 40,
-        });
-        const tops = new Map([
-            ["intro", 8],
-            ["details", 118],
-            ["finish", 390],
-        ]);
-        const resolveHeading = (item) => {
-            const element = document.createElement("h2");
-            setVerticalLayout(element, {
-                clientHeight: 32,
-                scrollHeight: 32,
-                top: tops.get(item.id),
-            });
-            return element;
-        };
-        expect(activeMarkdownOutlineId(items, resolveHeading, scrollRoot)).toBe("details");
-    });
-    it("keeps an explicitly focused outline target active while scrolling settles", () => {
-        const items = [
-            { id: "intro", text: "Intro", level: 1 },
-            { id: "details", text: "Details", level: 2 },
-        ];
-        const intro = document.createElement("h1");
-        const details = document.createElement("h2");
-        const scrollRoot = document.createElement("div");
-        const headings = new Map([
-            ["intro", intro],
-            ["details", details],
-        ]);
-        setVerticalLayout(scrollRoot, {
-            clientHeight: 300,
-            scrollHeight: 900,
-            top: 0,
-        });
-        setVerticalLayout(intro, { clientHeight: 32, scrollHeight: 32, top: 8 });
-        setVerticalLayout(details, {
-            clientHeight: 32,
-            scrollHeight: 32,
-            top: 390,
-        });
-        expect(activeMarkdownOutlineId(items, (item) => headings.get(item.id) ?? null, scrollRoot, 96, details)).toBe("details");
-    });
-});

package/dist/preview/portable-surfaces.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=portable-surfaces.test.d.ts.map

package/dist/preview/portable-surfaces.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"portable-surfaces.test.d.ts","sourceRoot":"","sources":["../../src/preview/portable-surfaces.test.ts"],"names":[],"mappings":""}