@liminis/editor 0.1.0-rc.1

package/dist/app/editor/c4/types.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Type definitions for the C4 architecture diagram plugin.
+ * Defines AST nodes for parsed C4 DSL and layout types for rendering.
+ */
+/**
+ * Type of C4 element in the diagram
+ */
+export type C4ElementType = 'system' | 'container' | 'component' | 'person';
+/**
+ * Shape override for C4 elements (e.g., cylinder for databases)
+ */
+export type C4Shape = 'rectangle' | 'cylinder' | 'queue';
+/**
+ * Layout direction for element groupings
+ */
+export type C4Direction = 'right' | 'down' | 'left' | 'up';
+/**
+ * Style modifier for elements (boundary creates dotted enclosure)
+ */
+export type C4Style = 'boundary';
+/**
+ * Properties that can be attached to any C4 element
+ */
+export interface C4Properties {
+    /** Technology stack (e.g., "React, TypeScript") */
+    tech?: string;
+    /** Description of the element's purpose */
+    description?: string;
+    /** Whether this is an external system */
+    external?: boolean;
+    /** Shape override (e.g., cylinder for databases) */
+    shape?: C4Shape;
+    /** Layout direction for children */
+    direction?: C4Direction;
+    /** Style modifier (boundary for dotted enclosure) */
+    style?: C4Style;
+}
+/**
+ * Core C4 element representing systems, containers, components, or persons.
+ * Elements can be nested (e.g., containers within systems).
+ */
+export interface C4Element {
+    /** Type of C4 element */
+    type: C4ElementType;
+    /** Unique identifier for this element (from [id] in DSL) */
+    id: string;
+    /** Human-readable name (from "Name" in DSL) */
+    name: string;
+    /** Element properties */
+    properties: C4Properties;
+    /** Nested child elements */
+    children: C4Element[];
+    /** Parent element id, if nested */
+    parent?: string;
+}
+/**
+ * Relationship between two C4 elements (arrow in diagram)
+ */
+export interface C4Relationship {
+    /** Source element id */
+    sourceId: string;
+    /** Target element id */
+    targetId: string;
+    /** Relationship label (e.g., "JSON/HTTPS", "SQL/TCP") */
+    label: string;
+}
+/**
+ * Complete C4 diagram AST
+ */
+export interface C4Diagram {
+    /** All elements in the diagram (flat list, nesting via parent field) */
+    elements: C4Element[];
+    /** All relationships between elements */
+    relationships: C4Relationship[];
+    /** Layout direction from LAYOUT_* directive */
+    direction?: C4Direction;
+}
+/**
+ * 2D point for edge routing
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Positioned node after layout calculation
+ */
+export interface LayoutNode {
+    /** Element id */
+    id: string;
+    /** X position (left edge) */
+    x: number;
+    /** Y position (top edge) */
+    y: number;
+    /** Node width */
+    width: number;
+    /** Node height */
+    height: number;
+    /** Reference to the C4 element */
+    element: C4Element;
+    /** Child nodes (for nested layout) */
+    children?: LayoutNode[];
+}
+/**
+ * Routed edge between two nodes
+ */
+export interface LayoutEdge {
+    /** Source node id */
+    source: string;
+    /** Target node id */
+    target: string;
+    /** Points defining the edge path */
+    points: Point[];
+    /** Edge label */
+    label: string;
+}
+/**
+ * Complete layout result ready for rendering
+ */
+export interface LayoutResult {
+    /** Positioned nodes */
+    nodes: LayoutNode[];
+    /** Routed edges */
+    edges: LayoutEdge[];
+    /** Total diagram width */
+    width: number;
+    /** Total diagram height */
+    height: number;
+    /** ViewBox origin X (non-zero when nodes have negative coordinates) */
+    viewBoxX: number;
+    /** ViewBox origin Y (non-zero when nodes have negative coordinates) */
+    viewBoxY: number;
+}
+/**
+ * Options for layout calculation
+ */
+export interface LayoutOptions {
+    /** Base width for nodes (default: 200) */
+    nodeWidth?: number;
+    /** Base height for nodes (default: 80) */
+    nodeHeight?: number;
+    /** Padding around nested elements (default: 20) */
+    nodePadding?: number;
+    /** Vertical separation between ranks (default: 80) */
+    rankSep?: number;
+    /** Horizontal separation between edges (default: 20) */
+    edgeSep?: number;
+}
+/**
+ * Parse error with location information
+ */
+export interface ParseError {
+    /** Error message */
+    message: string;
+    /** Line number (1-indexed) */
+    line: number;
+    /** Column number (1-indexed) */
+    column: number;
+}
+/**
+ * Result of parsing C4 DSL code
+ */
+export interface ParseResult {
+    /** Parsed diagram (null if parsing failed) */
+    diagram: C4Diagram | null;
+    /** Parse errors (empty if successful) */
+    errors: ParseError[];
+}
+/**
+ * Check if an element is a system
+ */
+export declare function isSystem(element: C4Element): boolean;
+/**
+ * Check if an element is a container
+ */
+export declare function isContainer(element: C4Element): boolean;
+/**
+ * Check if an element is a component
+ */
+export declare function isComponent(element: C4Element): boolean;
+/**
+ * Check if an element is a person
+ */
+export declare function isPerson(element: C4Element): boolean;
+/**
+ * Check if an element is external
+ */
+export declare function isExternal(element: C4Element): boolean;
+/**
+ * Check if an element has boundary style
+ */
+export declare function isBoundary(element: C4Element): boolean;
+/**
+ * Manual layout data for user-positioned diagram elements.
+ * When present, positions are user-defined instead of computed by dagre.
+ */
+export interface ManualLayout {
+    /** Element positions keyed by element ID */
+    positions: Record<string, {
+        x: number;
+        y: number;
+    }>;
+}

package/dist/app/editor/c4/types.js

@@ -0,0 +1,43 @@
+/**
+ * Type definitions for the C4 architecture diagram plugin.
+ * Defines AST nodes for parsed C4 DSL and layout types for rendering.
+ */
+// =============================================================================
+// TYPE GUARDS
+// =============================================================================
+/**
+ * Check if an element is a system
+ */
+export function isSystem(element) {
+    return element.type === 'system';
+}
+/**
+ * Check if an element is a container
+ */
+export function isContainer(element) {
+    return element.type === 'container';
+}
+/**
+ * Check if an element is a component
+ */
+export function isComponent(element) {
+    return element.type === 'component';
+}
+/**
+ * Check if an element is a person
+ */
+export function isPerson(element) {
+    return element.type === 'person';
+}
+/**
+ * Check if an element is external
+ */
+export function isExternal(element) {
+    return element.properties.external === true;
+}
+/**
+ * Check if an element has boundary style
+ */
+export function isBoundary(element) {
+    return element.properties.style === 'boundary';
+}

package/dist/app/editor/correction-yaml.d.ts

@@ -0,0 +1,10 @@
+export interface CorrectionEntry {
+    type: 'same_as' | 'retract';
+    canonical: string;
+    aliases: string[];
+    applied_at?: string;
+}
+export declare function parseCorrectionsYaml(raw: string | null): CorrectionEntry[];
+export declare function serializeCorrectionsYaml(entries: CorrectionEntry[]): string;
+export declare function mergeCorrection(entries: CorrectionEntry[], alias: string, canonical: string): CorrectionEntry[];
+export declare function isExistingCanonical(entries: CorrectionEntry[], text: string): boolean;

package/dist/app/editor/correction-yaml.js

@@ -0,0 +1,40 @@
+import { parse, stringify } from 'yaml';
+export function parseCorrectionsYaml(raw) {
+    if (!raw?.trim())
+        return [];
+    try {
+        const parsed = parse(raw);
+        if (!Array.isArray(parsed?.corrections))
+            return [];
+        return parsed.corrections.filter((e) => typeof e === 'object' &&
+            e !== null &&
+            (e.type === 'same_as' || e.type === 'retract') &&
+            typeof e.canonical === 'string' &&
+            Array.isArray(e.aliases) &&
+            e.aliases.every((a) => typeof a === 'string') &&
+            (e.applied_at === undefined || typeof e.applied_at === 'string'));
+    }
+    catch {
+        return [];
+    }
+}
+export function serializeCorrectionsYaml(entries) {
+    const file = { corrections: entries };
+    return stringify(file);
+}
+export function mergeCorrection(entries, alias, canonical) {
+    const result = entries.map((e) => ({ ...e, aliases: [...e.aliases] }));
+    // If alias exists in a same_as entry, update that entry's canonical (never touch retract entries)
+    const existingIdx = result.findIndex((e) => e.type === 'same_as' && e.aliases.includes(alias));
+    if (existingIdx >= 0) {
+        result[existingIdx] = { ...result[existingIdx], canonical };
+        return result;
+    }
+    // Otherwise append a new same_as entry
+    result.push({ type: 'same_as', canonical, aliases: [alias] });
+    return result;
+}
+export function isExistingCanonical(entries, text) {
+    const lower = text.toLowerCase();
+    return entries.some((e) => e.type === 'same_as' && e.canonical.toLowerCase() === lower);
+}

package/dist/app/editor/editorNodes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Lexical node classes the production editor configures its
+ * `LexicalComposer` with — extracted into its own module so it can be the
+ * single source of truth for both `Editor.tsx` and the public `./nodes`
+ * entry point (see #954 / ADR-075). A hand-maintained second copy of this
+ * list is exactly the drift risk this module exists to eliminate.
+ */
+import type { Klass, LexicalNode } from 'lexical';
+export declare const editorNodes: Klass<LexicalNode>[];

package/dist/app/editor/editorNodes.js

@@ -0,0 +1,36 @@
+import { HeadingNode, QuoteNode } from '@lexical/rich-text';
+import { CodeNode, CodeHighlightNode } from '@lexical/code';
+import { AutoLinkNode } from '@lexical/link';
+import { MarkNode } from '@lexical/mark';
+import { TableNode, TableRowNode, TableCellNode } from '@lexical/table';
+import { CalloutNode, ToggleContainerNode, ToggleTitleNode, ToggleContentNode, ImageNode, HorizontalRuleNode, EquationNode, MermaidNode, C4Node, FrontmatterNode, FootnoteNode, HtmlNode, ListItemParagraphBreakNode, CustomLinkNode, CustomListNode, DefinitionListNode, DefinitionTermNode, DefinitionDescriptionNode, CustomListItemNode, } from './nodes/index.js';
+export const editorNodes = [
+    HeadingNode,
+    QuoteNode,
+    CustomListNode, // Replaces ListNode - uses same type 'list' but carries spread (loose/tight) state
+    CustomListItemNode, // Replaces ListItemNode - uses same type 'listitem' but carries per-item task-checked state
+    CodeNode,
+    CodeHighlightNode,
+    CustomLinkNode, // Replaces LinkNode - uses same type 'link' but renders data-href
+    AutoLinkNode,
+    TableNode,
+    TableRowNode,
+    TableCellNode,
+    CalloutNode,
+    ToggleContainerNode,
+    ToggleTitleNode,
+    ToggleContentNode,
+    ImageNode,
+    HorizontalRuleNode,
+    EquationNode,
+    MermaidNode,
+    C4Node,
+    FrontmatterNode,
+    FootnoteNode,
+    DefinitionListNode,
+    DefinitionTermNode,
+    DefinitionDescriptionNode,
+    HtmlNode,
+    ListItemParagraphBreakNode,
+    MarkNode, // Annotation live marks (see ADR-077); inert unless an annotation kind is configured
+];

package/dist/app/editor/index.d.ts

@@ -0,0 +1 @@
+export { Editor } from './Editor.js';

package/dist/app/editor/index.js

@@ -0,0 +1 @@
+export { Editor } from './Editor.js';

package/dist/app/editor/mark-overlap-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { LexicalEditor } from 'lexical';
+/**
+ * Registers the un-nesting transform on `editor`. Returns the unregister
+ * function, so a host that mounts it in an effect can tear it down.
+ */
+export declare function registerMarkOverlapResolver(editor: LexicalEditor): () => void;

package/dist/app/editor/mark-overlap-resolver.js

@@ -0,0 +1,45 @@
+/**
+ * Un-nests overlapping annotation marks into id-unioned siblings (Liminis
+ * #970, FR-005/FR-006).
+ *
+ * `$wrapSelectionInMarkNode` does not merge ids. When a placement's selection
+ * lands inside an existing `MarkNode`, it creates a *nested* `MarkNode` inside
+ * it — its own source says as much, and defers un-nesting to "a call to
+ * `registerNestedElementResolver<MarkNode>` somewhere else in the codebase".
+ * Nothing registered one, so a pair of overlapping annotations produced a
+ * `<mark>` inside a `<mark>`: the inner element carries only the inner id, so
+ * the shared region resolves to one annotation rather than both, and a click
+ * there fires once for the inner mark and again for the outer as the event
+ * bubbles. `AnnotationMarkerPlugin` already groups its decorations *by DOM
+ * element*, on the stated assumption that "overlapping annotations share one
+ * MarkNode — and therefore one element"; this registration is what makes that
+ * assumption true.
+ *
+ * With it, an overlap becomes a run of sibling marks — the disjoint parts
+ * carrying one id each, the shared part carrying both — so every id still has
+ * at least one element, the shared element resolves to both ids, and removing
+ * one id leaves the other's coverage over the shared region intact (a
+ * `MarkNode` with ids remaining is not unwrapped; see
+ * `removeMarksForAnnotations`).
+ *
+ * `annotation-marks.ts`'s `locateLiveMarkdownRange` already handles an id
+ * spread across several sibling marks (first open token → last close token,
+ * with interior tokens stripped), so splitting a mark this way does not change
+ * any recovered range.
+ *
+ * This is a Lexical *node transform*, so it runs at the end of the update that
+ * created the nesting — inside the same `editor.update()` as the batch that
+ * placed the marks, preserving the single-reconciliation guarantee (FR-009).
+ */
+import { $createMarkNode, MarkNode } from '@lexical/mark';
+import { registerNestedElementResolver } from '@lexical/utils';
+/**
+ * Registers the un-nesting transform on `editor`. Returns the unregister
+ * function, so a host that mounts it in an effect can tear it down.
+ */
+export function registerMarkOverlapResolver(editor) {
+    return registerNestedElementResolver(editor, MarkNode, (from) => $createMarkNode(from.getIDs()), (from, to) => {
+        for (const id of from.getIDs())
+            to.addID(id);
+    });
+}

package/dist/app/editor/nodes/C4Component.d.ts

@@ -0,0 +1,14 @@
+/**
+ * C4Component - React component for rendering and editing C4 architecture diagrams
+ *
+ * Uses the canonical React C4Renderer for diagram display.
+ * Provides editing UI (textarea overlay, click-to-edit) for the Lexical editor.
+ * Supports manual layout mode for drag-and-drop positioning of elements.
+ */
+import { NodeKey } from 'lexical';
+interface C4ComponentProps {
+    code: string;
+    nodeKey: NodeKey;
+}
+export default function C4Component({ code, nodeKey, }: C4ComponentProps): JSX.Element;
+export {};