phormat 0.0.5

package/dist/editor/inlineChrome/inlineChromeActions.js

@@ -0,0 +1,148 @@
+import { findBlockLocation } from '../model/blockTree';
+import { cloneInlineNodeDeep, splitInlineNodesAtPlainOffset } from '../model/inlineEditCommands';
+import { getCommandsForSurface } from '../commandRegistry';
+import { inlineChromeState } from './inlineChromeState.svelte';
+function blockLocation(editor, blockId) {
+    return findBlockLocation(editor.document.blocks, blockId);
+}
+function unwrapLinkInNodes(nodes, start, end) {
+    const a = Math.min(start, end);
+    const b = Math.max(start, end);
+    const s1 = splitInlineNodesAtPlainOffset(nodes.map(cloneInlineNodeDeep), a);
+    const s2 = splitInlineNodesAtPlainOffset(s1.right, b - a);
+    const mid = s2.left;
+    if (mid.length === 1 && mid[0]?.type === 'link') {
+        const link = mid[0];
+        return [...s1.left, ...link.children.map(cloneInlineNodeDeep), ...s2.right];
+    }
+    return null;
+}
+export function commandContextForBlockId(editor, blockId) {
+    const loc = blockLocation(editor, blockId);
+    if (!loc)
+        return null;
+    const block = loc.block;
+    const blockIndex = loc.topLevelIndex;
+    const nested = loc.path.length > 1;
+    const canMoveUp = loc.index > 0;
+    const canMoveDown = loc.index < loc.siblings.length - 1;
+    return {
+        editor,
+        blockIndex,
+        blockId: nested ? loc.parent.id : block.id,
+        blockType: nested ? loc.parent.type : block.type,
+        blockSynthetic: (nested ? loc.parent : block).sourceRange.synthetic ?? false,
+        canMoveUp,
+        canMoveDown,
+        nestedRowBlockId: nested ? block.id : undefined,
+        nestedRowBlockType: nested ? block.type : undefined
+    };
+}
+function applyWrapOnBlock(editor, blockId, plainStart, plainEnd, kind, linkHref) {
+    const loc = blockLocation(editor, blockId);
+    if (!loc)
+        return;
+    if (loc.path.length > 1) {
+        editor.applyInlineWrapOnNestedRow(loc.topLevelIndex, loc.block.id, plainStart, plainEnd, kind, linkHref);
+        return;
+    }
+    if (loc.block.type === 'paragraph' || loc.block.type === 'heading') {
+        editor.applyInlineWrapAt(loc.topLevelIndex, plainStart, plainEnd, kind, linkHref);
+    }
+}
+export function applyWrapFromChrome(kind, linkHref) {
+    const s = inlineChromeState;
+    const editor = s.editor;
+    const blockId = s.blockId;
+    if (!editor || !blockId || s.plainStart === s.plainEnd)
+        return;
+    applyWrapOnBlock(editor, blockId, s.plainStart, s.plainEnd, kind, linkHref);
+}
+export function applyUnlinkFromChrome() {
+    const s = inlineChromeState;
+    const editor = s.editor;
+    const blockId = s.blockId;
+    if (!editor || !blockId)
+        return;
+    const loc = blockLocation(editor, blockId);
+    if (!loc?.block.inlines?.length)
+        return;
+    const unwrapped = unwrapLinkInNodes(loc.block.inlines, s.plainStart, s.plainEnd);
+    if (unwrapped) {
+        applyWrapOnBlock(editor, blockId, s.plainStart, s.plainEnd, 'link', '');
+        return;
+    }
+    applyWrapOnBlock(editor, blockId, s.plainStart, s.plainEnd, 'link', '');
+}
+export function runTurnIntoCommand(commandId) {
+    const s = inlineChromeState;
+    const editor = s.editor;
+    const blockId = s.blockId;
+    if (!editor || !blockId)
+        return;
+    const ctx = commandContextForBlockId(editor, blockId);
+    if (!ctx)
+        return;
+    const cmd = getCommandsForSurface('blockMenu', ctx).find((c) => c.id === commandId);
+    cmd?.run(ctx);
+}
+export function headingCommandsForChrome() {
+    const s = inlineChromeState;
+    const editor = s.editor;
+    const blockId = s.blockId;
+    if (!editor || !blockId)
+        return [];
+    const ctx = commandContextForBlockId(editor, blockId);
+    if (!ctx)
+        return [];
+    return getCommandsForSurface('blockMenu', ctx).filter((c) => c.group === 'turnInto');
+}
+export function resolveLinkHoverFromElement(el) {
+    const linkEl = el.closest('[data-md-inline-link]');
+    if (!linkEl)
+        return null;
+    const surface = linkEl.closest('[data-md-inline-surface]');
+    const blockId = surface?.getAttribute('data-md-inline-surface');
+    if (!blockId)
+        return null;
+    const start = Number(linkEl.getAttribute('data-md-plain-start'));
+    const end = Number(linkEl.getAttribute('data-md-plain-end'));
+    const href = linkEl.getAttribute('data-md-link-href') ?? '';
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return null;
+    return { blockId, plainStart: start, plainEnd: end, href };
+}
+export function applyLinkHrefFromChrome(href) {
+    const s = inlineChromeState;
+    const editor = s.editor;
+    if (!editor)
+        return;
+    if (s.linkHover) {
+        applyWrapOnBlock(editor, s.linkHover.blockId, s.linkHover.plainStart, s.linkHover.plainEnd, 'link', href.trim());
+        return;
+    }
+    if (s.blockId && s.plainStart !== s.plainEnd) {
+        applyWrapOnBlock(editor, s.blockId, s.plainStart, s.plainEnd, 'link', href.trim());
+    }
+}
+export function currentInlinesForChrome() {
+    const s = inlineChromeState;
+    const editor = s.editor;
+    const blockId = s.blockId;
+    if (!editor || !blockId)
+        return [];
+    const loc = blockLocation(editor, blockId);
+    if (!loc)
+        return [];
+    const block = loc.block;
+    if (block.inlines?.length)
+        return block.inlines;
+    const text = block.type === 'heading'
+        ? block.data.text
+        : block.type === 'paragraph'
+            ? block.data.text
+            : '';
+    if (text)
+        return [{ type: 'text', text, sourceRange: block.sourceRange }];
+    return [];
+}

package/dist/editor/inlineChrome/inlineChromeState.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+export type InlineChromePanel = 'root' | 'heading' | 'link-edit';
+export type InlineChromeMode = 'closed' | 'selection' | 'link-hover';
+export type LinkHoverTarget = {
+    blockId: string;
+    plainStart: number;
+    plainEnd: number;
+    href: string;
+    element: HTMLElement;
+};
+export declare class InlineChromeState {
+    mode: InlineChromeMode;
+    panel: InlineChromePanel;
+    editor: MarkdownEditor | null;
+    /** Leaf block receiving formatting (paragraph, heading, or nested row). */
+    blockId: string | null;
+    plainStart: number;
+    plainEnd: number;
+    linkHover: LinkHoverTarget | null;
+    linkDraftHref: string;
+    reset(): void;
+}
+export declare const inlineChromeState: InlineChromeState;

package/dist/editor/inlineChrome/inlineChromeState.svelte.js

@@ -0,0 +1,21 @@
+export class InlineChromeState {
+    mode = $state('closed');
+    panel = $state('root');
+    editor = $state(null);
+    /** Leaf block receiving formatting (paragraph, heading, or nested row). */
+    blockId = $state(null);
+    plainStart = $state(0);
+    plainEnd = $state(0);
+    linkHover = $state(null);
+    linkDraftHref = $state('');
+    reset() {
+        this.mode = 'closed';
+        this.panel = 'root';
+        this.blockId = null;
+        this.plainStart = 0;
+        this.plainEnd = 0;
+        this.linkHover = null;
+        this.linkDraftHref = '';
+    }
+}
+export const inlineChromeState = new InlineChromeState();

package/dist/editor/inlineChrome/inlineToolbarIcons.d.ts

@@ -0,0 +1,14 @@
+/** Iconify lucide ids for the inline formatting toolbar. */
+export declare const inlineToolbarIcons: {
+    readonly bold: "lucide:bold";
+    readonly italic: "lucide:italic";
+    readonly code: "lucide:code";
+    readonly strikethrough: "lucide:strikethrough";
+    readonly highlight: "lucide:highlighter";
+    readonly link: "lucide:link";
+    readonly externalLink: "lucide:external-link";
+    readonly unlink: "lucide:unlink";
+    readonly heading: "lucide:heading";
+    readonly chevronLeft: "lucide:chevron-left";
+    readonly paragraph: "lucide:pilcrow";
+};

package/dist/editor/inlineChrome/inlineToolbarIcons.js

@@ -0,0 +1,14 @@
+/** Iconify lucide ids for the inline formatting toolbar. */
+export const inlineToolbarIcons = {
+    bold: 'lucide:bold',
+    italic: 'lucide:italic',
+    code: 'lucide:code',
+    strikethrough: 'lucide:strikethrough',
+    highlight: 'lucide:highlighter',
+    link: 'lucide:link',
+    externalLink: 'lucide:external-link',
+    unlink: 'lucide:unlink',
+    heading: 'lucide:heading',
+    chevronLeft: 'lucide:chevron-left',
+    paragraph: 'lucide:pilcrow'
+};

package/dist/editor/inlineChrome/inlineWrapActive.d.ts

@@ -0,0 +1,3 @@
+import type { InlineNode } from '../model/types.js';
+import type { InlineWrapKind } from '../model/inlineEditCommands.js';
+export declare function activeWrapKindsForRange(nodes: InlineNode[], start: number, end: number): Set<InlineWrapKind>;

package/dist/editor/inlineChrome/inlineWrapActive.js

@@ -0,0 +1,19 @@
+import { inlineRangeFullyCoveredByKind } from '../model/inlineEditCommands.js';
+const WRAP_TYPES = [
+    'strong',
+    'emphasis',
+    'code',
+    'strikethrough',
+    'highlight',
+    'link'
+];
+export function activeWrapKindsForRange(nodes, start, end) {
+    const active = new Set();
+    if (start === end)
+        return active;
+    for (const kind of WRAP_TYPES) {
+        if (inlineRangeFullyCoveredByKind(nodes, start, end, kind))
+            active.add(kind);
+    }
+    return active;
+}

package/dist/editor/inlineChrome/selectionRect.d.ts

@@ -0,0 +1,2 @@
+/** Union of client rects for the current DOM selection (viewport coordinates). */
+export declare function selectionBoundingRect(): DOMRect | null;

package/dist/editor/inlineChrome/selectionRect.js

@@ -0,0 +1,23 @@
+/** Union of client rects for the current DOM selection (viewport coordinates). */
+export function selectionBoundingRect() {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0 || sel.isCollapsed)
+        return null;
+    const range = sel.getRangeAt(0);
+    const rects = range.getClientRects();
+    if (rects.length === 0) {
+        const r = range.getBoundingClientRect();
+        return r.width === 0 && r.height === 0 ? null : r;
+    }
+    let left = Infinity;
+    let top = Infinity;
+    let right = -Infinity;
+    let bottom = -Infinity;
+    for (const r of rects) {
+        left = Math.min(left, r.left);
+        top = Math.min(top, r.top);
+        right = Math.max(right, r.right);
+        bottom = Math.max(bottom, r.bottom);
+    }
+    return new DOMRect(left, top, right - left, bottom - top);
+}

package/dist/editor/model/blockEditCommands.d.ts

@@ -0,0 +1,73 @@
+import type { HeaderBlock } from '../block-specs/heading/types';
+import { type TransactionBuildResult } from './editorTransactions';
+import type { EditorDocument, EditorSelection } from './types';
+import type { FocusOutcome } from './focusOutcome';
+import { type InlineWrapKind } from './inlineEditCommands';
+export type SourceEditOk = {
+    ok: true;
+    source: string;
+    selection: EditorSelection;
+};
+export type SourceEditErr = {
+    ok: false;
+    error: string;
+};
+export type SourceEditResult = SourceEditOk | SourceEditErr;
+export type SplitBlockAtPlainOffsetResult = SourceEditResult;
+export declare const EDITOR_HISTORY_LIMIT = 120;
+export declare function replaceSourceRange(source: string, start: number, end: number, replacement: string): string;
+/** Serialized block markdown often omits the final line terminator that `sourceRange.end` still covers. */
+export declare function normalizeBlockSliceReplacement(source: string, start: number, end: number, replacement: string): string;
+export declare function replaceBlockSourceRange(source: string, start: number, end: number, replacement: string): string;
+export { paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, paragraphPlainOffsetToSourceOffset } from '../block-specs/paragraph';
+export { headingBodySourceRange, headingDisplayPlain, headingMarkdown, headingPlainOffsetToSourceOffset } from '../block-specs/heading/edit';
+/** Replace paragraph or heading body from a plain-text edit; preserves `inlines` when a single-character delta patches the AST. */
+export declare function updateBlockPlainText(source: string, doc: EditorDocument, blockIndex: number, plainText: string, kind: 'paragraph' | 'heading', selectionPlainOffset: number): SourceEditResult;
+/** Wrap plain-text selection in Markdown inline spans (paragraph or heading body). */
+export declare function applyInlineWrap(source: string, doc: EditorDocument, blockIndex: number, plainStart: number, plainEnd: number, kind: InlineWrapKind, linkHref?: string): SourceEditResult;
+/** Turn `# title` / `- item` / `1. item` plain lines into the corresponding Markdown block slice. */
+export declare function isStructuralMarkdownShortcutLine(plainText: string): boolean;
+export type StructuralShortcutTrigger = 'space' | 'enter' | 'blur';
+/** Whether Space, Enter, or blur should run **structural markdown shortcut** for this plain line. */
+export declare function isStructuralMarkdownShortcutTrigger(plainText: string, trigger: StructuralShortcutTrigger, options?: {
+    allowMarkerOnlyList?: boolean;
+}): boolean;
+/** Marker-only list/task prefixes completed by Space or Enter (not blur). Paragraph bodies only. */
+export declare function markerOnlyListShortcutMarkdown(plainText: string): string | null;
+export declare function paragraphShortcutMarkdown(plainText: string): string | null;
+export type StructuralShortcutEdit = SourceEditOk & {
+    focusAfter: FocusOutcome;
+};
+/** Focus after **structural markdown shortcut** conversion (heading body plain or list item body). */
+export declare function buildStructuralShortcutFocusOutcome(doc: EditorDocument, blockIndex: number, plainText: string, md: string): FocusOutcome;
+/** Apply line-start markdown shortcut on a top-level **paragraph** or **heading** body. */
+export declare function applyStructuralMarkdownShortcut(source: string, doc: EditorDocument, blockIndex: number, plainText: string): StructuralShortcutEdit | SourceEditErr;
+/** @deprecated Prefer {@link applyStructuralMarkdownShortcut}. */
+export declare function applyParagraphShortcut(source: string, doc: EditorDocument, blockIndex: number, plainText: string): SourceEditResult;
+export declare function splitBlockAtPlainOffset(source: string, doc: EditorDocument, blockIndex: number, plainOffset: number, kind: 'paragraph' | 'heading'): SplitBlockAtPlainOffsetResult;
+/** Insert an empty paragraph before (`after === false`) or after the block. */
+export declare function insertEmptyParagraphRelative(source: string, doc: EditorDocument, blockIndex: number, after: boolean): SourceEditOk;
+/** Source transaction for inserting a canonical empty **paragraph** sibling. */
+export declare function buildEmptyParagraphInsertTransaction(source: string, doc: EditorDocument, blockIndex: number, after: boolean, txId: string): TransactionBuildResult;
+export type MergeWithPreviousResult = SourceEditOk & {
+    focusAfter: FocusOutcome;
+};
+export declare function mergeWithPreviousBlock(source: string, doc: EditorDocument, blockIndex: number): MergeWithPreviousResult | SourceEditErr;
+/** Replace the raw markdown slice for one block (used for list/code/blockquote textareas). */
+export declare function replaceBlockMarkdownSlice(source: string, doc: EditorDocument, blockIndex: number, replacement: string): SourceEditResult;
+export declare function deleteBlock(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult;
+/** Inserts a copy of the block's markdown after it; caret at start of duplicate body region. */
+export declare function duplicateBlock(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult;
+/** Swap two adjacent blocks so the lower-index block moves earlier (same as moving block at `lowerIndex` up). */
+export declare function swapAdjacentBlocks(source: string, doc: EditorDocument, upperBlockIndex: number): SourceEditResult;
+export declare function moveBlockUp(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult;
+export declare function moveBlockDown(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult;
+/**
+ * Reorders blocks by moving one block to a new index via repeated {@link swapAdjacentBlocks},
+ * reparsing between swaps so ranges stay valid. Preserves irregular inter-block gaps that would
+ * be lost by joining slices with a single `\n\n`.
+ */
+export declare function moveBlockToIndex(source: string, doc: EditorDocument, fromIndex: number, toIndex: number): SourceEditResult;
+export declare function convertParagraphToHeading(source: string, doc: EditorDocument, blockIndex: number, level: HeaderBlock['level']): SourceEditResult;
+export declare function convertHeadingLevel(source: string, doc: EditorDocument, blockIndex: number, level: HeaderBlock['level']): SourceEditResult;
+export declare function convertHeadingToParagraph(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult;