@codecanvas-ide/engine 0.0.0-stage → 0.1.0

package/dist/types/arrange.d.ts

@@ -0,0 +1,19 @@
+import type { Block, Point } from './types.js';
+/** Blocks laid out together: a block, or blocks side by side (row) or one above the other (column). */
+export type Arrangement = {
+    block: string;
+} | {
+    row: Arrangement[];
+} | {
+    column: Arrangement[];
+};
+interface Size {
+    w: number;
+    h: number;
+}
+/**
+ * Positions for sibling blocks that were never laid out, following the rules in layoutRules.ts.
+ * Positions are relative to the group's origin; sizes come from the caller.
+ */
+export declare function arrangeSiblings(blocks: Block[], sizeOf: (id: string) => Size, text: string, gap: number, isFile: boolean): Map<string, Point>;
+export {};

package/dist/types/canvas.d.ts

@@ -0,0 +1,257 @@
+import { type CanvasProject } from './project.js';
+import { type ConflictChoice } from './conflicts.js';
+import type { Block, CodeDiagnostic, FileLayout, FileModel, HostDiagnostic } from './types.js';
+export interface EditorOptions {
+    parent: HTMLElement;
+    text: string;
+    /** Where `text` is in the file, for an editor that shows just this part of the whole document. */
+    start: number;
+    end: number;
+    /** Selection to apply on open, relative to `text`. */
+    selection?: [number, number];
+    /** While changes are shown: the block's code in the base version ('' for an added block). Show a diff against it. */
+    diffBase?: string;
+    /** For editors on their own copy of `text`. Editors that edit the file itself don't call it. */
+    onChange(text: string): void;
+    /** User pressed Escape / Mod-Enter inside the editor. */
+    onClose(): void;
+}
+export interface EditorHandle {
+    focus(): void;
+    destroy(): void;
+    /**
+     * The editor edits the file's document directly (e.g. Monaco on the real file, for IntelliSense).
+     * The canvas then gets its changes through `setText` and keeps the editor open, following the block.
+     */
+    editsFile?: boolean;
+}
+/** The host provides the code editor used inside blocks (CodeMirror in the playground, Monaco in the IDE). */
+export type EditorFactory = (o: EditorOptions) => EditorHandle;
+export interface CodeCanvasOptions {
+    createEditor: EditorFactory;
+    /** The canvas changed the file's text. */
+    /**
+     * The canvas changed the file's text. When the same action changed other files too (a rename),
+     * `otherFiles` lists them, already updated in the project: the host should treat it all as one undo step.
+     */
+    onTextChange(text: string, otherFiles?: OtherFileChange[]): void;
+    /**
+     * Block positions or collapsed state changed. Save with `serializeLayout`. `automatic` changes
+     * (first layout, blocks added in the text, renames) don't come from the user arranging the canvas:
+     * a host may keep those out of the repo until there's a `user` change.
+     */
+    onLayoutChange(layout: FileLayout, reason: LayoutChangeReason): void;
+    onUndo?(): void;
+    onRedo?(): void;
+    onCameraChange?(scale: number): void;
+    theme?: 'dark' | 'light';
+    /**
+     * The project the file belongs to, for references across files and type errors. Keep it updated
+     * with the other files' text. Without one, the canvas only sees the open file.
+     */
+    project?: CanvasProject;
+    /** The selected block changed (null: nothing selected). */
+    onSelect?(block: Block | null): void;
+    /** The user picked a block in another file, e.g. in the references list. */
+    onOpenBlock?(path: string, blockId: string): void;
+}
+export type LayoutChangeReason = 'user' | 'automatic';
+/** Another file changed by the same canvas action, e.g. usages renamed there. */
+export interface OtherFileChange {
+    path: string;
+    before: string;
+    after: string;
+    /** The file's model before the change, to carry renamed blocks' saved positions (`carryRenames`). */
+    previousModel: FileModel | undefined;
+}
+/**
+ * The visual editor for one file. Text is the source of truth: every action on the canvas
+ * becomes a text edit, and every text change re-renders the canvas.
+ */
+export declare class CodeCanvas {
+    private opts;
+    readonly root: HTMLElement;
+    private world;
+    private frameEl;
+    private blocksEl;
+    private svg;
+    private bar;
+    private refsEl;
+    private banner;
+    private toastEl;
+    private path;
+    private text;
+    /** Latest parse. */
+    private model;
+    /** What's on screen: the latest parse without syntax errors. */
+    private view;
+    private layout;
+    private geom;
+    private hints;
+    private cam;
+    private camQueued;
+    private movingTimer;
+    private anim;
+    private lod;
+    /** The camera still shows the whole file as `fit` left it: resizing the view fits it again. */
+    private fittedToView;
+    private els;
+    private edges;
+    private selected;
+    private hovered;
+    private refsOpen;
+    private project;
+    /** Errors on screen: type errors from the last resolve, or syntax errors mapped onto the last good view. */
+    private diagnostics;
+    private incomingUsages;
+    /** The version changes are shown against (`setDiffBase`), and its geometry, computed once. */
+    private diffBase;
+    private diffCache;
+    /** Merge conflicts in the text. The canvas then shows its current side, marking the blocks they touch. */
+    private conflicts;
+    private incomingBlockEls;
+    private removedBlockEls;
+    /** Errors from the host (`setDiagnostics`), shown instead of the project's type errors. */
+    private hostDiagnostics;
+    private renaming;
+    /** The layout before the last Arrange, until the next layout change: Undo arrange puts it back. */
+    private layoutBeforeArrange;
+    /** Where the camera was before the block editor moved it out of the way, and where it moved it to. */
+    private cameraBeforeEditor;
+    private editing;
+    private clip;
+    private pointers;
+    private gesture;
+    private lastTap;
+    private lastPointer;
+    private toastTimer;
+    private ro;
+    private barObserver;
+    private cleanup;
+    constructor(container: HTMLElement, opts: CodeCanvasOptions);
+    /** Show a file. Fits it to the view. */
+    openFile(path: string, text: string, layout?: FileLayout | null): void;
+    /** The text changed outside the canvas (e.g. the text editor). */
+    setText(text: string): void;
+    /**
+     * Show the changes since a base version of the file (e.g. the last commit): unchanged blocks are
+     * desaturated, added and changed ones get a chip, removed ones show in red where they were.
+     * `layout` is the base version's saved layout, for placing removed blocks. Null hides the changes.
+     */
+    setDiffBase(base: {
+        text: string;
+        layout?: FileLayout | null;
+    } | null): void;
+    get isShowingChanges(): boolean;
+    private conflictsOf;
+    /** Resolve the conflicts that touch a block: their sections become the chosen side. */
+    keepConflictSide(id: string, choice: ConflictChoice): void;
+    /** While changes are shown: the block's code in the base version, '' if it's new. */
+    private baseCodeOf;
+    /** The changes of what's on screen, while a diff base is set. */
+    private currentDiff;
+    /**
+     * Errors reported by the host, e.g. VS Code's Problems. While set, the canvas shows these instead of
+     * resolving type errors itself. Pass null to go back to the project's own.
+     */
+    setDiagnostics(diagnostics: HostDiagnostic[] | null): void;
+    setLayout(layout: FileLayout): void;
+    getLayout(): FileLayout;
+    getModel(): FileModel | null;
+    /** Re-resolve usages and errors, e.g. after other files of the project changed. */
+    refreshProject(): void;
+    getDiagnostics(): CodeDiagnostic[];
+    setTheme(theme: 'dark' | 'light'): void;
+    get scale(): number;
+    /** Lay the whole file out again by the layout rules (layoutRules.ts), forgetting saved positions. */
+    arrange(): void;
+    undoArrange(): void;
+    /** Fit the whole file in the view. */
+    fit(animate?: boolean): void;
+    zoomBy(factor: number): void;
+    /** Center a block and select it. */
+    reveal(id: string): void;
+    select(id: string | null): void;
+    destroy(): void;
+    private usageTimer;
+    private parseNow;
+    /** Usage links and type errors go through the project's language service: only once typing pauses. */
+    private scheduleUsages;
+    private hostDiagnosticsOnBlocks;
+    /** The text changed while an editor on the file is open: keep tracking the part of the file it shows. */
+    private followEditedRange;
+    /** While the syntax is broken the last good view stays on screen: put its errors on the closest block it still has. */
+    private syntaxDiagnosticsOnView;
+    private get stale();
+    /** Apply a text edit made on the canvas. */
+    private commit;
+    private relayout;
+    private emitLayout;
+    private render;
+    /** Blocks only the incoming side of a conflict has, drawn dashed where they would go. */
+    private renderIncomingBlocks;
+    /** A changed block's preview: its changed lines with a line of context, as many as fit. */
+    private changedLinesPreview;
+    /** Removed blocks stay visible, in red, where they were in the base version. They can't be selected. */
+    private renderRemovedBlocks;
+    /** Diagnostics grouped by the block that shows them: the innermost visible block containing each error. */
+    private diagnosticsByShownBlock;
+    private updateErrorMarkers;
+    private blockHTML;
+    /** Faint miniature of a collapsed block's nested blocks. */
+    private miniMap;
+    private renderEdges;
+    private updateHighlight;
+    private queueCamera;
+    private applyCamera;
+    private setCamera;
+    private moveCamera;
+    private zoomAt;
+    private toWorld;
+    private local;
+    /** What's under a world point: a block (header or leaf), or empty space inside a container/the file. */
+    private hitTest;
+    private bindEvents;
+    private isOverlay;
+    private onDown;
+    private onMove;
+    private relayoutQueued;
+    private relayoutSoon;
+    private onUp;
+    private endDrag;
+    private onTap;
+    private onWheel;
+    private onKey;
+    private onClipboard;
+    private guard;
+    /** Edits that add, remove or rename blocks work on the text's structure, which conflicts break. */
+    private guardStructureEdit;
+    private toggleCollapse;
+    private createFunctionAt;
+    private createFunctionAtCenter;
+    /** Convert a world point into coordinates relative to a container's content origin. */
+    private relativeTo;
+    private applyInsert;
+    private deleteBlock;
+    private duplicate;
+    private copy;
+    private paste;
+    /** Show a name field in the block's header. Enter renames the block and its usages in every file. */
+    startRename(id: string): void;
+    private cancelRename;
+    private commitRename;
+    openEditor(id: string, selection?: [number, number]): void;
+    private openRangeEditor;
+    private onEditorChange;
+    closeEditor({ restoreCamera }?: {
+        restoreCamera?: boolean;
+    }): void;
+    private renderBar;
+    private toggleRefs;
+    private showErrorsOf;
+    private diagnosticsInside;
+    private refsFor;
+    private renderRefs;
+    private openEditorAtDiagnostic;
+    private toast;
+}

package/dist/types/conflicts.d.ts

@@ -0,0 +1,37 @@
+import type { TextEdit } from './edits.js';
+/** Where one side of a conflict is in the file: its code, without the marker lines. */
+export interface ConflictSide {
+    start: number;
+    end: number;
+}
+/**
+ * A merge conflict as git writes it into the file:
+ * `<<<<<<< current` … (`||||||| base` …) `=======` … `>>>>>>> incoming`.
+ */
+export interface ConflictHunk {
+    /** The whole section, marker lines included (up to and including the last marker's line break). */
+    start: number;
+    end: number;
+    current: ConflictSide;
+    incoming: ConflictSide;
+    /** Only with `merge.conflictStyle = diff3` (or zdiff3). */
+    base?: ConflictSide;
+    /** What git wrote after the markers, e.g. `HEAD` and the branch name. */
+    currentLabel: string;
+    incomingLabel: string;
+}
+export type ConflictChoice = 'current' | 'incoming' | 'both';
+/** One side of a conflicted file: each conflict replaced by that side's code. */
+export interface ConflictSideText {
+    text: string;
+    /** Where each conflict's code is in `text`, in the order of the hunks. */
+    hunkRanges: ConflictSide[];
+    /** The file offset of an offset in `text`. */
+    toFileOffset(offset: number): number;
+}
+/** The merge conflicts in a file. Unfinished marker sections are left alone. */
+export declare function findConflicts(text: string): ConflictHunk[];
+/** The file with every conflict replaced by one side's code. */
+export declare function conflictSideText(text: string, hunks: ConflictHunk[], side: 'current' | 'incoming'): ConflictSideText;
+/** The edit that resolves one conflict: its whole section becomes the chosen code. */
+export declare function resolveConflict(text: string, hunk: ConflictHunk, choice: ConflictChoice): TextEdit;

package/dist/types/diff.d.ts

@@ -0,0 +1,28 @@
+import type { Block, FileModel } from './types.js';
+/**
+ * How a block compares with the base version of its file (e.g. the last commit).
+ * - `containsChanges`: its own code is the same, but nested blocks changed.
+ */
+export type BlockChange = 'added' | 'changed' | 'containsChanges' | 'unchanged';
+export interface DiffLine {
+    kind: 'same' | 'added' | 'removed';
+    text: string;
+}
+export interface FileDiff {
+    base: FileModel;
+    /** The change of every block of the current version. */
+    changes: Map<string, BlockChange>;
+    /** Blocks of the base that are gone (only the outermost one of a removed subtree). */
+    removed: Block[];
+}
+/** Compare two versions of a file block by block. Blocks are matched by id, so a renamed block is removed + added. */
+export declare function diffModels(base: FileModel, current: FileModel): FileDiff;
+/** Line diff of a block's own code (nested blocks left out) between the base and now. */
+export declare function diffOwnCode(base: FileModel, baseBlock: Block | undefined, current: FileModel, block: Block): DiffLine[];
+/** Shortest edit script between two lists of lines (longest common subsequence). */
+export declare function diffLines(before: string[], after: string[]): DiffLine[];
+/** The changed lines, with one line of context around each change if there's room, to fit in `max` lines. */
+export declare function diffPreview(lines: DiffLine[], max: number): {
+    lines: DiffLine[];
+    more: number;
+};

package/dist/types/edits.d.ts

@@ -0,0 +1,38 @@
+import type { Block, FileModel } from './types.js';
+/** A single text replacement. */
+export interface TextEdit {
+    start: number;
+    end: number;
+    text: string;
+}
+export declare function applyEdit(text: string, e: TextEdit): string;
+/** Apply edits that don't overlap, given as offsets into the original text. */
+export declare function applyEdits(text: string, edits: TextEdit[]): string;
+/** Result of a structural edit: the text change plus the id the new block will have. */
+export interface InsertResult {
+    edit: TextEdit;
+    id: string;
+    /** Selection to put in the editor, relative to the new block's start. */
+    select: [number, number];
+}
+export declare function replaceBlock(model: FileModel, id: string, code: string): TextEdit;
+/** Remove a block and the blank space it leaves behind. */
+export declare function deleteBlock(model: FileModel, id: string): TextEdit;
+/** Pick a name that isn't taken in the block's scope. */
+export declare function uniqueName(model: FileModel, parentId: string | null, base: string): string;
+/** Where nested code can go: the block itself if it can hold code, else its nearest container. */
+export declare function containerFor(model: FileModel, id: string | null): Block | null;
+export declare function newFunction(model: FileModel, parentId: string | null, base?: string): InsertResult;
+/** What the clipboard holds after copying a block. */
+export interface BlockClip {
+    code: string;
+    name: string;
+    kind: Block['kind'];
+    /** Copied from inside a class (method/property syntax). */
+    fromClass: boolean;
+}
+export declare function copyBlock(model: FileModel, id: string): BlockClip;
+/** Paste a copied block into `parentId` (or the file), converting method ↔ function syntax as needed. */
+export declare function pasteBlock(model: FileModel, parentId: string | null, clip: BlockClip): InsertResult;
+/** Turn plain clipboard text (e.g. copied from another app) into a block clip. */
+export declare function clipFromText(code: string): BlockClip;

package/dist/types/html.d.ts

@@ -0,0 +1 @@
+export declare function setHTML(element: Element, html: string): void;

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+export * from './types.js';
+export { parseFile, detectIndentUnit, blockAt } from './parse.js';
+export { Project } from './project.js';
+export type { CanvasProject, ConfigFile, FileResolution, ProjectOptions, RenameResult } from './project.js';
+export { RemoteProject } from './remoteProject.js';
+export type { ProjectServerCall } from './remoteProject.js';
+export { ProjectServer, callProjectServer } from './projectServer.js';
+export type { ProjectServerMethod } from './projectServer.js';
+export { connectProjectWorker, serveProject } from './projectWorker.js';
+export type { MessagePortLike } from './projectWorker.js';
+export * from './edits.js';
+export { diffLines, diffModels, diffOwnCode, diffPreview } from './diff.js';
+export { conflictSideText, findConflicts, resolveConflict } from './conflicts.js';
+export type { ConflictChoice, ConflictHunk, ConflictSide, ConflictSideText } from './conflicts.js';
+export type { BlockChange, DiffLine, FileDiff } from './diff.js';
+export { computeGeometry, carryRenames, serializeLayout, emptyLayout, freeSpotNear, M } from './layout.js';
+export type { Geo, FileGeometry } from './layout.js';
+export { CodeCanvas } from './canvas.js';
+export type { CodeCanvasOptions, EditorFactory, EditorHandle, EditorOptions, LayoutChangeReason, OtherFileChange } from './canvas.js';
+export { injectStyles } from './styles.js';

package/dist/types/layout.d.ts

@@ -0,0 +1,75 @@
+import type { Block, FileLayout, FileModel, Point } from './types.js';
+/** Visual metrics. Monospace everywhere so sizes can be computed without measuring the DOM. */
+export declare const M: {
+    headerH: number;
+    headerCharW: number;
+    previewLineH: number;
+    previewCharW: number;
+    previewPad: number;
+    pad: number;
+    gap: number;
+    minW: number;
+    maxW: number;
+    miniH: number;
+    fileHeader: number;
+    filePad: number;
+};
+export interface Geo {
+    id: string;
+    block: Block;
+    /** Position relative to the parent's content origin. */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Absolute world position. */
+    ax: number;
+    ay: number;
+    /** Y offset (inside the block) where nested blocks start. */
+    contentTop: number;
+    collapsed: boolean;
+    /** Hidden because an ancestor is collapsed. */
+    hidden: boolean;
+}
+export interface FileGeometry {
+    geo: Map<string, Geo>;
+    /** Order to draw blocks: parents before children. */
+    order: Geo[];
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** Positions that were assigned during this pass (new blocks). Save them so they stay put. */
+    assigned: Record<string, Point>;
+}
+export declare function emptyLayout(): FileLayout;
+/**
+ * Compute every block's size and position. Saved positions are always respected.
+ * Blocks without a saved position get one: a tidy flow layout for a never-laid-out file,
+ * otherwise a free spot near their neighbors (or the hint, e.g. where the user clicked).
+ */
+export declare function computeGeometry(model: FileModel, layout: FileLayout, hints?: Record<string, Point>, opts?: {
+    resolveOverlaps?: boolean;
+}): FileGeometry;
+interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** The closest free spot to `at` (e.g. where a block was dropped or created). */
+export declare function freeSpotNear(at: Point, g: {
+    w: number;
+    h: number;
+    id?: string;
+}, placed: Rect[], clampPositive: boolean): Point;
+/**
+ * When a block is renamed its id changes. If exactly one block disappeared and one appeared
+ * under the same parent, carry the old position (and its children's) over to the new id.
+ */
+export declare function carryRenames(prev: FileModel | null, next: FileModel, layout: FileLayout): boolean;
+/** Layout ready to be written to `.codecanvas/`: only live blocks, sorted keys, whole numbers. */
+export declare function serializeLayout(layout: FileLayout, model: FileModel | null): string;
+export {};

package/dist/types/layoutRules.d.ts

@@ -0,0 +1,48 @@
+import type { Block } from './types.js';
+/**
+ * How the canvas arranges a group of sibling blocks (a file, or a class's members) the first time,
+ * to make the file easy to read. The arranger (arrange.ts) applies these rules; they only decide.
+ *
+ * Three kinds of rules:
+ * - zones: where a block goes (the left column, or a band from top to bottom)
+ * - stacks: blocks that always go together, one above the other
+ * - relatedness: which blocks end up next to each other
+ * Plus one shape the arranger always applies, the newspaper: a function on the left, the functions it
+ * calls in a column to its right, in the order it calls them.
+ */
+export type Zone = 'left' | 'data' | 'types' | 'main' | 'bottom';
+/** The bands from top to bottom. The left column holds `left` blocks next to all of them. */
+export declare const BAND_ORDER: Zone[];
+export interface ZoneRule {
+    zone: Zone;
+    description: string;
+    matches(block: Block): boolean;
+}
+/** First match wins. */
+export declare const ZONE_RULES: ZoneRule[];
+export interface StackRule {
+    description: string;
+    /** Pairs to stack: the first block on top, the second right below it. */
+    pairs(blocks: Block[]): [Block, Block][];
+}
+export declare const STACK_RULES: StackRule[];
+/** What a block knows about its siblings, read from its own code. */
+export interface SiblingFacts {
+    /** Sibling functions it calls, in the order of their first call. */
+    calls: string[];
+    /** Every sibling it names (calls included). */
+    uses: Set<string>;
+}
+export interface RelatednessRule {
+    description: string;
+    /** How strongly two blocks belong together (0: not at all). */
+    score(a: Block, b: Block, factsOf: (block: Block) => SiblingFacts): number;
+}
+export declare const RELATEDNESS_RULES: RelatednessRule[];
+/**
+ * How many levels of callees the newspaper shows to the right of a function. Deeper calls start a
+ * shape of their own, so a long chain of calls doesn't become one very wide staircase.
+ */
+export declare const NEWSPAPER_DEPTH = 3;
+/** The newspaper shape applies to these: a caller and the functions it calls. */
+export declare const isFunctionLike: (block: Block) => boolean;

package/dist/types/parse.d.ts

@@ -0,0 +1,72 @@
+import ts from 'typescript';
+import type { Block, CodeDiagnostic, FileModel, Usage } from './types.js';
+/**
+ * Parse a TypeScript file into a tree of blocks plus the usage links between them.
+ * Pure function: same text in, same model out.
+ */
+export declare function parseFile(path: string, text: string): FileModel;
+/**
+ * Fast part of parsing: blocks only (usages left empty). Pass the previous model of the same
+ * file to parse incrementally, re-reading only the changed region.
+ */
+export declare function parseStructure(path: string, text: string, prev?: FileModel | null): FileModel;
+/** Innermost block whose text range contains `offset`. */
+export declare function blockAt(model: FileModel, offset: number): Block | null;
+export declare function toCodeDiagnostic(model: FileModel, sf: ts.SourceFile, d: ts.Diagnostic, source: CodeDiagnostic['source']): CodeDiagnostic;
+/** The builder that produced `model`: used by the project to resolve usages across files. */
+export declare function builderOf(model: FileModel): Builder | undefined;
+/** Slower part: resolve every name to its declaration and link the blocks. */
+export declare function computeUsages(model: FileModel): Usage[];
+export declare function detectIndentUnit(text: string): string;
+declare class Builder {
+    private sf;
+    private text;
+    roots: Block[];
+    byId: Map<string, Block>;
+    /**
+     * Declaration node → block id, keyed by node position (see `nodeKey`) so a syntax tree parsed
+     * elsewhere from the same text (the project's language service) maps to the same blocks.
+     */
+    private declToBlock;
+    /** Range node → block, to find which block contains a usage. Keyed like `declToBlock`. */
+    private rangeToBlock;
+    /** Every name a usage could resolve to. Other identifiers skip the (slow) checker. */
+    readonly names: Set<string>;
+    constructor(sf: ts.SourceFile, text: string);
+    collectStatements(stmts: readonly ts.Statement[], parent: Block | null, depth: number, declarationsOnly?: boolean): void;
+    private addImport;
+    private addFunctionLike;
+    private addClass;
+    private collectMembers;
+    private addVariableStatement;
+    private addVariable;
+    private add;
+    /** Include doc comments directly above the node (no blank line in between). */
+    private startWithComments;
+    private lineStartOf;
+    private indentAt;
+    blockIdForDeclaration(declaration: ts.Node): string | undefined;
+    /**
+     * Link every name used inside a block to the block that declares it. `sf` is a tree of the same
+     * text (this builder's own, or the language service's when resolving across files).
+     */
+    collectUsages(sf: ts.SourceFile, checker: ts.TypeChecker, otherFiles?: OtherFileResolver): Usage[];
+    private recordUsage;
+}
+/** Finds blocks declared in other files of the project. */
+export interface OtherFileResolver {
+    /** Names declared anywhere in the project. Identifiers with other names skip the checker. */
+    projectNames: Set<string>;
+    blockInOtherFile(declaration: ts.Node): {
+        path: string;
+        id: string;
+    } | null;
+}
+/** Faint code preview: the block's own code with nested blocks cut out, dedented and trimmed. */
+/** The text of `range` with the given nested blocks cut out: a block's own code. */
+export declare function codeWithoutChildren(text: string, range: [number, number], children: Block[]): string;
+export declare function makePreview(text: string, range: [number, number], children: Block[], max: number): {
+    lines: string[];
+    more: number;
+};
+export {};