@dineug/erd-editor 3.3.1 → 3.4.0

package/dist/services/shikiService.d.ts

@@ -1,6 +1,6 @@
 export type ShikiService = {
     codeToHtml(code: string, { lang, theme, }: {
-        lang: 'sql' | 'typescript' | 'graphql' | 'csharp' | 'java' | 'kotlin' | 'scala';
+        lang: 'sql' | 'typescript' | 'graphql' | 'csharp' | 'java' | 'kotlin' | 'scala' | 'go' | 'python';
         theme?: 'dark' | 'light';
     }): Promise<string>;
 };

package/dist/styles/colorPicker.style.d.ts

@@ -1 +1,10 @@
-export declare function createColorPickerStyle(): HTMLStyleElement;
+/**
+ * Vendored from https://github.com/easylogic/colorpicker.
+ *
+ * Global, not scoped. The picker's markup is built by the upstream library at runtime, outside
+ * anything r-html renders, so there is no element here to hang a generated component class on —
+ * every selector below matches by the literal class names that library writes
+ * (`.easylogic-colorpicker`, `.colorsets-contextmenu`), and scoping them would rename them out
+ * from under it. Last in `setGlobalStyleOrder`, which is where it sat when it was a tree `<style>`.
+ */
+export declare const colorPickerStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/styles/fonts.styles.d.ts

@@ -1,3 +1,4 @@
 export declare const TextFontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', 'Open Sans', system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji'";
 export declare const CodeFontFamily: "'Menlo', 'Consolas', 'Bitstream Vera Sans Mono', monospace, 'Apple Color Emoji', 'Segoe UI Emoji'";
-export declare function createFontsStyle(): HTMLStyleElement;
+/** Global, not scoped: `:host` is the shadow host, which no component class matches. */
+export declare const fontsStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/styles/reset.styles.d.ts

@@ -1 +1,5 @@
-export declare function createResetStyle(): HTMLStyleElement;
+/**
+ * Global, not scoped: every selector here is a type selector, the universal selector or `:host`,
+ * none of which survives having a component class prepended to it.
+ */
+export declare const resetStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/styles/scrollbar.styles.d.ts

@@ -1 +1,6 @@
-export declare function createScrollbarStyle(): HTMLStyleElement;
+/**
+ * Global, not scoped. The `::-webkit-scrollbar*` pseudo elements have no element of their own to
+ * hang a component class on, and `.scrollbar` is a hook class seven components opt into by
+ * literal name (`class=${['scrollbar', ...]}`) — scoping it would rename it out from under them.
+ */
+export declare const scrollbarStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/styles/typography.styles.d.ts

@@ -11,4 +11,5 @@ export declare const typography: {
     readonly normal: import('@dineug/r-html').CSSTemplateLiterals;
     readonly paragraph: import('@dineug/r-html').CSSTemplateLiterals;
 };
-export declare function createTypographyStyle(): HTMLStyleElement;
+/** Global, not scoped: `:host` is the shadow host, which no component class matches. */
+export declare const typographyStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/themes/radix-ui-theme.d.ts

@@ -1783,7 +1783,7 @@ export declare const AccentColor: {
     readonly sky: "sky";
 };
 export type AccentColor = ValuesType<typeof AccentColor>;
-export declare const AccentColorList: ("gray" | "gold" | "bronze" | "brown" | "yellow" | "amber" | "orange" | "tomato" | "red" | "ruby" | "crimson" | "pink" | "plum" | "purple" | "violet" | "iris" | "indigo" | "blue" | "cyan" | "teal" | "jade" | "green" | "grass" | "lime" | "mint" | "sky")[];
+export declare const AccentColorList: ("ruby" | "gray" | "gold" | "bronze" | "brown" | "yellow" | "amber" | "orange" | "tomato" | "red" | "crimson" | "pink" | "plum" | "purple" | "violet" | "iris" | "indigo" | "blue" | "cyan" | "teal" | "jade" | "green" | "grass" | "lime" | "mint" | "sky")[];
 export type ThemeOptions = {
     appearance: Appearance;
     grayColor: GrayColor;

package/dist/themes/tokens.d.ts

@@ -45,8 +45,8 @@ export type Theme = {
     minimapViewportBorderHover: string;
     toastBackground: string;
     toastBorder: string;
-    dargSelectBackground: string;
-    dargSelectBorder: string;
+    dragSelectBackground: string;
+    dragSelectBorder: string;
     scrollbarTrack: string;
     scrollbarThumb: string;
     scrollbarThumbHover: string;

package/dist/utils/calcTable.d.ts

@@ -1,6 +1,13 @@
 import { EngineContext } from '../engine/context';
 import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
+export declare function getWidthGeneration(): number;
+/**
+ * Invalidates every cached table size. Called from `recalculateTableWidth`,
+ * which rewrites widths without dispatching an action, and from the
+ * relationship-sort hook for any action that is not a pure move.
+ */
+export declare function invalidateTableWidths(): void;
 export declare function calcTableWidths(table: Table, { settings: { show, maxWidthComment }, collections }: RootState): ColumnWidth;
 export type ColumnWidth = {
     width: number;

package/dist/utils/draw-relationship/chamfer.d.ts

@@ -0,0 +1,2 @@
+import { Point } from '../../internal-types';
+export declare function chamferPolyline(points: Point[], size: number): Point[];

package/dist/utils/draw-relationship/index.d.ts

@@ -1,4 +1,4 @@
-import { Point, RelationshipPoint, ValuesType } from '../../internal-types';
+import { Point, Relationship, ValuesType } from '../../internal-types';
 export declare const DirectionName: {
     readonly left: "left";
     readonly right: "right";
@@ -78,15 +78,6 @@ export type RelationshipPath = {
         startCircle: Circle;
     };
 };
-export type RelationshipMarginPoint = {
-    xArray: number[];
-    yArray: number[];
-};
-export type RelationshipOrder = {
-    start: RelationshipPoint;
-    end: RelationshipPoint;
-    distance: number;
-};
 export type ObjectPoint = {
     width: number;
     height: number;
@@ -102,7 +93,75 @@ export type ObjectPoint = {
 export declare const isDirection: (value: string) => boolean;
 export declare const PATH_HEIGHT = 30;
 export declare const PATH_END_HEIGHT: number;
-export declare const PATH_LINE_HEIGHT = 35;
-export declare const LINE_SIZE = 10;
-export declare const LINE_HEIGHT = 16;
-export declare const CIRCLE_HEIGHT = 26;
+/**
+ * The cardinality decoration, measured outward from the anchor.
+ *
+ * The four are one shape and cannot be set independently: the second tick and
+ * the ring share a centre at `LINE_SIZE + LINE_HEIGHT`, the guide line starts
+ * where the longest stroke ends at `LINE_HEIGHT * 2 + 3`, and the ring has to
+ * clear the first tick behind it and the guide line in front of it, which puts
+ * its radius between those two.
+ *
+ * Scaled to 0.7 of what they were, so a decoration reaches 25px out rather than
+ * 35px. `RELATIONSHIP_STROKE_WIDTH` thinned the connector; leaving the notation
+ * at its old size would have made the crow's foot the heaviest thing on the
+ * canvas.
+ */
+export declare const LINE_SIZE = 7;
+export declare const LINE_HEIGHT = 11;
+export declare const CIRCLE_HEIGHT: number;
+export declare const CIRCLE_RADIUS = 6;
+export declare const PATH_LINE_HEIGHT: number;
+/**
+ * How far apart the corridors of two relationships leaving the same table side
+ * are placed. Without this every path on a side turns at the same `x` (or `y`),
+ * so their first segments run down one another no matter how far apart the
+ * anchors are spread.
+ */
+export declare const STUB_STEP = 12;
+/**
+ * Corridors repeat every fourth slot. Growing the stub without limit would walk
+ * a busy side's paths ever further from the table; wrapping keeps the longest
+ * stub at `PATH_END_HEIGHT + 3 * STUB_STEP` while leaving four slots — at least
+ * four anchor pitches apart — between any two that share a corridor.
+ */
+export declare const STUB_CYCLE = 4;
+/**
+ * The shortest a stub may be clamped to.
+ *
+ * It has to clear `PATH_LINE_HEIGHT`: the cardinality decorations reach that far
+ * out from the anchor and the guide line is drawn from there to the stub, so a
+ * shorter stub draws that line backwards. It is not derived from it. 36 is where
+ * the routing was measured, and letting it follow the decorations down to 26
+ * when they shrank took the medium corpus from 168px of collinear overlap to
+ * 484px — two tables facing each other closer than `2 * MIN_STUB` turn in
+ * earlier, and the routing bench found them sharing a corridor for 316px.
+ */
+export declare const MIN_STUB = 36;
+/**
+ * The widest gap allowed between two anchors on the same table side.
+ *
+ * Anchors used to be spread over the whole edge, so two relationships on a tall
+ * table splayed hundreds of pixels apart and converged again. Capping the pitch
+ * keeps a side's anchors together as a group; the side is only filled when it
+ * genuinely has that many relationships.
+ */
+export declare const ANCHOR_MAX_PITCH = 120;
+/** Keeps the outermost anchor of a side clear of the table's corners. */
+export declare const ANCHOR_EDGE_INSET = 12;
+/**
+ * How far back from a corner a connector turns, when the corner is drawn as a
+ * 45-degree cut rather than a right angle.
+ *
+ * Each cut is clamped to half of the shorter run it touches, so this is a ceiling
+ * rather than a length: a short run keeps its right angle instead of losing the
+ * whole of itself to two cuts. Two connectors turning the same way in
+ * neighbouring lanes stay `NUDGE_GAP` apart through the corner, so a bundle bends
+ * as a set of concentric cuts rather than converging on one.
+ */
+export declare const ROUTE_CHAMFER = 8;
+export declare function setStubSlots(relationship: Relationship, slots: readonly [number, number]): void;
+/** Falls back to slot zero, which reproduces the pre-stagger geometry. */
+export declare function getStubSlots(relationship: Relationship): readonly [number, number];
+export declare function setRoute(relationship: Relationship, points: Point[]): void;
+export declare function getRoute(relationship: Relationship): Point[] | undefined;

package/dist/utils/draw-relationship/nudge.d.ts

@@ -0,0 +1,3 @@
+import { Point } from '../../internal-types';
+import { Obstacles } from './route';
+export declare function nudgeRoutes(routes: Map<string, Point[]>, obstacles: Obstacles, endpoints: Map<string, [string, string]>): void;

package/dist/utils/draw-relationship/pathFinding.d.ts

@@ -1,3 +1,11 @@
-import { Relationship } from '../../internal-types';
+import { Point, Relationship } from '../../internal-types';
 import { RelationshipPath } from '.';
 export declare function getRelationshipPath(relationship: Relationship): RelationshipPath;
+/**
+ * The routing polyline as one `d`, so a connector is a single element whatever
+ * the router and the corner cuts made of it.
+ *
+ * The segments are contiguous by construction — they come from a polyline — so
+ * each one contributes its far end and nothing else.
+ */
+export declare function toPathD(segments: Array<[Point, Point]>): string;

package/dist/utils/draw-relationship/route.d.ts

@@ -0,0 +1,32 @@
+import { RootState } from '../../engine/state';
+import { Point } from '../../internal-types';
+export type Obstacles = {
+    ids: string[];
+    left: Float64Array;
+    top: Float64Array;
+    right: Float64Array;
+    bottom: Float64Array;
+};
+/**
+ * Every table in the document, not only those carrying a relationship: a table
+ * with no relationships at all still blocks the view.
+ */
+export declare function collectObstacles(state: RootState): Obstacles;
+/** Liang–Barsky, with no divisions until a slab actually clips. */
+export declare function segmentHitsBox(ax: number, ay: number, bx: number, by: number, left: number, top: number, right: number, bottom: number): boolean;
+/**
+ * How many tables a polyline passes through, ignoring the two it connects.
+ *
+ * This is the hot function of the whole router: every candidate is scored with
+ * it, and the nudge pass calls it twice per lane it tries. The polyline's own
+ * bounding box is computed once and used to skip tables outright — a connector
+ * spans a small part of the canvas, so most tables fail it. Every segment's box
+ * sits inside the polyline's, so a table the polyline's box misses is a table
+ * every segment's cheap reject would have missed too; the count is unchanged.
+ */
+export declare function countBlocked(points: Point[], obstacles: Obstacles, skipA: string, skipB: string): number;
+/**
+ * The cheapest orthogonal polyline from `m` to `l`, or a two-bend fallback when
+ * nothing is feasible — a connector always has to be drawn.
+ */
+export declare function routeOrthogonal(m: Point, mDirection: number, l: Point, lDirection: number, obstacles: Obstacles, skipA: string, skipB: string): Point[];

package/dist/utils/draw-relationship/stub.d.ts

@@ -0,0 +1,47 @@
+import { Point, Relationship } from '../../internal-types';
+/**
+ * Where a connector turns away from its anchor.
+ *
+ * Shared because two callers need the same answer: `pathFinding` draws from it,
+ * and `relationshipSort` routes from it. Deriving it twice would let the routed
+ * polyline and the guide line drift apart by a slot's worth of stub.
+ */
+/**
+ * Slot zero keeps the historical `PATH_END_HEIGHT`, so a relationship that never
+ * went through `relationshipSort` draws exactly as it did before.
+ */
+export declare function stubFor(slot: number): number;
+/**
+ * The axis-aligned distance between two anchors that point at each other, or
+ * `null` when they do not.
+ *
+ * Only this arrangement can collapse: with a stub on each side, a gap of twice
+ * the stub puts both turning points on the same spot and the connector vanishes,
+ * and a smaller gap inverts it so the path runs backwards through both tables.
+ * Nothing stops two tables being that close — the editor allows them to overlap.
+ */
+export declare function facingGap(start: Relationship['start'], end: Relationship['end']): number | null;
+/**
+ * Below roughly `2 * MIN_STUB` the two cardinality decorations already overlap
+ * each other, which no stub length can fix; the clamp stops short of making it
+ * worse by drawing the guide line backwards.
+ */
+export declare function clampStub(stub: number, gap: number | null): number;
+export type StubEnds = {
+    /** Turning point on the start side. */
+    m: Point;
+    /** Turning point on the end side. */
+    l: Point;
+    startStub: number;
+    endStub: number;
+};
+export declare function isHorizontal(direction: number): direction is 1 | 2;
+/** +1 when the anchor's outward normal points right or down. */
+export declare function outwardSign(direction: number): 1 | -1;
+/** The two points a route has to join, given the anchors and their slots. */
+export declare function stubEnds(relationship: Relationship): StubEnds;
+/**
+ * Where the guide line begins — the short run between the cardinality
+ * decorations and the routed polyline.
+ */
+export declare const GUIDE_START: number;

package/dist/utils/emitter.d.ts

@@ -17,6 +17,7 @@ declare const InternalActionType: {
     readonly mouseTrackerStart: "mouseTrackerStart";
     readonly mouseTrackerEnd: "mouseTrackerEnd";
     readonly openDiffViewer: "openDiffViewer";
+    readonly duplicateDragStart: "duplicateDragStart";
 };
 type InternalActionType = ValuesType<typeof InternalActionType>;
 type InternalActionMap = {
@@ -50,6 +51,10 @@ type InternalActionMap = {
     [InternalActionType.openDiffViewer]: {
         value: string;
     };
+    [InternalActionType.duplicateDragStart]: {
+        tableIds: string[];
+        memoIds: string[];
+    } | void;
 };
 type ListenerRecord = {
     [P in keyof InternalActionMap]: (action: Action<P, InternalActionMap>) => void;
@@ -165,4 +170,15 @@ export declare const openDiffViewerAction: {
     toString(): string;
     type: string;
 };
+export declare const duplicateDragStartAction: {
+    (payload: void | {
+        tableIds: string[];
+        memoIds: string[];
+    }): AnyAction<void | {
+        tableIds: string[];
+        memoIds: string[];
+    }>;
+    toString(): string;
+    type: string;
+};
 export {};

package/dist/utils/file/importFile.d.ts

@@ -1,6 +1,6 @@
 import { AppContext } from '../../components/appContext';
 type ImportOptions = {
-    type: 'json' | 'sql';
+    type: 'json' | 'sql' | 'graphql' | 'dbml' | 'aml';
     op: 'set' | 'diff';
     accept: string;
 };
@@ -8,5 +8,8 @@ type ImportFileCallback = (options: ImportOptions) => void;
 export declare function setImportFileCallback(callback: ImportFileCallback | null): void;
 export declare function importJSON({ store, emitter }: AppContext): void;
 export declare function importSchemaSQL({ store, emitter }: AppContext): void;
+export declare function importGraphQL({ store, emitter }: AppContext): void;
+export declare function importDBML({ store, emitter }: AppContext): void;
+export declare function importAML({ store, emitter }: AppContext): void;
 export declare function importDiffJSON({ emitter }: AppContext): void;
 export {};

package/dist/utils/focus.d.ts

@@ -1,5 +1,7 @@
-import { FocusTable, FocusType } from '../engine/modules/editor/state';
-export declare function isFocus(focusTable: FocusTable | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
+import { FocusTable, FocusType, SharedFocus } from '../engine/modules/editor/state';
+export declare function isFocus(focusTable: Pick<FocusTable, 'tableId' | 'columnId' | 'focusType'> | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare const isSelectColumn: (focusTable: FocusTable | null, tableId: string, columnId: string) => boolean;
 export declare function isEdit(focusTable: FocusTable | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare function lastCursorFocus(input: HTMLInputElement): void;
+export declare const toSharedFocus: (focusTable: FocusTable | null) => SharedFocus | null;
+export declare const toSharedFocusKey: (focus: SharedFocus | null) => string;

package/dist/utils/generator-code/aml.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/generator-code/dbml.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/generator-code/drizzle.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/generator-code/go.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/generator-code/sequelize.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/generator-code/sqlalchemy.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/generator-code/typeorm.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;

package/dist/utils/keyboard-shortcut/index.d.ts

@@ -28,7 +28,7 @@ export declare const KeyBindingName: {
     readonly zoomOut: "zoomOut";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "search" | "stop" | "primaryKey" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "zoomIn" | "zoomOut")[];
+export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "primaryKey" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "zoomIn" | "zoomOut")[];
 export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
 export declare const createKeyBindingMap: () => KeyBindingMap;
 export declare function shortcutToTuple(shortcut?: string): KeyBindingPress[];

package/dist/utils/promise.d.ts

@@ -1 +1,2 @@
+export declare const delay: (ms: number) => Promise<void>;
 export declare function closePromise(): [Promise<void>, () => void];

package/dist/utils/schema-aml-parser/convert.d.ts

@@ -0,0 +1,4 @@
+import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
+import { EngineContext } from '../../engine/context';
+import { AMLModel } from './types';
+export declare function convertToSchema(model: AMLModel, ctx: EngineContext, database: number): ERDEditorSchemaV3;

package/dist/utils/schema-aml-parser/dataType.d.ts

@@ -0,0 +1,13 @@
+import { AMLModel } from './types';
+/**
+ * `enumValues` carries the inline `status post_status(draft, published)`
+ * members, which never reach `model.types`. Both entry points take them as a
+ * trailing optional argument so `convert.ts` keeps one call site each, and
+ * inline members take precedence over anything the name would resolve to.
+ */
+export declare function resolveDataType(typeName: string, database: number, model: AMLModel, enumValues?: string[]): string;
+/**
+ * Keeps the members where the column type cannot hold them. Pass `database` to
+ * drop it on the dialects whose `ENUM(...)` column already spells them out.
+ */
+export declare function enumCommentSuffix(typeName: string, model: AMLModel, database: number, enumValues?: string[]): string;

package/dist/utils/schema-aml-parser/index.d.ts

@@ -0,0 +1,3 @@
+import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
+import { EngineContext } from '../../engine/context';
+export declare function schemaAMLParserToSchemaJson(aml: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3): string;

package/dist/utils/schema-aml-parser/parser.d.ts

@@ -0,0 +1,2 @@
+import { AMLParseResult } from './types';
+export declare function parseAMLModel(source: string): AMLParseResult;

package/dist/utils/schema-aml-parser/tokenizer.d.ts

@@ -0,0 +1,25 @@
+export declare const TokenKind: {
+    readonly identifier: 1;
+    readonly quoted: 2;
+    readonly string: 3;
+    readonly expression: 4;
+    readonly number: 5;
+    readonly punctuation: 6;
+    readonly doc: 7;
+    readonly comment: 8;
+    readonly newline: 9;
+};
+/**
+ * AML is indentation-sensitive, so every token carries the depth of its line --
+ * `-1` when the line is unindented, `0` for the first nesting level. A newline
+ * token opens the line that follows it and already holds that line's depth, and
+ * the stream always starts with a synthetic one (`value: ''`, `line: 0`), so
+ * `parser.ts` reads the first line's depth the same way as every other line's.
+ */
+export type Token = {
+    kind: number;
+    value: string;
+    line: number;
+    depth: number;
+};
+export declare function tokenize(source: string): Token[];

package/dist/utils/schema-aml-parser/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `tokenizer.ts` and `parser.ts` own every AML syntax concern -- indentation,
+ * quoting and the constraint grammar are resolved into the flat fields below,
+ * so `convert.ts` never sees a token. Nesting is resolved the same way: a
+ * nested attribute reaches `convert.ts` as one entry whose `path` is dotted.
+ */
+export type AMLNamespace = {
+    database: string;
+    catalog: string;
+    schema: string;
+};
+/** `-` and `--` read as `1`, `>` and `<>` as `n`. */
+export type AMLCardinality = '1' | 'n';
+export type AMLEndpoint = {
+    namespace: AMLNamespace;
+    entityName: string;
+    /** Dotted from the entity root, so a nested endpoint keeps `settings.slug`. */
+    attributePaths: string[];
+};
+export type AMLRelation = {
+    src: AMLEndpoint;
+    ref: AMLEndpoint;
+    srcCardinality: AMLCardinality;
+    refCardinality: AMLCardinality;
+    /** `-item_kind=User>`; the discriminator has no editor slot and is dropped. */
+    polymorphic: boolean;
+};
+/**
+ * One `unique` / `unique=name` / `index` / `index=name` constraint. A bare
+ * `unique` is a column flag; every other spelling groups by `name`.
+ */
+export type AMLAttributeIndex = {
+    name: string;
+    unique: boolean;
+};
+export type AMLAttribute = {
+    /** Dotted from the entity root; a root attribute is its own name. */
+    path: string;
+    comment: string;
+    /** Holds the argument list and any array suffix; never the namespace. */
+    typeName: string;
+    /** Inline `status post_status(draft, published)` members. */
+    enumValues: string[];
+    /** AML is NOT NULL by default, so `nullable` is what clears this. */
+    notNull: boolean;
+    primaryKey: boolean;
+    indexes: AMLAttributeIndex[];
+    default: string;
+    autoIncrement: boolean;
+};
+export type AMLEntity = {
+    namespace: AMLNamespace;
+    name: string;
+    alias: string;
+    comment: string;
+    attributes: AMLAttribute[];
+};
+/** A struct and a custom type carry neither field, which is what stops a lookup. */
+export type AMLType = {
+    values: string[];
+    /** `type uid int` -- the aliased name. */
+    alias: string;
+};
+export type AMLModel = {
+    entities: AMLEntity[];
+    /** Inline and standalone relations in source order, both with `src` filled. */
+    relations: AMLRelation[];
+    /** Keyed by the qualified name, so `cms.post_status` and `post_status` stay apart. */
+    types: Record<string, AMLType>;
+    skipped: string[];
+};
+export type AMLParseResult = {
+    ok: true;
+    model: AMLModel;
+} | {
+    ok: false;
+    message: string;
+};
+export declare const EMPTY_NAMESPACE: AMLNamespace;

package/dist/utils/schema-dbml-parser/convert.d.ts

@@ -0,0 +1,4 @@
+import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
+import { EngineContext } from '../../engine/context';
+import { DBMLModel } from './types';
+export declare function convertToSchema(model: DBMLModel, ctx: EngineContext, database: number): ERDEditorSchemaV3;

package/dist/utils/schema-dbml-parser/dataType.d.ts

@@ -0,0 +1,7 @@
+import { DBMLModel } from './types';
+export declare function resolveDataType(typeName: string, typeSchemaName: string, database: number, model: DBMLModel): string;
+/**
+ * Keeps the members where the column type cannot hold them. Pass `database` to
+ * drop it on the dialects whose `ENUM(...)` column already spells them out.
+ */
+export declare function enumCommentSuffix(typeName: string, typeSchemaName: string, model: DBMLModel, database: number): string;

package/dist/utils/schema-dbml-parser/index.d.ts

@@ -0,0 +1,3 @@
+import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
+import { EngineContext } from '../../engine/context';
+export declare function schemaDBMLParserToSchemaJson(dbml: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3): string;

package/dist/utils/schema-dbml-parser/parser.d.ts

@@ -0,0 +1,2 @@
+import { DBMLParseResult } from './types';
+export declare function parseDBMLModel(source: string): DBMLParseResult;

package/dist/utils/schema-dbml-parser/tokenizer.d.ts

@@ -0,0 +1,16 @@
+export declare const TokenKind: {
+    readonly identifier: 1;
+    readonly quoted: 2;
+    readonly string: 3;
+    readonly expression: 4;
+    readonly number: 5;
+    readonly punctuation: 6;
+    readonly operator: 7;
+    readonly newline: 8;
+};
+export type Token = {
+    kind: number;
+    value: string;
+    line: number;
+};
+export declare function tokenize(source: string): Token[];