@dineug/erd-editor 3.3.1 → 3.5.0

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 function lastCursorFocus(input: HTMLInputElement | HTMLTextAreaElement): 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/globalEventObservable.d.ts

@@ -1,16 +1,17 @@
-export declare const keyup$: import('rxjs').Observable<KeyboardEvent>;
-export declare const mousedown$: import('rxjs').Observable<MouseEvent>;
-export declare const mousemove$: import('rxjs').Observable<MouseEvent>;
-export declare const mouseup$: import('rxjs').Observable<MouseEvent>;
-export declare const touchstart$: import('rxjs').Observable<TouchEvent>;
-export declare const touchmove$: import('rxjs').Observable<TouchEvent>;
-export declare const touchend$: import('rxjs').Observable<TouchEvent>;
-export declare const animationFrames$: import('rxjs').Observable<{
+import { Observable } from 'rxjs';
+export declare const keyup$: Observable<KeyboardEvent>;
+export declare const mousedown$: Observable<MouseEvent>;
+export declare const mousemove$: Observable<MouseEvent>;
+export declare const mouseup$: Observable<MouseEvent>;
+export declare const touchstart$: Observable<TouchEvent>;
+export declare const touchmove$: Observable<TouchEvent>;
+export declare const touchend$: Observable<TouchEvent>;
+export declare const animationFrames$: Observable<{
     timestamp: number;
     elapsed: number;
 }>;
-export declare const moveStart$: import('rxjs').Observable<MouseEvent | TouchEvent>;
-export declare const moveEnd$: import('rxjs').Observable<MouseEvent | TouchEvent>;
+export declare const moveStart$: Observable<MouseEvent | TouchEvent>;
+export declare const moveEnd$: Observable<MouseEvent | TouchEvent>;
 export type DragMove = {
     movementX: number;
     movementY: number;
@@ -18,7 +19,7 @@ export type DragMove = {
     y: number;
     event: MouseEvent | TouchEvent;
 };
-export declare const move$: import('rxjs').Observable<{
+export declare const move$: Observable<{
     event: MouseEvent;
     movementX: number;
     movementY: number;
@@ -31,7 +32,7 @@ export declare const move$: import('rxjs').Observable<{
     x: number;
     y: number;
 }>;
-export declare const drag$: import('rxjs').Observable<{
+export declare const drag$: Observable<{
     event: MouseEvent;
     movementX: number;
     movementY: number;

package/dist/utils/icon.d.ts

@@ -1 +1,9 @@
-export declare function getRelationshipIcon(relationshipType: number): string | null;
+import { IconNode } from 'lucide';
+/**
+ * An icon node as an svg data uri, which is what css cursor takes. The glyph
+ * is drawn twice, the halo under the ink, with the caps and joins Icon.tsx puts
+ * on its svg so the cursor matches the menu item.
+ */
+export declare function toCursorImage(node: IconNode, isDarkMode: boolean): string;
+/** The draw-relationship cursor for a relationship type, or null for a type with no glyph. */
+export declare function getRelationshipIcon(relationshipType: number, isDarkMode: boolean): string | null;

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

@@ -28,9 +28,15 @@ 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[];
 export declare function isMod(event: MouseEvent | TouchEvent | KeyboardEvent): boolean;
+/**
+ * Whether the press still belongs to an IME composition. The browser finishes
+ * the composition on its own, so a binding that fired here would spend a key
+ * the text editor was owed and leave a half-formed syllable behind.
+ */
+export declare function isComposing(event: KeyboardEvent): boolean;
 export declare function simpleShortcutToString(shortcut?: string): string;

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,12 @@
+import { AMLModel } from './types';
+/**
+ * enumValues carries the inline members, which never reach model.types. Both
+ * entry points take them as a trailing optional argument, 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,23 @@
+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 its line's depth. A
+ * newline token opens the line that follows and holds that line's depth, and a
+ * synthetic one starts the stream so the first line reads like every other.
+ */
+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,78 @@
+/**
+ * tokenizer.ts and parser.ts own every AML syntax concern, resolving
+ * indentation, quoting and the constraint grammar into the flat fields below,
+ * so convert.ts never sees a token and a nested attribute arrives dotted.
+ */
+export type AMLNamespace = {
+    database: string;
+    catalog: string;
+    schema: string;
+};
+/** A dash on either end reads as 1, an angle bracket 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[];

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

@@ -0,0 +1,62 @@
+/**
+ * tokenizer.ts and parser.ts own every DBML syntax concern -- settings are
+ * resolved into the flat fields below, so convert.ts never sees a token.
+ */
+export type DBMLEndpoint = {
+    schemaName: string;
+    tableName: string;
+    columnNames: string[];
+};
+export type DBMLInlineRef = {
+    /** -, <, > or <>, with the ? optionality markers dropped. */
+    operator: string;
+    target: DBMLEndpoint;
+};
+export type DBMLColumn = {
+    name: string;
+    comment: string;
+    /** Holds the argument list and any array suffix; never the schema. */
+    typeName: string;
+    typeSchemaName: string;
+    primaryKey: boolean;
+    unique: boolean;
+    notNull: boolean;
+    autoIncrement: boolean;
+    default: string;
+    inlineRefs: DBMLInlineRef[];
+};
+export type DBMLIndex = {
+    name: string;
+    unique: boolean;
+    /** [pk], which is DBML's only composite primary key spelling. */
+    primaryKey: boolean;
+    /** Expression columns are dropped, so these are column names only. */
+    columnNames: string[];
+};
+export type DBMLTable = {
+    schemaName: string;
+    name: string;
+    alias: string;
+    comment: string;
+    columns: DBMLColumn[];
+    indexes: DBMLIndex[];
+};
+export type DBMLRef = {
+    operator: string;
+    left: DBMLEndpoint;
+    right: DBMLEndpoint;
+};
+export type DBMLModel = {
+    tables: DBMLTable[];
+    refs: DBMLRef[];
+    /** Keyed by the qualified name, so s.status and status stay apart. */
+    enums: Record<string, string[]>;
+    skipped: string[];
+};
+export type DBMLParseResult = {
+    ok: true;
+    model: DBMLModel;
+} | {
+    ok: false;
+    message: string;
+};

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

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

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

@@ -0,0 +1,7 @@
+import { GraphQLModel } from './types';
+export declare function resolveDataType(named: string, database: number, model: GraphQLModel): 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(named: string, model: GraphQLModel, database?: number): string;

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

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

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

@@ -0,0 +1,2 @@
+import { GraphQLParseResult } from './types';
+export declare function parseGraphQLModel(sdl: string): GraphQLParseResult;

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

@@ -0,0 +1,58 @@
+/**
+ * parser.ts owns every graphql AST concern -- directives are resolved into
+ * the flat fields below, so convert.ts never imports from graphql.
+ */
+export type GraphQLTypeRef = {
+    named: string;
+    /** The outermost wrapper is NonNull -- the column-level NOT NULL signal. */
+    nonNull: boolean;
+    isList: boolean;
+    /** The ! inside [T!] -- a cardinality signal, never a column one. */
+    itemNonNull: boolean;
+};
+export type GraphQLField = {
+    /** Already rewritten by @map / @column(name:) when either is present. */
+    name: string;
+    comment: string;
+    typeRef: GraphQLTypeRef;
+    primaryKey: boolean;
+    unique: boolean;
+    autoIncrement: boolean;
+    default: string;
+    /** @db.* or @column(dataType:); wins over the scalar lookup when set. */
+    dataType: string;
+    relationName: string;
+    /** Columns on this type. */
+    relationFields: string[];
+    /** Columns on the target type. */
+    relationReferences: string[];
+    /** Resolver fields keep their arguments; the target type decides the rest. */
+    hasArguments: boolean;
+};
+export type GraphQLIndex = {
+    name: string;
+    unique: boolean;
+    fieldNames: string[];
+};
+export type GraphQLTable = {
+    name: string;
+    comment: string;
+    fields: GraphQLField[];
+    indexes: GraphQLIndex[];
+};
+export type GraphQLModel = {
+    tables: GraphQLTable[];
+    enums: Record<string, string[]>;
+    /** scalar X declarations, so an unknown name can be told from a typo. */
+    customScalars: string[];
+    unions: Record<string, string[]>;
+    /** Pruned type names, so a field pointing at one is dropped rather than read. */
+    skipped: string[];
+};
+export type GraphQLParseResult = {
+    ok: true;
+    model: GraphQLModel;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/utils/schema-sql/Databricks.d.ts

@@ -0,0 +1,5 @@
+import { RootState } from '../../engine/state';
+import { FormatIndexOptions, FormatTableOptions } from './utils';
+export declare function createSchema(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function formatIndex({ collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;

package/dist/utils/schema-sql/Snowflake.d.ts

@@ -0,0 +1,5 @@
+import { RootState } from '../../engine/state';
+import { FormatIndexOptions, FormatTableOptions } from './utils';
+export declare function createSchema(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function formatIndex({ collections, settings: { bracketType } }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;

package/dist/utils/sharedColor.d.ts

@@ -0,0 +1,2 @@
+export declare const SharedColors: ReadonlyArray<string>;
+export declare function toSharedColor(id: string): string;

package/dist/utils/table-clipboard/copy.d.ts

@@ -1,3 +1,10 @@
 import { RootState } from '../../engine/state';
+import { Settings } from '../../internal-types';
+import { ClipboardPayload } from '.';
 export declare function tableCopyToText(state: RootState): string;
 export declare function tableCopyToHtml(state: RootState): string;
+export declare function entitiesCopyToPayload({ editor: { selectedMap }, collections, }: RootState): ClipboardPayload | null;
+export declare function columnsCopyToPayload({ editor: { focusTable }, collections, }: RootState): ClipboardPayload | null;
+export declare function entitiesToTsv(payload: ClipboardPayload, settings: Settings): string;
+export declare function entitiesToHtmlTable(payload: ClipboardPayload, settings: Settings): string;
+export declare function payloadToHtml(payload: ClipboardPayload, tableHtml: string): string;

package/dist/utils/table-clipboard/index.d.ts

@@ -1,4 +1,6 @@
 import { ValuesType } from '../../internal-types';
+export * from './payload';
+export * from './placement';
 export type Cell = [CellType | '', string];
 export type Row = Cell[];
 export declare const CellType: {

package/dist/utils/table-clipboard/paste.d.ts

@@ -1,4 +1,7 @@
 import { RootState } from '../../engine/state';
 import { Column } from '../../internal-types';
+import { ClipboardPayload, ParseResult } from './payload';
 export declare function tablePasteFromTextToColumns({ settings: { show, columnOrder } }: RootState, text: string): Column[];
 export declare function tablePasteFromHtmlToColumns({ settings: { show, columnOrder } }: RootState, html: string): Column[];
+export declare function readClipboardPayload(dataTransfer: DataTransfer): ParseResult;
+export declare function payloadToColumns({ columns }: ClipboardPayload): Column[];

package/dist/utils/table-clipboard/payload.d.ts

@@ -0,0 +1,83 @@
+import { ValuesType } from '../../internal-types';
+export declare const CLIPBOARD_MIME = "application/x-erd-editor";
+export declare const CLIPBOARD_FORMAT = "erd-editor-clipboard";
+export declare const CLIPBOARD_VERSION = 1;
+export declare const CLIPBOARD_HTML_ATTR = "data-erd-editor";
+export declare const CLIPBOARD_HTML_TRUNCATED_ATTR = "data-erd-editor-truncated";
+export declare const HTML_PAYLOAD_MAX_BYTES = 1000000;
+export declare const PayloadKind: {
+    readonly tables: "tables";
+    readonly columns: "columns";
+};
+export type PayloadKind = ValuesType<typeof PayloadKind>;
+export type ClipboardTable = {
+    sourceId: string;
+    name: string;
+    comment: string;
+    columnIds: string[];
+    ui: {
+        x: number;
+        y: number;
+        zIndex: number;
+        widthName: number;
+        widthComment: number;
+        color: string;
+    };
+};
+export type ClipboardColumn = {
+    sourceId: string;
+    tableId: string;
+    name: string;
+    comment: string;
+    dataType: string;
+    default: string;
+    options: number;
+    ui: {
+        keys: number;
+        widthName: number;
+        widthComment: number;
+        widthDataType: number;
+        widthDefault: number;
+    };
+};
+export type ClipboardMemo = {
+    sourceId: string;
+    value: string;
+    ui: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zIndex: number;
+        color: string;
+    };
+};
+export type ClipboardPayload = {
+    format: typeof CLIPBOARD_FORMAT;
+    version: number;
+    copyId: string;
+    kind: PayloadKind;
+    tables: ClipboardTable[];
+    columns: ClipboardColumn[];
+    memos: ClipboardMemo[];
+};
+export type ParseResult = {
+    status: 'ok';
+    payload: ClipboardPayload;
+} | {
+    status: 'foreign';
+} | {
+    status: 'unsupported';
+    version: number;
+};
+type CreatePayloadConfig = {
+    kind: PayloadKind;
+    copyId?: string;
+    tables?: ClipboardTable[];
+    columns?: ClipboardColumn[];
+    memos?: ClipboardMemo[];
+};
+export declare function createPayload({ kind, copyId, tables, columns, memos, }: CreatePayloadConfig): ClipboardPayload;
+export declare function parsePayload(json: string): ParseResult;
+export declare function migratePayload(payload: ClipboardPayload): ClipboardPayload;
+export {};

package/dist/utils/table-clipboard/placement.d.ts

@@ -0,0 +1,30 @@
+import { Memo, Point, Settings, Table } from '../../internal-types';
+export type PlacementEntity = {
+    sourceId: string;
+    ui: {
+        x: number;
+        y: number;
+        zIndex?: number;
+    };
+};
+export type PlacementSource = {
+    ui: {
+        x: number;
+        y: number;
+    };
+};
+export type PlacementPoint = {
+    x: number;
+    y: number;
+    zIndex: number;
+};
+export type ResolvePlacementConfig = {
+    entities: PlacementEntity[];
+    offset: Point;
+    escapeCollision: boolean;
+    settings: Settings;
+    tables: Table[];
+    memos: Memo[];
+    findSource: (sourceId: string) => PlacementSource | undefined | null;
+};
+export declare function resolvePlacement({ entities, offset, escapeCollision, settings, tables, memos, findSource, }: ResolvePlacementConfig): Map<string, PlacementPoint>;

package/dist/utils/validation.d.ts

@@ -14,3 +14,4 @@ export declare const hasCanvasType: (value: string) => boolean;
 export declare function textInRange(width: number): number;
 export declare function toSafeString(value: any): string;
 export declare function isHighLevelTable(zoomLevel: number): boolean;
+export declare function isEditableTarget(target: EventTarget | null): boolean;