@draftably/editor 0.1.0 → 0.2.0

package/dist/types/src/import/browser.d.ts

@@ -1,3 +0,0 @@
-import type { ImportResult } from './import-core';
-/** Convert a supported text diagram without changing the current document. */
-export declare function importBrowser(source: string, filename?: string): Promise<ImportResult>;

package/dist/types/src/import/detect.d.ts

@@ -1,31 +0,0 @@
-/** A bounded dispatcher, not a parser. Ambiguous plain text never becomes D2 by guess. */
-export type KnownFormat = 'native' | 'mermaid' | 'dot' | 'd2' | 'plantuml' | 'dbml' | 'nomnoml';
-export interface DetectedSource {
-    status: 'detected';
-    format: KnownFormat;
-    source: string;
-    via: 'explicit' | 'extension' | 'fence' | 'signature';
-    /** One-based source line where the extracted content begins. */
-    startLine: number;
-}
-export interface FencedSource {
-    format: KnownFormat;
-    source: string;
-    startLine: number;
-}
-export type Detection = DetectedSource | {
-    status: 'choose-fence';
-    blocks: FencedSource[];
-} | {
-    status: 'unknown';
-    reason: string;
-};
-/** Focused conventional fences: <=3 leading spaces, backticks or tildes, closed.
- * A Markdown document is never sent wholesale to a diagram parser.
- * This intentionally does not implement every CommonMark container rule.
- */
-export declare function fencedSources(text: string): FencedSource[];
-export declare function detectSource(source: string, options?: {
-    filename?: string;
-    format?: KnownFormat;
-}): Detection;

package/dist/types/src/import/dot-importer.d.ts

@@ -1,3 +0,0 @@
-import { type ImportResult } from './import-core';
-/** Convert DOT and verify the generated source before exposing it to callers. */
-export declare function importDot(source: string, title?: string): ImportResult;

package/dist/types/src/import/import-core.d.ts

@@ -1,105 +0,0 @@
-/** Build native source from the facts retained by an importer. */
-import type { EndMarker } from '../model/markers';
-export type Format = 'dot' | 'mermaid' | 'd2';
-export type Impact = 'syntax' | 'semantics' | 'appearance' | 'layout' | 'security' | 'limit';
-export interface Diagnostic {
-    code: string;
-    severity: 'error' | 'warning' | 'info';
-    impact: Impact;
-    message: string;
-    line?: number;
-    column?: number;
-    foreignIds?: string[];
-}
-export interface NativeObject {
-    id: string;
-    kind: 'node' | 'group';
-    label: string;
-    parent?: string;
-    shape?: 'box' | 'pill' | 'circle' | 'diamond' | 'text';
-    color?: string;
-    shade?: number;
-}
-export interface NativeEdge {
-    id: string;
-    from: string;
-    to: string;
-    label: string;
-    directed: boolean;
-    head?: EndMarker;
-    tail?: EndMarker;
-    dashed?: boolean;
-    constraint?: false;
-    fromSide?: 'left' | 'right' | 'top' | 'bottom';
-    toSide?: 'left' | 'right' | 'top' | 'bottom';
-}
-export interface NativeLayout {
-    scope: string;
-    kind: 'flow' | 'column' | 'row' | 'sequence';
-    direction?: 'right' | 'down';
-}
-export interface NativeColor {
-    name: string;
-    fill: string;
-    stroke: string;
-    ink: string;
-}
-export interface NativePhase {
-    id: string;
-    label: string;
-    members: string[];
-}
-export interface NativeNote {
-    text: string;
-    near?: string;
-    side?: 'left' | 'right' | 'above' | 'below';
-}
-export interface NativePlan {
-    title: string;
-    objects: NativeObject[];
-    edges: NativeEdge[];
-    layouts: NativeLayout[];
-    colors: NativeColor[];
-    /** Sequence diagrams only. */
-    phases?: NativePhase[];
-    notes?: NativeNote[];
-}
-export interface IdMapping {
-    kind: string;
-    foreign: string;
-    native: string;
-}
-export interface ImportResult {
-    status: 'ready' | 'needs-review' | 'failed';
-    format: Format;
-    family: string;
-    diagnostics: Diagnostic[];
-    /** Absent on every fatal error; callers must not apply a partial graph. */
-    nativeSource?: string;
-    facts?: NativePlan;
-    ids: IdMapping[];
-    requires: string[];
-}
-export declare const LIMITS: Readonly<{
-    sourceBytes: number;
-    objects: 500;
-    edges: 1200;
-    depth: 12;
-    labelChars: number;
-    totalLabelBytes: number;
-    outputBytes: number;
-    nativeSourceChars: 300000;
-}>;
-export declare class Ids {
-    readonly entries: IdMapping[];
-    private readonly byForeign;
-    private readonly taken;
-    get(kind: string, foreign: string, preferred?: string): string;
-}
-export declare const quote: (value: string) => string;
-export declare const blankPlan: (title: string) => NativePlan;
-export declare function inputLimit(source: string): Diagnostic[];
-export declare function finish(format: Format, family: string, plan: NativePlan, diagnostics: Diagnostic[], ids: Ids): ImportResult;
-/** Only an explicit hex color is accepted. No CSS, URL, or Graphviz colorscheme interpretation. */
-export declare function hex(value: string | undefined): string | undefined;
-export declare function applyColor(plan: NativePlan, o: NativeObject, fill?: string, stroke?: string, ink?: string): void;

package/dist/types/src/import/mermaid-facade.d.ts

@@ -1,120 +0,0 @@
-/**
- * Tested against mermaid 12.2.0. Uses its internal DB behind a narrow, checked boundary.
- * This file parses only; it neither renders Mermaid nor attaches interaction callbacks.
- * Call in an isolated Node worker with a DOM, or in a dedicated browser Mermaid instance.
- */
-export declare const MERMAID_VERSION: "12.2.0";
-export type ParserDiagnostic = {
-    code: string;
-    severity: 'warning' | 'error';
-    message: string;
-    line?: number;
-    column?: number;
-    locationKind?: 'source' | 'parser-relative';
-};
-export type FlowVertex = {
-    id: string;
-    text: string;
-    type?: string;
-    labelType: string;
-    classes: string[];
-    styles: string[];
-    link?: string;
-    icon?: string;
-    img?: string;
-    props?: Record<string, unknown>;
-};
-export type FlowEdge = {
-    start: string;
-    end: string;
-    text: string;
-    type?: string;
-    stroke?: string;
-    id?: string;
-    isUserDefinedId: boolean;
-    labelType: string;
-    classes: string[];
-    style: string[];
-    length?: number;
-    interpolate?: string;
-    animate?: boolean;
-    animation?: string;
-};
-export type FlowGroup = {
-    id: string;
-    title: string;
-    nodes: string[];
-    dir?: string;
-    labelType: string;
-    classes: string[];
-    metadata?: Record<string, unknown>;
-};
-export type FlowClass = {
-    id: string;
-    styles: string[];
-    textStyles: string[];
-};
-export type FlowSnapshot = {
-    format: 'mermaid';
-    family: 'flowchart';
-    parserVersion: typeof MERMAID_VERSION;
-    direction: string;
-    vertices: FlowVertex[];
-    edges: FlowEdge[];
-    groups: FlowGroup[];
-    classes: FlowClass[];
-    defaultEdgeStyle: string[];
-    defaultEdgeInterpolate?: string;
-};
-/** One entry of Mermaid's ordered sequence log; `kind` is its LINETYPE name. */
-export type SequenceEvent = {
-    kind: string;
-    from?: string;
-    to?: string;
-    text: string;
-    placement?: 'left' | 'right' | 'over';
-    central: boolean;
-};
-export type SequenceActor = {
-    id: string;
-    name: string;
-    type: string;
-    box?: number;
-    links: string[];
-};
-export type SequenceBox = {
-    name?: string;
-    fill?: string;
-};
-export type SequenceSnapshot = {
-    format: 'mermaid';
-    family: 'sequence';
-    parserVersion: typeof MERMAID_VERSION;
-    title?: string;
-    actors: SequenceActor[];
-    boxes: SequenceBox[];
-    events: SequenceEvent[];
-    created: string[];
-    destroyed: string[];
-};
-export type ParseFlowResult = {
-    ok: true;
-    snapshot: FlowSnapshot | SequenceSnapshot;
-    diagnostics: ParserDiagnostic[];
-} | {
-    ok: false;
-    diagnostics: ParserDiagnostic[];
-};
-type MermaidApi = Pick<(typeof import('mermaid'))['default'], 'initialize' | 'mermaidAPI'>;
-/** DB strings contain Mermaid entity sentinels; preserve entity spelling for text decoding. */
-export declare function restoreEntitySpelling(value: string): string;
-/**
- * Use an unattached HTML template only. Its content is inert and is never adopted into the page.
- * Caller supplies the browser document or the dedicated worker's JSDOM document.
- * Markdown markers deliberately remain visible; native Markdown rendering is not assumed.
- */
-export declare function makePlainLabel(document: Document): (value: string) => string;
-export declare function preflightMermaidFlow(source: string): ParserDiagnostic[];
-/** Each factory owns a serialized queue because Mermaid maintains parser/configuration state. */
-export declare function createMermaidFlowParser(load: () => Promise<MermaidApi>): (source: string) => Promise<ParseFlowResult>;
-export {};

package/dist/types/src/import/mermaid-importer.d.ts

@@ -1,4 +0,0 @@
-import { type ImportResult } from './import-core';
-import { type ParseFlowResult } from './mermaid-facade';
-/** Convert a checked Mermaid snapshot into valid native source. */
-export declare function importMermaidFlow(parsed: ParseFlowResult, plainText: (value: string) => string, title?: string): ImportResult;

package/dist/types/src/import/mermaid-sequence.d.ts

@@ -1,8 +0,0 @@
-/**
- * Mermaid `sequenceDiagram` -> native source. Participants become nodes and messages become edges
- * in file order. Native sequences have no fragments, so each top-level branch of a block becomes
- * a phase band, and the warning says that the branch logic is gone.
- */
-import { type Diagnostic, type ImportResult } from './import-core';
-import type { SequenceSnapshot } from './mermaid-facade';
-export declare function mapMermaidSequence(snapshot: SequenceSnapshot, plainText: (value: string) => string, title: string, diagnostics: Diagnostic[]): ImportResult;

package/dist/types/src/import/scratch.d.ts

@@ -1,3 +0,0 @@
-/** Keep the imported native source before navigating away from the current diagram. */
-export declare function keepImportedSource(source: string): string;
-export declare function readImportedSource(id: string): string | null;

package/dist/types/src/lib/source-hash.d.ts

@@ -1,7 +0,0 @@
-/**
- * Source in a URL hash, deflated and base64url-encoded: `#s=<data>`. The hash never reaches a
- * server, so a shared link carries the diagram and nothing else.
- */
-export declare function encodeSource(source: string): Promise<string>;
-/** The source in a `#s=` hash, or null when there is none or it does not decode. */
-export declare function decodeSource(hash: string): Promise<string | null>;

package/dist/types/src/model/candidates.d.ts

@@ -1,53 +0,0 @@
-/**
- * Compare's reading of its candidates: what each one measures, which ones are the same drawing,
- * which few are worth showing, and how each differs from the current drawing.
- */
-import type { RoutingResult } from '../engines/routing-engine.js';
-import type { StaticScene } from './static-scene';
-export interface Measure {
-    crossings: number;
-    blocked: number;
-    overlaps: number;
-    labels: number;
-    bends: number;
-    length: number;
-    area: number;
-    aspect: number;
-}
-export declare function measure(scene: StaticScene, routing: RoutingResult): Measure;
-/** Two drawings match when every box and line agrees within a couple of pixels. */
-export declare function sameDrawing(a: StaticScene, b: StaticScene): boolean;
-export interface Reading {
-    /** Hard defects this candidate has that the current drawing does not. */
-    defects: string[];
-    gains: string[];
-    costs: string[];
-}
-export declare const count: (n: number, noun: string) => string;
-/** How a candidate differs from the current drawing, from its measures alone. */
-export declare function readDifference(m: Measure, base: Measure): Reading;
-/** The measures of the drawing the others are read against. */
-export declare const describeMeasure: (m: Measure) => string;
-export interface Candidate {
-    index: number;
-    measure: Measure;
-    scene: StaticScene;
-}
-/**
- * The sheet's slots after a change: each card in `keep` stays where it was, so a card never moves
- * under the pointer, and `fill` takes the free slots in order.
- */
-export declare function holdSlots(before: number[], keep: number[], fill: number[], limit: number): number[];
-/**
- * The candidates worth showing beside the current drawing, best first. Repeats of the current
- * drawing or of each other are dropped. A candidate with more hard defects than the current
- * drawing comes last, whatever its other measures, and the fewer it has the sooner it comes. A
- * candidate that beats the current drawing on something comes before one that does not: first the
- * best for hard defects, crossings, area and line length, then the ones with the fewest hard
- * defects and least like those already chosen.
- */
-export declare function pickCandidates(current: Candidate, candidates: Candidate[], limit: number): {
-    shown: number[];
-    others: number[];
-    alike: number;
-};

package/dist/types/src/model/examples.d.ts

@@ -1,15 +0,0 @@
-export interface ExampleInfo {
-    id: string;
-    title: string;
-    /** The first comment in the file. */
-    summary: string;
-    source: string;
-    nodes: number;
-    groups: number;
-    edges: number;
-    /** Deepest container nesting: 0 for a flat diagram. */
-    depth: number;
-}
-/** All examples, flattest first, so the list reads as a ladder of nesting depth. */
-export declare const EXAMPLES: ExampleInfo[];
-export declare const findExample: (id: string) => ExampleInfo | undefined;

package/dist/types/src/model/label-hits.d.ts

@@ -1,27 +0,0 @@
-/**
- * Where a drawing's text cannot be read: a connection label on another label, a shape, a group's
- * title or a line, and a shape title too long for its shape. Compare counts these for each
- * candidate and marks them on its card, so this has to stay cheap and read only the drawn scene.
- */
-import { type ResolvedAppearance } from './appearance';
-import type { DrawnRoute } from './routes';
-import type { StaticScene } from './static-scene';
-import type { DiagramGroup, Rect } from './types';
-/** Connection labels as boxes. Labels are centred on their spot. */
-export declare const labelBoxes: (routes: readonly DrawnRoute[]) => {
-    route: DrawnRoute;
-    box: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-}[];
-/** A group's title: its icon and text, as the canvas draws them. */
-export declare function groupTitleInk(g: DiagramGroup, r: Rect, look: ResolvedAppearance): Rect;
-export interface LabelHit {
-    /** What cannot be read, and where to mark it. */
-    box: Rect;
-    note: string;
-}
-export declare function labelHits(scene: StaticScene): LabelHit[];

package/dist/types/src/model/static-scene.d.ts

@@ -1,15 +0,0 @@
-import type { RoutingResult } from '../engines/routing-engine.js';
-import { type VisibleGraph } from './graph';
-import { type DrawnRoute } from './routes';
-import type { Diagram, Point, Rect } from './types';
-/** A read-only drawing of a document with precomputed routes, e.g. a comparison candidate. */
-export interface StaticScene {
-    doc: Diagram;
-    vg: VisibleGraph;
-    rects: Map<string, Rect>;
-    routes: DrawnRoute[];
-    bounds: Rect;
-}
-export declare function buildStaticScene(doc: Diagram, routing: RoutingResult): StaticScene;
-/** Center of an object in a scene, or of its nearest visible container when it is hidden. */
-export declare function anchorPoint(scene: StaticScene, id: string): Point;