@dineug/erd-editor 3.9.2 → 4.0.0

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

@@ -1744,6 +1744,10 @@ export declare const Appearance: {
 };
 export type Appearance = ValuesType<typeof Appearance>;
 export declare const AppearanceList: ("dark" | "light")[];
+/** The theme builder's third appearance: the light or dark the system shows. */
+export declare const SYSTEM_APPEARANCE = "system";
+export type AppearanceOption = Appearance | typeof SYSTEM_APPEARANCE;
+export declare const AppearanceOptionList: ReadonlyArray<AppearanceOption>;
 export declare const GrayColor: {
     readonly gray: "gray";
     readonly mauve: "mauve";
@@ -1783,11 +1787,15 @@ export declare const AccentColor: {
     readonly sky: "sky";
 };
 export type AccentColor = ValuesType<typeof AccentColor>;
-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 declare const AccentColorList: ("ruby" | "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "teal" | "cyan" | "sky" | "blue" | "indigo" | "violet" | "purple" | "pink" | "gray" | "gold" | "bronze" | "brown" | "tomato" | "crimson" | "plum" | "iris" | "jade" | "grass" | "mint")[];
 export type ThemeOptions = {
-    appearance: Appearance;
+    appearance: AppearanceOption;
     grayColor: GrayColor;
     accentColor: AccentColor;
 };
-export declare const createTheme: ({ grayColor, accentColor, appearance, }: ThemeOptions) => Theme;
+/** Theme options with system resolved to the light or dark a theme is built for. */
+export type ResolvedThemeOptions = Omit<ThemeOptions, 'appearance'> & {
+    appearance: Appearance;
+};
+export declare const createTheme: ({ grayColor, accentColor, appearance, }: ResolvedThemeOptions) => Theme;
 //# sourceMappingURL=radix-ui-theme.d.ts.map

package/dist/themes/tokens.d.ts

@@ -30,6 +30,9 @@ export type Theme = {
     tableSelect: string;
     tableBorder: string;
     tableShadow: string;
+    tableGroupHeaderBackground: string;
+    tableGroupBackground: string;
+    tableGroupBorder: string;
     memoBackground: string;
     memoSelect: string;
     memoBorder: string;
@@ -52,6 +55,12 @@ export type Theme = {
     minimapViewportBorderHover: string;
     toastBackground: string;
     toastBorder: string;
+    toastSuccess: string;
+    toastError: string;
+    findReplaceError: string;
+    mapColumnsError: string;
+    schemaSqlWarningBackground: string;
+    schemaSqlWarningForeground: string;
     dragSelectBackground: string;
     dragSelectBorder: string;
     scrollbarTrack: string;

package/dist/utils/calcTable.d.ts

@@ -3,15 +3,32 @@ import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
 import { GeometrySource } from './draw-relationship/geometrySource';
 export declare function getWidthGeneration(): number;
+/**
+ * Reads the generation through the observable, so the render calling it runs
+ * again whenever any table's widths may have changed.
+ *
+ * @example
+ * trackTableWidths();
+ * const rect = getTableRect(state, member);
+ */
+export declare function trackTableWidths(): 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;
+/**
+ * The room a row keeps for the table's alternate key marks after its last
+ * cell: the longest mark, or none while the marks are hidden or the table has
+ * none, so only a table that shows one widens.
+ */
+export declare function calcAlternateKeyWidth(table: Table, state: RootState): number;
+export declare function calcTableWidths(table: Table, state: RootState): ColumnWidth;
 export type ColumnWidth = {
     width: number;
+    /** The alternate key marks' room after a row's last cell, 0 while none is drawn. */
+    alternateKey: number;
     name: number;
     comment: number;
     dataType: number;

package/dist/utils/clipboard.d.ts

@@ -1,2 +1,11 @@
 export declare function copyToClipboard(value: string): Promise<void>;
+/**
+ * Puts a png on the clipboard, writing at once inside the click with the image
+ * still to come: Safari refuses a write made after an await has spent the
+ * click. A host with no image clipboard refuses before the image is asked for.
+ *
+ * @example
+ * await copyImageToClipboard(() => createDocumentPng(options));
+ */
+export declare function copyImageToClipboard(createPng: () => Promise<Blob>): Promise<void>;
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/utils/collection/tableGroup.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, TableGroup } from '../../internal-types';
+export declare const createTableGroup: (value?: DeepPartial<TableGroup>) => TableGroup;
+//# sourceMappingURL=tableGroup.entity.d.ts.map

package/dist/utils/contrastText.d.ts

@@ -0,0 +1,21 @@
+/** The dark text a light background takes. */
+export declare const CONTRAST_BLACK = "#000000";
+/** The light text a dark background takes. */
+export declare const CONTRAST_WHITE = "#ffffff";
+/**
+ * A color's WCAG 2 relative luminance, from 0 for black to 1 for white, any
+ * alpha dropped; null for a color toOpaqueHex cannot read.
+ */
+export declare function relativeLuminance(color: string): number | null;
+/** The WCAG 2 contrast ratio of two relative luminances, from 1 to 21 in either order. */
+export declare function contrastRatio(a: number, b: number): number;
+/**
+ * White, unless black's WCAG 2 contrast ratio against the background beats
+ * white's by more than 4, so white is never under 3 and black never under 7.
+ * Null for a background toOpaqueHex cannot read, which keeps its colors.
+ *
+ * @example
+ * contrastTextColor('#3b82f6'); // '#ffffff'
+ */
+export declare function contrastTextColor(background: string): string | null;
+//# sourceMappingURL=contrastText.d.ts.map

package/dist/utils/deepMerge.d.ts

@@ -0,0 +1,8 @@
+import { DeepPartial } from '../internal-types';
+/**
+ * Merges source over a deep copy of target: objects key by key, arrays target
+ * first then source, every object and array in the result a fresh copy, and a
+ * key source holds as undefined overwriting target's.
+ */
+export declare function deepMerge<T extends object>(target: T, source: DeepPartial<T>): T;
+//# sourceMappingURL=deepMerge.d.ts.map

package/dist/utils/device-detect/index.d.ts

@@ -1,9 +1,5 @@
+/** macOS or iOS, where $mod is Cmd rather than Ctrl. */
 export declare const hasAppleDevice: () => boolean;
-export declare const hasMacintosh: () => boolean;
-export declare const hasIOS: () => boolean;
-export declare const hasAndroid: () => boolean;
+/** Windows, whose browsers all name it Win32 and where AltGr is Ctrl and Alt held. */
 export declare const hasWindows: () => boolean;
-export declare const hasChrome: () => boolean;
-export declare const hasSafari: () => boolean;
-export declare const hasFirefox: () => boolean;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/domEvent.d.ts

@@ -4,8 +4,26 @@ export declare function onStop(event: Event): void;
 export declare function onStopImmediate(event: Event): void;
 export declare function isMouseEvent(event: Event): event is MouseEvent;
 export declare function isTouchEvent(event: Event): event is TouchEvent;
+/**
+ * A press of the secondary mouse button alone. A macOS Ctrl+click reports the
+ * main button with ctrlKey and stays a main press, and a touch has no button.
+ */
+export declare function isSecondaryButtonPress(event: Event): boolean;
 /** A touch that puts a finger down beside another: a pinch, never a press of its own. */
 export declare function isMultiTouch(event: Event): boolean;
+/** A press that may carry what it lands on: a touch, or the main mouse button. */
+export declare function isMainButtonPress(event: Event): boolean;
+/** A press of the middle mouse button. */
+export declare function isMiddleButtonPress(event: Event): event is MouseEvent;
+/**
+ * Prevents the next middle lift wherever it lands, heard on the window ahead of
+ * the listener that ends a pan, since Chromium on Linux pastes the selection on
+ * a lift left unprevented. The returned remover drops it when no lift came.
+ *
+ * @example
+ * drag$.subscribe(handleMove).add(preventMiddleLift());
+ */
+export declare function preventMiddleLift(): () => void;
 /**
  * The editor root, which is where a pan has to take the selection off: the top
  * toolbar is a sibling of the scene that pans, so suppressing it any lower

package/dist/utils/dragSelect.d.ts

@@ -10,6 +10,8 @@ export type Rect = {
     w: number;
     h: number;
 };
+/** Whether the rect lies wholly inside the drag rect, its edges included. */
+export declare function isInsideDragRect(dragRect: Rect, rect: Rect): boolean;
 export declare function isOverlapPosition(dragRect: Rect, rect: Rect): boolean;
 export declare function getOverlapPosition(dragRect: Rect, rect: Rect): PointToPoint | null;
 export {};

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

@@ -29,4 +29,6 @@ export declare function bezierControls(from: Point, fromOutward: Point, to: Poin
  * the particle measurement and the route box all stay as they were.
  */
 export declare function bezierPolyline(from: Point, fromOutward: Point, to: Point, toOutward: Point, segments?: number): Point[];
+/** A cubic between two ends and its two control points, as that many chords. */
+export declare function cubicPolyline(from: Point, first: Point, second: Point, to: Point, segments: number): Point[];
 //# sourceMappingURL=bezier.d.ts.map

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

@@ -0,0 +1,9 @@
+import { Point } from '../../internal-types';
+/**
+ * How many chords a full-radius corner is flattened into. A chord strays from the
+ * arc by about a tenth of a pixel at the canvas's closest zoom, so the turn still
+ * reads as a curve there; a smaller corner takes one chord per pixel of radius.
+ */
+export declare const ROUTE_CORNER_SEGMENTS = 6;
+export declare function roundPolyline(points: Point[], radius: number): Point[];
+//# sourceMappingURL=corner.d.ts.map

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

@@ -92,24 +92,24 @@ export type ObjectPoint = {
     rb: Point;
 };
 export declare const isDirection: (value: string) => boolean;
-export declare const PATH_HEIGHT = 30;
-export declare const PATH_END_HEIGHT: number;
+/** The stub of a side's first slot: as short as the decoration lets it be. */
+export declare const PATH_END_HEIGHT = 24;
 /**
- * The cardinality decoration, measured outward from the anchor. The four are one
- * shape and cannot be set independently: the ring shares a centre with the
- * second tick and has to clear both the first tick and the guide line.
+ * The cardinality decoration, measured outward from the anchor, at the size other
+ * ERD tools draw it, clear down to the lowest zoom a table shows its rows. The
+ * ring shares the second tick's centre and clears the first and the guide.
  */
-export declare const LINE_SIZE = 7;
-export declare const LINE_HEIGHT = 11;
+export declare const LINE_SIZE = 6;
+export declare const LINE_HEIGHT = 9;
 export declare const CIRCLE_HEIGHT: number;
-export declare const CIRCLE_RADIUS = 6;
+export declare const CIRCLE_RADIUS = 5;
 export declare const PATH_LINE_HEIGHT: number;
 /**
  * How far apart the corridors of two relationships leaving the same table side
- * sit. Without it every path on a side turns at the same coordinate and their
- * first segments run down one another however far the anchors are spread.
+ * sit, one hit band at full zoom. Without it every path on a side turns at the
+ * same coordinate and their first segments run down one another.
  */
-export declare const STUB_STEP = 12;
+export declare const STUB_STEP = 8;
 /**
  * Corridors repeat every fourth slot. An unbounded stub walks a busy side's
  * paths ever further from the table; wrapping caps the longest one and still
@@ -118,10 +118,10 @@ export declare const STUB_STEP = 12;
 export declare const STUB_CYCLE = 4;
 /**
  * The shortest a stub may be clamped to. It has to clear PATH_LINE_HEIGHT or the
- * guide line is drawn backwards, but it is not derived from it: this is where
- * the routing was measured, and following the decorations down cost overlap.
+ * guide line is drawn backwards; just past it, two facing tables about 50px
+ * apart still join in one straight run, where a longer floor sends it around.
  */
-export declare const MIN_STUB = 36;
+export declare const MIN_STUB = 24;
 /**
  * The widest gap allowed between two anchors on the same table side. Capping the
  * pitch keeps a side's anchors together as a group, so a tall table's edge is
@@ -131,11 +131,11 @@ 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 cut to 45
- * degrees. A ceiling rather than a length: each cut is clamped to half the
- * shorter run it touches, so a short run keeps its right angle.
+ * The radius of the quarter circle a connector turns on at a corner. A ceiling
+ * rather than a length: each corner is clamped to half the shorter run it
+ * touches, so a short run keeps its right angle.
  */
-export declare const ROUTE_CHAMFER = 8;
+export declare const ROUTE_CORNER_RADIUS = 8;
 /** One end of a connector as the geometry reads it: which table, where on it, and which way out. */
 export type Anchor = Pick<RelationshipPoint, 'x' | 'y' | 'direction'> & {
     tableId: string;

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

@@ -0,0 +1,29 @@
+import { Point } from '../../internal-types';
+/**
+ * How far a loop's stubs run, as a multiple of how far its anchors sit from the
+ * table corner: the first loop's 20px gives the 24px every other stub starts at.
+ */
+export declare const LOOP_STUB_RATIO = 1.2;
+/**
+ * How far a loop's control points reach past its stubs, as the same multiple.
+ * With both scaled by the offset, a table's loops are one shape at nested sizes.
+ */
+export declare const LOOP_CURVATURE = 1.25;
+/**
+ * How many chords a loop is flattened into. Even a fourth loop's chords stray from
+ * the curve by under a quarter of a pixel at the canvas's closest zoom.
+ */
+export declare const LOOP_SEGMENTS = 48;
+/** How far a loop's anchors sit from the table corner, along either side. */
+export declare function loopOffset(start: Point, end: Point): number;
+/** The stub both ends of a loop run out on. */
+export declare function loopStub(start: Point, end: Point): number;
+/** How far past its anchors a loop is drawn at most, for the route box. */
+export declare function loopReach(start: Point, end: Point): number;
+/**
+ * A loop between its two turning points: a cubic leaving each straight out along
+ * its stub, so it meets both without a corner and turns round the table's corner
+ * clear of it.
+ */
+export declare function loopPolyline(from: Point, fromOutward: Point, to: Point, toOutward: Point, offset: number): Point[];
+//# sourceMappingURL=loop.d.ts.map

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

@@ -4,7 +4,7 @@ import { GeometrySource } from './geometrySource';
 export declare function getRelationshipPath(relationship: Relationship, source?: GeometrySource): 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
+ * router and the rounded corners made of it. The segments are contiguous by
  * construction, so each contributes its far end and nothing else.
  */
 export declare function toPathD(segments: Array<[Point, Point]>): string;

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

@@ -1,4 +1,11 @@
 import { RootState } from '../../engine/state';
 import { GeometrySource } from './geometrySource';
-export declare function relationshipSort(state: RootState, source?: GeometrySource): void;
+/**
+ * Places each relationship's anchors and slots on the source's channel, and on
+ * the document's routes every connector too, unless route is false, as in a
+ * store that draws nothing, where a route is never read.
+ */
+export declare function relationshipSort(state: RootState, source?: GeometrySource, { route }?: {
+    route?: boolean;
+}): void;
 //# sourceMappingURL=sort.d.ts.map

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

@@ -1,8 +1,9 @@
 import { Point } from '../../internal-types';
 import { Anchor, Anchors } from '.';
 /**
- * Slot zero keeps the historical PATH_END_HEIGHT, so a relationship that never
- * went through relationshipSort draws exactly as it did before.
+ * Slot zero runs at PATH_END_HEIGHT, the stub a relationship that never went
+ * through relationshipSort is drawn with, so a side's first connector keeps its
+ * stub through a sort.
  */
 export declare function stubFor(slot: number): number;
 /**
@@ -25,7 +26,7 @@ export type StubEnds = {
     startStub: number;
     endStub: number;
 };
-export declare function isHorizontal(direction: number): direction is 1 | 2;
+export declare function isHorizontal(direction: number): direction is 2 | 1;
 /** +1 when the anchor's outward normal points right or down. */
 export declare function outwardSign(direction: number): 1 | -1;
 /**

package/dist/utils/emitter.d.ts

@@ -1,8 +1,28 @@
 import { Action, AnyAction, DOMTemplateLiterals } from '@dineug/r-html';
 import { TablePlacement } from '../constants/tablePlacement';
+import { LocaleOption } from '../i18n/locales';
 import { ValuesType } from '../internal-types';
 import { ThemeOptions } from '../themes/radix-ui-theme';
 import { GeometrySource } from './draw-relationship/geometrySource';
+import { FindField } from './find-replace/findMatches';
+/** A search the palette hands Find and Replace: the query, and the kinds of text it searches in. */
+export type FindReplaceQuery = {
+    query: string;
+    fields: FindField[];
+};
+/**
+ * What Map Columns opens on: a relationship drawn between two tables and not
+ * made yet, or one the document holds whose columns it changes.
+ */
+export type MapColumnsOpening = {
+    mode: 'create';
+    startTableId: string;
+    endTableId: string;
+    relationshipType: number;
+} | {
+    mode: 'edit';
+    relationshipId: string;
+};
 declare const InternalActionType: {
     readonly openColorPicker: "openColorPicker";
     readonly closeColorPicker: "closeColorPicker";
@@ -11,10 +31,14 @@ declare const InternalActionType: {
     readonly dragendColumnAll: "dragendColumnAll";
     readonly copy: "copy";
     readonly paste: "paste";
-    readonly schemaGC: "schemaGC";
     readonly toggleSearch: "toggleSearch";
+    readonly openFindReplace: "openFindReplace";
+    readonly openExportImage: "openExportImage";
+    readonly openMapColumns: "openMapColumns";
     readonly openThemeBuilder: "openThemeBuilder";
     readonly setThemeOptions: "setThemeOptions";
+    readonly openLocalePicker: "openLocalePicker";
+    readonly setLocaleOption: "setLocaleOption";
     readonly mouseTrackerStart: "mouseTrackerStart";
     readonly mouseTrackerEnd: "mouseTrackerEnd";
     readonly openDiffViewer: "openDiffViewer";
@@ -33,6 +57,8 @@ type InternalActionMap = {
     [InternalActionType.openToast]: {
         message: DOMTemplateLiterals;
         close?: Promise<void>;
+        /** One toast per key: a toast opened under a key already up takes its place. */
+        key?: string;
     };
     [InternalActionType.openTableProperties]: {
         tableId: string;
@@ -44,10 +70,16 @@ type InternalActionMap = {
     [InternalActionType.paste]: {
         event: ClipboardEvent;
     };
-    [InternalActionType.schemaGC]: void;
     [InternalActionType.toggleSearch]: void;
+    [InternalActionType.openFindReplace]: FindReplaceQuery | void;
+    [InternalActionType.openExportImage]: void;
+    [InternalActionType.openMapColumns]: MapColumnsOpening;
     [InternalActionType.openThemeBuilder]: void;
     [InternalActionType.setThemeOptions]: Partial<ThemeOptions>;
+    [InternalActionType.openLocalePicker]: void;
+    [InternalActionType.setLocaleOption]: {
+        locale: LocaleOption;
+    };
     [InternalActionType.mouseTrackerStart]: void;
     [InternalActionType.mouseTrackerEnd]: void;
     [InternalActionType.openDiffViewer]: {
@@ -97,9 +129,13 @@ export declare const openToastAction: {
     (payload: {
         message: DOMTemplateLiterals;
         close?: Promise<void>;
+        /** One toast per key: a toast opened under a key already up takes its place. */
+        key?: string;
     }): AnyAction<{
         message: DOMTemplateLiterals;
         close?: Promise<void>;
+        /** One toast per key: a toast opened under a key already up takes its place. */
+        key?: string;
     }>;
     toString(): string;
     type: string;
@@ -136,16 +172,26 @@ export declare const pasteAction: {
     toString(): string;
     type: string;
 };
-export declare const schemaGCAction: {
+export declare const toggleSearchAction: {
     (payload: void): AnyAction<void>;
     toString(): string;
     type: string;
 };
-export declare const toggleSearchAction: {
+export declare const openFindReplaceAction: {
+    (payload: void | FindReplaceQuery): AnyAction<void | FindReplaceQuery>;
+    toString(): string;
+    type: string;
+};
+export declare const openExportImageAction: {
     (payload: void): AnyAction<void>;
     toString(): string;
     type: string;
 };
+export declare const openMapColumnsAction: {
+    (payload: MapColumnsOpening): AnyAction<MapColumnsOpening>;
+    toString(): string;
+    type: string;
+};
 export declare const openThemeBuilderAction: {
     (payload: void): AnyAction<void>;
     toString(): string;
@@ -156,6 +202,20 @@ export declare const setThemeOptionsAction: {
     toString(): string;
     type: string;
 };
+export declare const openLocalePickerAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const setLocaleOptionAction: {
+    (payload: {
+        locale: LocaleOption;
+    }): AnyAction<{
+        locale: LocaleOption;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const mouseTrackerStartAction: {
     (payload: void): AnyAction<void>;
     toString(): string;

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

@@ -1,4 +1,4 @@
-import { DocumentPngOptions } from '../../services/export-png';
+import { DocumentPngOptions, DocumentSvgOptions } from '../../services/export-png';
 type ExportOptions = {
     fileName: string;
 };
@@ -6,14 +6,24 @@ type ExportFileCallback = (blob: Blob, options: ExportOptions) => void;
 export declare function setExportFileCallback(callback: ExportFileCallback | null): void;
 export declare function exportJSON(json: string, name?: string): void;
 export declare function exportSchemaSQL(sql: string, name?: string): void;
+/** The Code Generator's text, named as the other exports are, with its language's extension. */
+export declare function exportCode(code: string, extension: string, name?: string): void;
 /**
- * Writes the whole document out as an image, at the zoom the author is reading
- * it at. The scene is rendered again off screen rather than captured, so the
- * file holds the whole document however far it was scrolled away from.
+ * Writes the whole document out as an image, at 100% whatever zoom the author
+ * is reading it at. The scene is rendered again off screen rather than captured,
+ * so the file holds the whole document however far it was scrolled away from.
  *
  * @example
- * exportPNG({ doc: toJson(store.state), theme, toWidth, zoomLevel }, databaseName);
+ * exportPNG({ doc: toJson(store.state), theme, toWidth }, databaseName);
  */
 export declare function exportPNG(options: DocumentPngOptions, name?: string): Promise<void>;
+/**
+ * Writes the whole document out as an svg, at 100% and with no scale, drawn
+ * again off screen the way the png is.
+ *
+ * @example
+ * exportSVG({ doc: toJson(store.state), theme, toWidth }, databaseName);
+ */
+export declare function exportSVG(options: DocumentSvgOptions, name?: string): Promise<void>;
 export {};
 //# sourceMappingURL=exportFile.d.ts.map

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

@@ -1,16 +1,20 @@
 import { AppContext } from '../../components/appContext';
+/** Whether an import takes the document's place or joins it below the diagram. */
+export type ImportMode = 'replace' | 'append';
 type ImportOptions = {
     type: 'json' | 'sql' | 'graphql' | 'dbml' | 'aml';
     op: 'set' | 'diff';
     accept: string;
+    /** Named only for an append, so a host that knows no mode replaces as before. */
+    mode?: ImportMode;
 };
 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 importJSON(app: AppContext, mode?: ImportMode): void;
+export declare function importSchemaSQL(app: AppContext, mode?: ImportMode): void;
+export declare function importGraphQL(app: AppContext, mode?: ImportMode): void;
+export declare function importDBML(app: AppContext, mode?: ImportMode): void;
+export declare function importAML(app: AppContext, mode?: ImportMode): void;
 export declare function importDiffJSON({ emitter }: AppContext): void;
 export {};
 //# sourceMappingURL=importFile.d.ts.map

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

@@ -0,0 +1,45 @@
+import { AppContext } from '../../components/appContext';
+import { SchemaImportType } from '../../engine/modules/editor/generator.actions';
+/**
+ * Replaces the document with an import whose tables stand in the grid, in
+ * one dispatch, as the element's setters always did.
+ *
+ * @example
+ * importSchema(app, 'sql', value);
+ */
+export declare function importSchema({ store }: AppContext, type: SchemaImportType, value: string): void;
+/**
+ * Replaces the document with an import Flow placed first, in one dispatch:
+ * one undo puts the previous document back and no grid shows in between. A
+ * load or another placed replace meanwhile supersedes it and nothing lands.
+ *
+ * @example
+ * await importSchemaPlaced(app, 'sql', value);
+ */
+export declare function importSchemaPlaced(app: AppContext, type: SchemaImportType, value: string): Promise<void>;
+/**
+ * Adds an import to the document below the diagram, its tables in the grid,
+ * in one dispatch, leaving every table and setting already there as it is.
+ *
+ * @example
+ * appendSchema(app, 'sql', value);
+ */
+export declare function appendSchema(app: AppContext, type: SchemaImportType, value: string): void;
+/**
+ * Adds an .erd.json document to this one below the diagram, its tables and
+ * memos standing apart as the file has them, its settings left out.
+ *
+ * @example
+ * appendSchemaJSON(app, value);
+ */
+export declare function appendSchemaJSON(app: AppContext, value: string): void;
+/**
+ * Adds an import Flow placed first below the diagram, in one dispatch, after
+ * every placed import started before it. The diagram is read as it lands, so a
+ * table moved meanwhile is cleared; a load or a later placed replace drops it.
+ *
+ * @example
+ * await appendSchemaPlaced(app, 'sql', value);
+ */
+export declare function appendSchemaPlaced(app: AppContext, type: SchemaImportType, value: string): Promise<void>;
+//# sourceMappingURL=importSchema.d.ts.map