explorbot 0.4.10 → 0.5.0

package/dist/src/utils/mdq/edit.js

@@ -0,0 +1,147 @@
+import YAML from 'yaml';
+export class MarkdownEditor {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    static splitFrontmatter(source) {
+        if (!source.startsWith('---'))
+            return { raw: '', body: source, offset: 0 };
+        const match = source.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+        if (!match)
+            return { raw: '', body: source, offset: 0 };
+        return { raw: match[1], body: source.slice(match[0].length), offset: match[0].length };
+    }
+    static blockEnd(range) {
+        if (range.trailing)
+            return range.trailing.start + range.trailing.length;
+        return range.start + range.length;
+    }
+    static table(headers, rows, align) {
+        const widths = headers.map((header, index) => Math.max(header.length, 3, ...rows.map((row) => (row[index] || '').length)));
+        const line = (cells) => `| ${cells.map((cell, index) => (cell || '').padEnd(widths[index])).join(' | ')} |`;
+        const divider = `| ${widths.map((width, index) => MarkdownEditor.dashes(align[index], width)).join(' | ')} |`;
+        return `${[line(headers), divider, ...rows.map(line)].join('\n')}\n`;
+    }
+    static item(listRaw, text) {
+        const lines = listRaw.split('\n').filter((line) => line.trim());
+        const last = lines[lines.length - 1] || '- x';
+        const ordered = last.match(/^(\s*)(\d+)([.)])\s/);
+        if (ordered)
+            return `${ordered[1]}${Number.parseInt(ordered[2], 10) + 1}${ordered[3]} ${text}`;
+        const bullet = last.match(/^(\s*)([-*+])\s/);
+        if (!bullet)
+            return `- ${text}`;
+        return `${bullet[1]}${bullet[2]} ${text}`;
+    }
+    static entries(text, key, value, isBlockquote) {
+        const lines = text
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const index = lines.findIndex((line) => MarkdownEditor.entryKey(line) === key.toLowerCase());
+        if (index < 0 && value)
+            lines.push(`${key}: ${value}`);
+        if (index >= 0 && value)
+            lines[index] = `${key}: ${value}`;
+        if (index >= 0 && !value)
+            lines.splice(index, 1);
+        if (!isBlockquote)
+            return lines.join('\n');
+        return lines.map((line) => `> ${line}`).join('\n');
+    }
+    remove(ranges) {
+        const ordered = this.dedupe(ranges);
+        let result = this.source;
+        for (let i = ordered.length - 1; i >= 0; i--) {
+            const range = ordered[i];
+            const head = result.slice(0, range.start);
+            const tail = result.slice(MarkdownEditor.blockEnd(range));
+            if (tail) {
+                result = head + tail;
+                continue;
+            }
+            if (!head) {
+                result = '';
+                continue;
+            }
+            result = `${head.trimEnd()}\n`;
+        }
+        return result;
+    }
+    replace(ranges, render) {
+        const ordered = this.dedupe(ranges);
+        const rendered = ordered.map(render);
+        let result = this.source;
+        for (let i = ordered.length - 1; i >= 0; i--) {
+            const range = ordered[i];
+            result = result.slice(0, range.start) + rendered[i] + result.slice(range.start + range.length);
+        }
+        return result;
+    }
+    insert(offsets, markdown) {
+        const ordered = [...offsets].sort((a, b) => a - b);
+        let result = this.source;
+        for (let i = ordered.length - 1; i >= 0; i--) {
+            result = MarkdownEditor.spliceIn(result, ordered[i], markdown);
+        }
+        return result;
+    }
+    frontmatter() {
+        const { raw } = MarkdownEditor.splitFrontmatter(this.source);
+        if (!raw)
+            return {};
+        return YAML.parseDocument(raw).toJS() || {};
+    }
+    setFrontmatter(key, value) {
+        const { raw, body, offset } = MarkdownEditor.splitFrontmatter(this.source);
+        let document = new YAML.Document({});
+        if (raw)
+            document = YAML.parseDocument(raw);
+        if (value === null)
+            document.delete(key);
+        if (value !== null)
+            document.set(key, value);
+        const rendered = document.toString().trimEnd();
+        if (!offset)
+            return `---\n${rendered}\n---\n\n${this.source}`;
+        return `---\n${rendered}\n---\n${body}`;
+    }
+    static spliceIn(source, offset, markdown) {
+        const block = `${markdown.trimEnd()}\n`;
+        const before = source.slice(0, offset).replace(/\n+$/, '');
+        const after = source.slice(offset).replace(/^\n+/, '');
+        if (!before)
+            return `${block}\n${after}`;
+        if (!after)
+            return `${before}\n\n${block}`;
+        return `${before}\n\n${block}\n${after}`;
+    }
+    static dashes(alignment, width) {
+        if (alignment === 'center')
+            return `:${'-'.repeat(Math.max(width - 2, 1))}:`;
+        if (alignment === 'left')
+            return `:${'-'.repeat(Math.max(width - 1, 1))}`;
+        if (alignment === 'right')
+            return `${'-'.repeat(Math.max(width - 1, 1))}:`;
+        return '-'.repeat(width);
+    }
+    static entryKey(line) {
+        const separator = line.indexOf(':');
+        if (separator < 1)
+            return null;
+        return line.slice(0, separator).trim().toLowerCase();
+    }
+    dedupe(ranges) {
+        const sorted = [...ranges].sort((a, b) => a.start - b.start);
+        const kept = [];
+        let lastEnd = -1;
+        for (const range of sorted) {
+            if (range.start < lastEnd)
+                continue;
+            kept.push(range);
+            lastEnd = range.start + range.length;
+        }
+        return kept;
+    }
+}

package/dist/src/utils/mdq/query.d.ts

@@ -0,0 +1,118 @@
+import { type Token } from 'marked';
+import { MarkdownEditor } from './edit.js';
+export { MarkdownEditor };
+export declare class MarkdownQuery {
+    source: string;
+    matches: MatchedRange[];
+    constructor(source: string, matches?: MatchedRange[]);
+    query(selector: string, matcher?: Matcher): MarkdownQuery;
+    section(matcher?: Matcher, options?: SelectorOptions): MarkdownQuery;
+    heading(matcher?: Matcher, options?: SelectorOptions): MarkdownQuery;
+    paragraph(matcher?: Matcher): MarkdownQuery;
+    table(matcher?: Matcher): MarkdownQuery;
+    list(matcher?: Matcher): MarkdownQuery;
+    item(matcher?: Matcher): MarkdownQuery;
+    code(matcher?: Matcher): MarkdownQuery;
+    blockquote(matcher?: Matcher): MarkdownQuery;
+    comment(matcher?: Matcher): MarkdownQuery;
+    html(matcher?: Matcher): MarkdownQuery;
+    hr(): MarkdownQuery;
+    text(): string;
+    nodes(): NodeInfo[];
+    rows(): Record<string, string>[];
+    entries(): Record<string, string>;
+    frontmatter(): Record<string, unknown>;
+    count(): number;
+    exists(): boolean;
+    at(index: number): MarkdownQuery;
+    slice(from?: number, to?: number): MarkdownQuery;
+    first(): MarkdownQuery;
+    last(): MarkdownQuery;
+    each(): MarkdownQuery[];
+    preceding(): MarkdownQuery;
+    following(): MarkdownQuery;
+    replace(content: Markdown): MarkdownQuery;
+    replaceEach(replacer: (match: MarkdownQuery, index: number) => Markdown): MarkdownQuery;
+    remove(): MarkdownQuery;
+    insertBefore(markdown: Markdown): MarkdownQuery;
+    insertAfter(markdown: Markdown): MarkdownQuery;
+    prepend(markdown: Markdown): MarkdownQuery;
+    append(markdown: Markdown): MarkdownQuery;
+    addRow(row: Record<string, string>): MarkdownQuery;
+    addItem(text: string): MarkdownQuery;
+    setEntry(key: string, value: string | null): MarkdownQuery;
+    setFrontmatter(key: string, value: unknown): MarkdownQuery;
+    toString(): string;
+    valueOf(): string;
+    /** Compatibility aliases. Each delegates to the canonical name above; prefer those. */
+    get(): string;
+    meta(): NodeInfo[];
+    toJson(): Record<string, string>[];
+    keyValue(): Record<string, string>;
+    setKeyValue(key: string, value: string | null): MarkdownQuery;
+    before(): MarkdownQuery;
+    after(): MarkdownQuery;
+    editor(): MarkdownEditor;
+    run(candidates: MatchedRange[], segments: QuerySegment[]): MatchedRange[];
+    sectionsOf(candidates: MatchedRange[], segment: QuerySegment): MatchedRange[];
+    itemsOf(candidates: MatchedRange[]): MatchedRange[];
+    expandSections(matches: MatchedRange[]): MatchedRange[];
+    narrow(matches: MatchedRange[], segment: QuerySegment): MatchedRange[];
+    filterByText(matches: MatchedRange[], segment: QuerySegment): MatchedRange[];
+    matchText(text: string, matcher: TextMatcher): boolean;
+    valueMatcher(matcher: Matcher): TextMatcher;
+    tokenText(token: Token): string;
+    isComment(token: Token): boolean;
+    insertAll(offsetOf: (range: MatchedRange) => number, markdown: Markdown): MarkdownQuery;
+    containerStart(range: MatchedRange): number;
+    containerEnd(range: MatchedRange): number;
+}
+export declare class MdqError extends Error {
+}
+export declare class MdqSelectorError extends MdqError {
+    index: number;
+    constructor(message: string, index: number);
+}
+export declare class MdqOperationError extends MdqError {
+    constructor(message: string);
+}
+export declare function mdq(source: Markdown): MarkdownQuery;
+export declare function parseQuery(input: string): QuerySegment[];
+export declare function buildTokenIndex(source: string): MatchedRange[];
+export type Markdown = string | MarkdownQuery;
+export type Matcher = string | RegExp | ((text: string) => boolean);
+export type SelectorType = 'comment' | 'html' | 'section' | 'section1' | 'section2' | 'section3' | 'section4' | 'section5' | 'section6' | 'table' | 'heading' | 'paragraph' | 'list' | 'item' | 'code' | 'blockquote' | 'hr' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export interface SelectorOptions {
+    depth?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+export interface TextMatcher {
+    mode: 'exact' | 'contains' | 'regex' | 'predicate';
+    value: string;
+    negated: boolean;
+    flags?: string;
+    predicate?: (text: string) => boolean;
+}
+export interface QuerySegment {
+    selector: SelectorType;
+    textMatch?: TextMatcher;
+    index: number | null;
+    slice: {
+        from?: number;
+        to?: number;
+    } | null;
+}
+export interface MatchedRange {
+    token: Token;
+    start: number;
+    length: number;
+    trailing?: {
+        start: number;
+        length: number;
+    };
+    innerTokens?: MatchedRange[];
+}
+export interface NodeInfo {
+    type: string;
+    depth: number | null;
+    text: string;
+}