@dineug/erd-editor 3.0.0

package/dist/components/visualization/createVisualization.d.ts

@@ -0,0 +1,9 @@
+import { RootState } from "../../engine/state";
+type Props = {
+    onDragStart: () => void;
+    onDragEnd: () => void;
+    onStartPreview: (event: MouseEvent, tableId: string | null, columnId: string | null) => void;
+    onEndPreview: () => void;
+};
+export declare function createVisualization(state: RootState, props: Props): import("d3-selection").Selection<SVGSVGElement, undefined, null, undefined>;
+export {};

package/dist/components/visualization/table/Table.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@dineug/r-html';
+import { Table } from "../../../internal-types";
+export type TableProps = {
+    table: Table;
+    columnId: string | null;
+    x: number;
+    y: number;
+};
+declare const Table: FC<TableProps>;
+export default Table;

package/dist/components/visualization/table/Table.styles.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/visualization/table/column/Column.d.ts

@@ -0,0 +1,12 @@
+import { FC } from '@dineug/r-html';
+import { Column } from "../../../../internal-types";
+export type ColumnProps = {
+    column: Column;
+    selected: boolean;
+    widthName: number;
+    widthDataType: number;
+    widthDefault: number;
+    widthComment: number;
+};
+declare const Column: FC<ColumnProps>;
+export default Column;

package/dist/components/visualization/table/column/Column.styles.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/constants/language.d.ts

@@ -0,0 +1 @@
+export declare const LanguageToLangMap: Record<number, string>;

package/dist/constants/layout.d.ts

@@ -0,0 +1,32 @@
+export declare const START_X = 200;
+export declare const START_Y = 100;
+export declare const START_ADD = 50;
+export declare const DEFAULT_WIDTH = 1200;
+export declare const DEFAULT_HEIGHT: number;
+export declare const INPUT_HEIGHT = 20;
+export declare const INPUT_MARGIN_RIGHT = 8;
+export declare const HEADER_ICON_HEIGHT = 12;
+export declare const HEADER_ICON_MARGIN_BOTTOM = 4;
+export declare const TABLE_BORDER = 1;
+export declare const TABLE_PADDING = 8;
+export declare const TABLE_HEADER_PADDING = 2;
+export declare const TABLE_HEADER_ICON_MARGIN_BOTTOM = 2;
+export declare const TABLE_HEADER_INPUT_HEIGHT: number;
+export declare const TABLE_HEADER_HEIGHT: number;
+export declare const TABLE_HEADER_BUTTON_MARGIN_LEFT = 4;
+export declare const COLUMN_DELETE_WIDTH = 12;
+export declare const COLUMN_KEY_WIDTH = 12;
+export declare const COLUMN_MIN_WIDTH = 60;
+export declare const COLUMN_NOT_NULL_WIDTH = 35;
+export declare const COLUMN_UNIQUE_WIDTH = 22;
+export declare const COLUMN_AUTO_INCREMENT_WIDTH = 15;
+export declare const COLUMN_PADDING = 2;
+export declare const COLUMN_HEIGHT: number;
+export declare const MEMO_BORDER = 1;
+export declare const MEMO_PADDING = 8;
+export declare const MEMO_HEADER_HEIGHT: number;
+export declare const MEMO_MIN_WIDTH: number;
+export declare const MEMO_MIN_HEIGHT = 100;
+export declare const MINIMAP_SIZE = 150;
+export declare const MINIMAP_MARGIN = 20;
+export declare const TOOLBAR_HEIGHT = 30;

package/dist/constants/open.d.ts

@@ -0,0 +1,8 @@
+import { ValuesType } from "../internal-types";
+export declare const Open: {
+    readonly automaticTablePlacement: "automaticTablePlacement";
+    readonly tableProperties: "tableProperties";
+    readonly search: "search";
+    readonly themeBuilder: "themeBuilder";
+};
+export type Open = ValuesType<typeof Open>;

package/dist/constants/schema.d.ts

@@ -0,0 +1,102 @@
+export declare const CanvasType: {
+    readonly ERD: "ERD";
+    readonly visualization: "@dineug/erd-editor/builtin-visualization";
+    readonly schemaSQL: "@dineug/erd-editor/builtin-schema-sql";
+    readonly generatorCode: "@dineug/erd-editor/builtin-generator-code";
+    readonly settings: "settings";
+};
+export declare const CanvasTypeList: readonly string[];
+export declare const Show: {
+    readonly tableComment: 1;
+    readonly columnComment: 2;
+    readonly columnDataType: 4;
+    readonly columnDefault: 8;
+    readonly columnAutoIncrement: 16;
+    readonly columnPrimaryKey: 32;
+    readonly columnUnique: 64;
+    readonly columnNotNull: 128;
+    readonly relationship: 256;
+};
+export declare const ColumnType: {
+    readonly columnName: 1;
+    readonly columnDataType: 2;
+    readonly columnNotNull: 4;
+    readonly columnUnique: 8;
+    readonly columnAutoIncrement: 16;
+    readonly columnDefault: 32;
+    readonly columnComment: 64;
+};
+export declare const ColumnTypeList: readonly number[];
+export declare const Database: {
+    readonly MariaDB: 1;
+    readonly MSSQL: 2;
+    readonly MySQL: 4;
+    readonly Oracle: 8;
+    readonly PostgreSQL: 16;
+    readonly SQLite: 32;
+};
+export declare const DatabaseList: readonly number[];
+export declare const Language: {
+    readonly GraphQL: 1;
+    readonly csharp: 2;
+    readonly Java: 4;
+    readonly Kotlin: 8;
+    readonly TypeScript: 16;
+    readonly JPA: 32;
+    readonly Scala: 64;
+};
+export declare const LanguageList: readonly number[];
+export declare const NameCase: {
+    readonly none: 1;
+    readonly camelCase: 2;
+    readonly pascalCase: 4;
+    readonly snakeCase: 8;
+};
+export declare const NameCaseList: readonly number[];
+export declare const BracketType: {
+    readonly none: 1;
+    readonly doubleQuote: 2;
+    readonly singleQuote: 4;
+    readonly backtick: 8;
+};
+export declare const BracketTypeList: readonly number[];
+export declare const RelationshipType: {
+    readonly ZeroOne: 2;
+    readonly ZeroN: 4;
+    readonly OneOnly: 8;
+    readonly OneN: 16;
+};
+export declare const RelationshipTypeList: readonly number[];
+export declare const StartRelationshipType: {
+    readonly ring: 1;
+    readonly dash: 2;
+};
+export declare const StartRelationshipTypeList: readonly number[];
+export declare const Direction: {
+    readonly left: 1;
+    readonly right: 2;
+    readonly top: 4;
+    readonly bottom: 8;
+};
+export declare const DirectionList: readonly number[];
+export declare const ColumnOption: {
+    readonly autoIncrement: 1;
+    readonly primaryKey: 2;
+    readonly unique: 4;
+    readonly notNull: 8;
+};
+export declare const ColumnUIKey: {
+    readonly primaryKey: 1;
+    readonly foreignKey: 2;
+};
+export declare const OrderType: {
+    readonly ASC: 1;
+    readonly DESC: 2;
+};
+export declare const OrderTypeList: readonly number[];
+export declare const CANVAS_SIZE_MAX: 20000;
+export declare const CANVAS_SIZE_MIN: 2000;
+export declare const CANVAS_ZOOM_MAX: 1;
+export declare const CANVAS_ZOOM_MIN: 0.1;
+export declare const BracketTypeMap: Record<number, string>;
+export declare const ColumnTypeToName: Record<number, string>;

package/dist/constants/sql/dataType/MSSQL.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from "./";
+/**
+ * https://docs.microsoft.com/ko-kr/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver15
+ */
+export declare const MSSQLTypes: DataTypeHint[];

package/dist/constants/sql/dataType/MariaDB.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from "./";
+/**
+ * https://mariadb.com/kb/en/data-types/
+ */
+export declare const MariaDBTypes: DataTypeHint[];

package/dist/constants/sql/dataType/MySQL.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from "./";
+/**
+ * https://dev.mysql.com/doc/refman/8.0/en/data-types.html
+ */
+export declare const MySQLTypes: DataTypeHint[];

package/dist/constants/sql/dataType/Oracle.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from "./";
+/**
+ * https://docs.oracle.com/cd/B28359_01/server.111/b28318/datatype.htm#CNCPT012
+ */
+export declare const OracleTypes: DataTypeHint[];

package/dist/constants/sql/dataType/PostgreSQL.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from "./";
+/**
+ * https://www.postgresql.org/docs/current/datatype.html
+ */
+export declare const PostgreSQLTypes: DataTypeHint[];

package/dist/constants/sql/dataType/SQLite.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from "./";
+/**
+ * https://www.sqlite.org/datatype3.html
+ */
+export declare const SQLiteTypes: DataTypeHint[];

package/dist/constants/sql/dataType/index.d.ts

@@ -0,0 +1,25 @@
+import { ValuesType } from "../../../internal-types";
+export declare const PrimitiveType: {
+    readonly int: "int";
+    readonly long: "long";
+    readonly float: "float";
+    readonly double: "double";
+    readonly decimal: "decimal";
+    readonly boolean: "boolean";
+    readonly string: "string";
+    readonly lob: "lob";
+    readonly date: "date";
+    readonly dateTime: "dateTime";
+    readonly time: "time";
+};
+export type PrimitiveType = ValuesType<typeof PrimitiveType>;
+export type PrimitiveTypeMap = Record<PrimitiveType, string>;
+export type DataTypeHint = {
+    name: string;
+    primitiveType: PrimitiveType;
+};
+export type DatabaseHint = {
+    database: number;
+    dataTypeHints: DataTypeHint[];
+};
+export declare const DatabaseHintMap: Record<number, Array<DataTypeHint>>;

package/dist/constants/sql/database.d.ts

@@ -0,0 +1,12 @@
+import { ValuesType } from "../../internal-types";
+export declare const DatabaseVendor: {
+    readonly MariaDB: "MariaDB";
+    readonly MSSQL: "MSSQL";
+    readonly MySQL: "MySQL";
+    readonly Oracle: "Oracle";
+    readonly PostgreSQL: "PostgreSQL";
+    readonly SQLite: "SQLite";
+};
+export type DatabaseVendor = ValuesType<typeof DatabaseVendor>;
+export declare const DatabaseVendorList: ReadonlyArray<string>;
+export declare const DatabaseVendorToDatabase: Record<DatabaseVendor, number>;

package/dist/engine/actions.d.ts

@@ -0,0 +1,35 @@
+import { ActionMap as EditorActionMap } from "./modules/editor/actions";
+import { actions as editorActions } from "./modules/editor/atom.actions";
+import { actions$ as editorActions$ } from "./modules/editor/generator.actions";
+import { ActionMap as IndexActionMap } from "./modules/index/actions";
+import { actions as indexActions } from "./modules/index/atom.actions";
+import { actions$ as indexActions$ } from "./modules/index/generator.actions";
+import { ActionMap as IndexColumnActionMap } from "./modules/index-column/actions";
+import { actions as indexColumnActions } from "./modules/index-column/atom.actions";
+import { actions$ as indexColumnActions$ } from "./modules/index-column/generator.actions";
+import { ActionMap as MemoActionMap } from "./modules/memo/actions";
+import { actions as memoActions } from "./modules/memo/atom.actions";
+import { actions$ as memoActions$ } from "./modules/memo/generator.actions";
+import { ActionMap as RelationshipActionMap } from "./modules/relationship/actions";
+import { actions as relationshipActions } from "./modules/relationship/atom.actions";
+import { actions$ as relationshipActions$ } from "./modules/relationship/generator.actions";
+import { ActionMap as SettingsActionMap } from "./modules/settings/actions";
+import { actions as settingsActions } from "./modules/settings/atom.actions";
+import { actions$ as settingsActions$ } from "./modules/settings/generator.actions";
+import { ActionMap as TableActionMap } from "./modules/table/actions";
+import { actions as tableActions } from "./modules/table/atom.actions";
+import { actions$ as tableActions$ } from "./modules/table/generator.actions";
+import { ActionMap as TableColumnActionMap } from "./modules/table-column/actions";
+import { actions as tableColumnActions } from "./modules/table-column/atom.actions";
+import { actions$ as tableColumnActions$ } from "./modules/table-column/generator.actions";
+export type Actions = typeof editorActions & typeof editorActions$ & typeof indexActions & typeof indexActions$ & typeof indexColumnActions & typeof indexColumnActions$ & typeof memoActions & typeof memoActions$ & typeof relationshipActions & typeof relationshipActions$ & typeof settingsActions & typeof settingsActions$ & typeof tableActions & typeof tableActions$ & typeof tableColumnActions & typeof tableColumnActions$;
+export type RootActionMap = EditorActionMap & TableActionMap & TableColumnActionMap & MemoActionMap & RelationshipActionMap & SettingsActionMap & IndexActionMap & IndexColumnActionMap;
+export type ActionType = keyof RootActionMap;
+export declare const actions: Actions;
+export declare const ChangeActionTypes: ReadonlyArray<ActionType>;
+export declare const ReadonlyIgnoreActionTypes: ReadonlyArray<ActionType>;
+export declare const StreamRegroupMoveActionTypes: ReadonlyArray<ActionType>;
+export declare const StreamRegroupColorActionTypes: ReadonlyArray<ActionType>;
+export declare const StreamRegroupScrollActionTypes: ReadonlyArray<ActionType>;
+export declare const StreamActionTypes: ReadonlyArray<ActionType>;
+export declare const HistoryActionTypes: ReadonlyArray<ActionType>;

package/dist/engine/context.d.ts

@@ -0,0 +1,5 @@
+export type EngineContext = {
+    toWidth: (text: string) => number;
+};
+export type InjectEngineContext = EngineContext;
+export declare function createEngineContext(ctx: InjectEngineContext): EngineContext;

package/dist/engine/generator.actions.d.ts

@@ -0,0 +1,4 @@
+import { AnyAction, GeneratorActionCreator } from '@dineug/r-html';
+import { EngineContext } from "./context";
+import { RootState } from "./state";
+export type GeneratorAction = GeneratorActionCreator<AnyAction, RootState, EngineContext>;

package/dist/engine/history.actions.d.ts

@@ -0,0 +1,9 @@
+import { AnyAction } from '@dineug/r-html';
+import { History } from "./history";
+import { RootState } from "./state";
+import { Store } from "./store";
+export type PushUndoHistory = (undoActions: AnyAction[], action: AnyAction, state: RootState) => void;
+export type PushStreamHistory = (undoActions: AnyAction[], redoActions: AnyAction[], actions: AnyAction[], state: RootState) => void;
+export declare const pushUndoHistoryMap: Record<string, PushUndoHistory>;
+export declare const pushStreamHistoryMap: Record<string, PushStreamHistory>;
+export declare const pushHistory: (store: Store, history: History) => (actions: AnyAction[]) => void;

package/dist/engine/history.d.ts

@@ -0,0 +1,20 @@
+export type Command = {
+    undo(): void;
+    redo(): void;
+};
+export type CommandKey = keyof Command;
+export type History = {
+    hasUndo(): boolean;
+    hasRedo(): boolean;
+    undo(): void;
+    redo(): void;
+    push(command: Command): void;
+    clear(): void;
+    setLimit(limit: number): void;
+};
+type HasHistory = {
+    hasRedo: boolean;
+    hasUndo: boolean;
+};
+export declare function createHistory(notify: (has: HasHistory) => void): History;
+export {};

package/dist/engine/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { Channel, CoroutineCreator } from '@dineug/go';
+import { type AnyAction, createAction } from '@dineug/r-html';
+import type { EngineContext } from "./context";
+import type { RootState } from "./state";
+type ActionCreator = ReturnType<typeof createAction<any>>;
+export type CO = (channel: Channel<AnyAction>, state: RootState, ctx: EngineContext) => ReturnType<CoroutineCreator>;
+export type Hook = [Array<ActionCreator | string>, CO];
+export {};

package/dist/engine/modules/editor/actions.d.ts

@@ -0,0 +1,93 @@
+import { Reducer } from '@dineug/r-html';
+import { EngineContext } from "../../context";
+import { RootState } from "../../state";
+import { ValuesType } from "../../../internal-types";
+import { FocusType, MoveKey, SelectType } from './state';
+export declare const ActionType: {
+    readonly changeHasHistory: "editor.changeHasHistory";
+    readonly selectAll: "editor.selectAll";
+    readonly unselectAll: "editor.unselectAll";
+    readonly select: "editor.select";
+    readonly changeViewport: "editor.changeViewport";
+    readonly clear: "editor.clear";
+    readonly loadJson: "editor.loadJson";
+    readonly initialClear: "editor.initialClear";
+    readonly initialLoadJson: "editor.initialLoadJson";
+    readonly focusTable: "editor.focusTable";
+    readonly focusColumn: "editor.focusColumn";
+    readonly focusTableEnd: "editor.focusTableEnd";
+    readonly focusMoveTable: "editor.focusMoveTable";
+    readonly editTable: "editor.editTable";
+    readonly editTableEnd: "editor.editTableEnd";
+    readonly selectAllColumn: "editor.selectAllColumn";
+    readonly drawStartRelationship: "editor.drawStartRelationship";
+    readonly drawStartAddRelationship: "editor.drawStartAddRelationship";
+    readonly drawEndRelationship: "editor.drawEndRelationship";
+    readonly drawRelationship: "editor.drawRelationship";
+    readonly hoverColumnMap: "editor.hoverColumnMap";
+    readonly changeOpenMap: "editor.changeOpenMap";
+    readonly dragstartColumn: "editor.dragstartColumn";
+    readonly dragendColumn: "editor.dragendColumn";
+};
+export type ActionType = ValuesType<typeof ActionType>;
+export type ActionMap = {
+    [ActionType.changeHasHistory]: {
+        hasUndo: boolean;
+        hasRedo: boolean;
+    };
+    [ActionType.selectAll]: void;
+    [ActionType.unselectAll]: void;
+    [ActionType.select]: Record<string, SelectType>;
+    [ActionType.changeViewport]: {
+        width: number;
+        height: number;
+    };
+    [ActionType.clear]: void;
+    [ActionType.loadJson]: {
+        value: string;
+    };
+    [ActionType.initialClear]: void;
+    [ActionType.initialLoadJson]: {
+        value: string;
+    };
+    [ActionType.focusTable]: {
+        tableId: string;
+        focusType?: FocusType;
+    };
+    [ActionType.focusColumn]: {
+        tableId: string;
+        columnId: string;
+        focusType: FocusType;
+        $mod: boolean;
+        shiftKey: boolean;
+    };
+    [ActionType.focusTableEnd]: void;
+    [ActionType.focusMoveTable]: {
+        moveKey: MoveKey;
+        shiftKey: boolean;
+    };
+    [ActionType.editTable]: void;
+    [ActionType.editTableEnd]: void;
+    [ActionType.selectAllColumn]: void;
+    [ActionType.drawStartRelationship]: {
+        relationshipType: number;
+    };
+    [ActionType.drawStartAddRelationship]: {
+        tableId: string;
+    };
+    [ActionType.drawEndRelationship]: void;
+    [ActionType.drawRelationship]: {
+        x: number;
+        y: number;
+    };
+    [ActionType.hoverColumnMap]: {
+        columnIds: string[];
+    };
+    [ActionType.changeOpenMap]: Record<string, boolean>;
+    [ActionType.dragstartColumn]: {
+        tableId: string;
+        columnIds: string[];
+    };
+    [ActionType.dragendColumn]: void;
+};
+export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;