@dineug/erd-editor 3.0.0

package/dist/themes/textColor.d.ts

@@ -0,0 +1,2 @@
+import Color from 'color';
+export declare const toTextColor: (color: Color) => "black" | "white";

package/dist/themes/tokens.d.ts

@@ -0,0 +1,63 @@
+export type Theme = {
+    grayColor1: string;
+    grayColor2: string;
+    grayColor3: string;
+    grayColor4: string;
+    grayColor5: string;
+    grayColor6: string;
+    grayColor7: string;
+    grayColor8: string;
+    grayColor9: string;
+    grayColor10: string;
+    grayColor11: string;
+    grayColor12: string;
+    accentColor1: string;
+    accentColor2: string;
+    accentColor3: string;
+    accentColor4: string;
+    accentColor5: string;
+    accentColor6: string;
+    accentColor7: string;
+    accentColor8: string;
+    accentColor9: string;
+    accentColor10: string;
+    accentColor11: string;
+    accentColor12: string;
+    canvasBackground: string;
+    canvasBoundaryBackground: string;
+    tableBackground: string;
+    tableSelect: string;
+    tableBorder: string;
+    memoBackground: string;
+    memoSelect: string;
+    memoBorder: string;
+    columnSelect: string;
+    columnHover: string;
+    relationshipHover: string;
+    toolbarBackground: string;
+    contextMenuBackground: string;
+    contextMenuSelect: string;
+    contextMenuHover: string;
+    contextMenuBorder: string;
+    minimapBorder: string;
+    minimapShadow: string;
+    minimapViewportBorder: string;
+    minimapViewportBorderHover: string;
+    toastBackground: string;
+    toastBorder: string;
+    dargSelectBackground: string;
+    dargSelectBorder: string;
+    scrollbarTrack: string;
+    scrollbarThumb: string;
+    scrollbarThumbHover: string;
+    foreground: string;
+    active: string;
+    placeholder: string;
+    focus: string;
+    inputActive: string;
+    keyPK: string;
+    keyFK: string;
+    keyPFK: string;
+};
+export declare const ThemeTokens: ReadonlyArray<keyof Theme>;
+export declare const themeToTokensString: (theme: Theme) => string;

package/dist/utils/attribute.d.ts

@@ -0,0 +1 @@
+export declare function restAttrs(value: Record<string, any>): Record<string, any>;

package/dist/utils/bit.d.ts

@@ -0,0 +1 @@
+export declare function bHas(bit: number, value: number): boolean;

package/dist/utils/calcMemo.d.ts

@@ -0,0 +1,3 @@
+import { Memo } from "../internal-types";
+export declare function calcMemoWidth(memo: Memo): number;
+export declare function calcMemoHeight(memo: Memo): number;

package/dist/utils/calcTable.d.ts

@@ -0,0 +1,16 @@
+import { EngineContext } from "../engine/context";
+import { RootState } from "../engine/state";
+import { Table } from "../internal-types";
+export declare function calcTableWidths(table: Table, { settings: { show, maxWidthComment }, collections }: RootState): ColumnWidth;
+export type ColumnWidth = {
+    width: number;
+    name: number;
+    comment: number;
+    dataType: number;
+    default: number;
+    notNull: number;
+    autoIncrement: number;
+    unique: number;
+};
+export declare function calcTableHeight(table: Table): number;
+export declare function recalculateTableWidth({ doc: { tableIds }, collections }: RootState, { toWidth }: EngineContext): void;

package/dist/utils/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyToClipboard(value: string): Promise<void>;

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

@@ -0,0 +1,2 @@
+import { DeepPartial, Index } from "../../internal-types";
+export declare const createIndex: (value?: DeepPartial<Index>) => Index;

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

@@ -0,0 +1,2 @@
+import { DeepPartial, IndexColumn } from "../../internal-types";
+export declare const createIndexColumn: (value?: DeepPartial<IndexColumn>) => IndexColumn;

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

@@ -0,0 +1,2 @@
+import { DeepPartial, Memo } from "../../internal-types";
+export declare const createMemo: (value?: DeepPartial<Memo>) => Memo;

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

@@ -0,0 +1,2 @@
+import { DeepPartial, Relationship } from "../../internal-types";
+export declare const createRelationship: (value?: DeepPartial<Relationship>) => Relationship;

package/dist/utils/collection/sequence.d.ts

@@ -0,0 +1 @@
+export declare function addAndSort(ids: string[], seqIds: string[], id: string): void;

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

@@ -0,0 +1,2 @@
+import { DeepPartial, Table } from "../../internal-types";
+export declare const createTable: (value?: DeepPartial<Table>) => Table;

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

@@ -0,0 +1,2 @@
+import { Column, DeepPartial } from "../../internal-types";
+export declare const createColumn: (value?: DeepPartial<Column>) => Column;

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

@@ -0,0 +1,7 @@
+export declare const isAndroid: boolean;
+export declare const isWindows: boolean;
+export declare const isMacOs: boolean;
+export declare const isIOS: boolean;
+export declare const isChrome: boolean;
+export declare const isFirefox: boolean;
+export declare const isSafari: boolean;

package/dist/utils/domEvent.d.ts

@@ -0,0 +1,6 @@
+export declare function onNumberOnly(event: InputEvent): void;
+export declare function onPrevent(event: Event): void;
+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;

package/dist/utils/dragSelect.d.ts

@@ -0,0 +1,23 @@
+import { Point } from "../internal-types";
+type PointToPoint = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function isOverlapPosition(dragRect: Rect, rect: Rect): boolean;
+export declare function getOverlapPosition(dragRect: Rect, rect: Rect): PointToPoint | null;
+export declare function getZoomViewport(width: number, height: number, zoomLevel: number): Rect;
+export declare const getAbsolutePosition: (overlapPosition: PointToPoint, zoomViewport: Rect, zoomLevel: number) => PointToPoint;
+export declare function getAbsoluteZoomPoint({ x, y }: Point, width: number, height: number, zoomLevel: number): {
+    x: number;
+    y: number;
+};
+export declare function getAbsolutePoint(point: Point, width: number, height: number, zoomLevel: number): Point;
+export {};

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

@@ -0,0 +1,6 @@
+import { RootState } from "../../engine/state";
+import { Point, Table } from "../../internal-types";
+import { ObjectPoint } from "./";
+export declare function tableToObjectPoint(state: RootState, table: Table): ObjectPoint;
+export declare function euclideanDistance(a: Point, b: Point): number;
+export declare function manhattanDistance(a: Point, b: Point): number;

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

@@ -0,0 +1,4 @@
+import { DrawRelationship } from "../../engine/modules/editor/state";
+import { RootState } from "../../engine/state";
+import { DrawPath } from "./";
+export declare function getDraw(state: RootState, draw: DrawRelationship): DrawPath;

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

@@ -0,0 +1,108 @@
+import { Point, RelationshipPoint, ValuesType } from "../../internal-types";
+export declare const DirectionName: {
+    readonly left: "left";
+    readonly right: "right";
+    readonly top: "top";
+    readonly bottom: "bottom";
+};
+export type DirectionName = ValuesType<typeof DirectionName>;
+export declare const DirectionNameList: ReadonlyArray<string>;
+export type PointToPoint = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export type DrawPathLine = {
+    start: PointToPoint;
+};
+export type DrawLine = {
+    start: {
+        base: PointToPoint;
+        base2: PointToPoint;
+        center: PointToPoint;
+        center2: PointToPoint;
+    };
+};
+export type PathPoint = {
+    M: Point;
+    L: Point;
+    Q: Point;
+    d(): Array<[Point, Point]>;
+};
+export type Path = {
+    M: Point;
+    L: Point;
+    Q: Point;
+    d(): string;
+};
+export type DrawPath = {
+    path: {
+        path: Path;
+        line: DrawPathLine;
+    };
+    line: DrawLine;
+};
+export type PathLine = {
+    start: PointToPoint;
+    end: PointToPoint;
+};
+export type Line = {
+    start: {
+        base: PointToPoint;
+        base2: PointToPoint;
+        center: PointToPoint;
+        center2: PointToPoint;
+    };
+    end: {
+        base: PointToPoint;
+        base2: PointToPoint;
+        left: PointToPoint;
+        center: PointToPoint;
+        center2: PointToPoint;
+        right: PointToPoint;
+    };
+};
+export type Circle = {
+    cx: number;
+    cy: number;
+};
+export type RelationshipPath = {
+    path: {
+        path: PathPoint;
+        line: PathLine;
+    };
+    line: {
+        line: Line;
+        circle: Circle;
+        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;
+    top: Point;
+    bottom: Point;
+    left: Point;
+    right: Point;
+    lt: Point;
+    rt: Point;
+    lb: Point;
+    rb: Point;
+};
+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;

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

@@ -0,0 +1,3 @@
+import { Relationship } from "../../internal-types";
+import { RelationshipPath } from "./";
+export declare function getRelationshipPath(relationship: Relationship): RelationshipPath;

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

@@ -0,0 +1,2 @@
+import { RootState } from "../../engine/state";
+export declare function relationshipSort(state: RootState): void;

package/dist/utils/emitter.d.ts

@@ -0,0 +1,141 @@
+import { Action, AnyAction, DOMTemplateLiterals } from '@dineug/r-html';
+import { ValuesType } from "../internal-types";
+import { ThemeOptions } from "../themes/radix-ui-theme";
+declare const InternalActionType: {
+    readonly openColorPicker: "openColorPicker";
+    readonly closeColorPicker: "closeColorPicker";
+    readonly openToast: "openToast";
+    readonly loadShikiService: "loadShikiService";
+    readonly openTableProperties: "openTableProperties";
+    readonly dragendColumnAll: "dragendColumnAll";
+    readonly copy: "copy";
+    readonly paste: "paste";
+    readonly schemaGC: "schemaGC";
+    readonly toggleSearch: "toggleSearch";
+    readonly openThemeBuilder: "openThemeBuilder";
+    readonly setThemeOptions: "setThemeOptions";
+};
+type InternalActionType = ValuesType<typeof InternalActionType>;
+type InternalActionMap = {
+    [InternalActionType.openColorPicker]: {
+        x: number;
+        y: number;
+        color: string;
+    };
+    [InternalActionType.closeColorPicker]: void;
+    [InternalActionType.openToast]: {
+        message: DOMTemplateLiterals;
+        close?: Promise<void>;
+    };
+    [InternalActionType.loadShikiService]: void;
+    [InternalActionType.openTableProperties]: {
+        tableId: string;
+    };
+    [InternalActionType.dragendColumnAll]: void;
+    [InternalActionType.copy]: {
+        event: ClipboardEvent;
+    };
+    [InternalActionType.paste]: {
+        event: ClipboardEvent;
+    };
+    [InternalActionType.schemaGC]: void;
+    [InternalActionType.toggleSearch]: void;
+    [InternalActionType.openThemeBuilder]: void;
+    [InternalActionType.setThemeOptions]: Partial<ThemeOptions>;
+};
+type Reducer<K extends keyof M, M> = (action: Action<K, M>) => void;
+type ReducerRecord<K extends keyof M, M> = {
+    [P in K]: Reducer<P, M>;
+};
+export declare class Emitter<M extends InternalActionMap = InternalActionMap> {
+    #private;
+    on(reducers: Partial<ReducerRecord<keyof M, M>>): () => void;
+    emit(action: AnyAction): void;
+}
+export declare const openColorPickerAction: {
+    (payload: {
+        x: number;
+        y: number;
+        color: string;
+    }): AnyAction<{
+        x: number;
+        y: number;
+        color: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const closeColorPickerAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const openToastAction: {
+    (payload: {
+        message: DOMTemplateLiterals;
+        close?: Promise<void> | undefined;
+    }): AnyAction<{
+        message: DOMTemplateLiterals;
+        close?: Promise<void> | undefined;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const loadShikiServiceAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const openTablePropertiesAction: {
+    (payload: {
+        tableId: string;
+    }): AnyAction<{
+        tableId: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const dragendColumnAllAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const copyAction: {
+    (payload: {
+        event: ClipboardEvent;
+    }): AnyAction<{
+        event: ClipboardEvent;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const pasteAction: {
+    (payload: {
+        event: ClipboardEvent;
+    }): AnyAction<{
+        event: ClipboardEvent;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const schemaGCAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const toggleSearchAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const openThemeBuilderAction: {
+    (payload: void): AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const setThemeOptionsAction: {
+    (payload: Partial<ThemeOptions>): AnyAction<Partial<ThemeOptions>>;
+    toString(): string;
+    type: string;
+};
+export {};

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

@@ -0,0 +1,9 @@
+type ExportOptions = {
+    fileName: string;
+};
+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;
+export declare function exportPNG(root: HTMLElement, name?: string): void;
+export {};

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

@@ -0,0 +1,10 @@
+import { AppContext } from "../../components/appContext";
+type ImportOptions = {
+    type: 'json' | 'sql';
+    accept: string;
+};
+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 {};

package/dist/utils/flipAnimation.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from '@dineug/r-html';
+export declare class FlipAnimation {
+    private flipSnapshots;
+    private root;
+    private selector;
+    private animationName;
+    constructor(root: Ref<HTMLElement | null>, selector: string, animationName: string);
+    snapshot(): void;
+    play(): void;
+}

package/dist/utils/focus.d.ts

@@ -0,0 +1,5 @@
+import { FocusTable, FocusType } from "../engine/modules/editor/state";
+export declare function isFocus(focusTable: FocusTable | 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;

package/dist/utils/generator-code/csharp.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/graphql.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/index.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from "../../engine/state";
+import { Table } from "../../internal-types";
+export declare function createGeneratorCode(state: RootState): string;
+export declare function createGeneratorCodeTable(state: RootState, table: Table): string;

package/dist/utils/generator-code/java.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/jpa.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/kotlin.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/scala.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/typescript.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/utils.d.ts

@@ -0,0 +1,19 @@
+import { DataTypeHint, PrimitiveType } from "../../constants/sql/dataType";
+import { Column, Table } from "../../internal-types";
+export interface FormatTableOptions {
+    buffer: string[];
+    table: Table;
+}
+export interface FormatColumnOptions {
+    buffer: string[];
+    column: Column;
+}
+export interface FormatRelationOptions {
+    buffer: string[];
+    table: Table;
+}
+export declare const hasOneRelationship: (value: number) => boolean;
+export declare const hasNRelationship: (value: number) => boolean;
+export declare function getPrimitiveType(dataType: string, database: number): PrimitiveType;
+export declare function getDataTypeHints(database: number): DataTypeHint[];
+export declare function getNameCase(name: string, nameCase: number): string;

package/dist/utils/globalEmitter.d.ts

@@ -0,0 +1,28 @@
+import { Emitter } from "./emitter";
+export declare const globalEmitter: Emitter<{
+    openColorPicker: {
+        x: number;
+        y: number;
+        color: string;
+    };
+    closeColorPicker: void;
+    openToast: {
+        message: import("@dineug/r-html").DOMTemplateLiterals;
+        close?: Promise<void> | undefined;
+    };
+    loadShikiService: void;
+    openTableProperties: {
+        tableId: string;
+    };
+    dragendColumnAll: void;
+    copy: {
+        event: ClipboardEvent;
+    };
+    paste: {
+        event: ClipboardEvent;
+    };
+    schemaGC: void;
+    toggleSearch: void;
+    openThemeBuilder: void;
+    setThemeOptions: Partial<import("../themes/radix-ui-theme").ThemeOptions>;
+}>;

package/dist/utils/globalEventObservable.d.ts

@@ -0,0 +1,41 @@
+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 moveStart$: import("rxjs").Observable<MouseEvent | TouchEvent>;
+export declare const moveEnd$: import("rxjs").Observable<MouseEvent | TouchEvent>;
+export type DragMove = {
+    movementX: number;
+    movementY: number;
+    x: number;
+    y: number;
+    event: MouseEvent | TouchEvent;
+};
+export declare const move$: import("rxjs").Observable<{
+    event: MouseEvent;
+    movementX: number;
+    movementY: number;
+    x: number;
+    y: number;
+} | {
+    event: TouchEvent;
+    movementX: number;
+    movementY: number;
+    x: number;
+    y: number;
+}>;
+export declare const drag$: import("rxjs").Observable<{
+    event: MouseEvent;
+    movementX: number;
+    movementY: number;
+    x: number;
+    y: number;
+} | {
+    event: TouchEvent;
+    movementX: number;
+    movementY: number;
+    x: number;
+    y: number;
+}>;

package/dist/utils/icon.d.ts

@@ -0,0 +1 @@
+export declare function getRelationshipIcon(relationshipType: number): string | null;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+import { EntityMeta, Memo, Point, Settings, Table } from "../internal-types";
+export declare const nextZIndex: (tables: Table[], memos: Memo[]) => number;
+export declare function nextPoint({ width, height, zoomLevel, scrollLeft, scrollTop }: Settings, tables: Table[], memos: Memo[]): Point;
+export declare const toList: <T>(ids: string[], entities: Record<string, T>) => T[];
+export declare function getDefaultEntityMeta(): EntityMeta;
+export declare function safeRange(a: number, b: number): number[];
+export declare function pascalCase(value?: string): string;