@dineug/erd-editor 3.0.4 → 3.1.0

package/README.md

@@ -33,7 +33,7 @@ const editor = document.createElement('erd-editor');
   const editor = document.createElement('erd-editor');
 </script>
 <!-- or -->
-<script src="https://cdn.jsdelivr.net/npm/@dineug/erd-editor/dist/erd-editor.min.js"></script>
+<script type="module" src="https://esm.run/@dineug/erd-editor"></script>
 ```
 
 ## ErdEditorElement
@@ -47,12 +47,14 @@ interface ErdEditorElement extends HTMLElement {
   focus: () => void;
   blur: () => void;
   clear: () => void;
+  destroy: () => void;
   setInitialValue: (value: string) => void;
   setPresetTheme: (themeOptions: Partial<ThemeOptions>) => void;
   setTheme: (theme: Partial<Theme>) => void;
   setKeyBindingMap: (keyBindingMap: Partial<KeyBindingMap>) => void;
   setSchemaSQL: (value: string) => void;
   getSchemaSQL: (databaseVendor?: DatabaseVendor) => string;
+  getSharedStore: (config?: SharedStoreConfig) => SharedStore;
 }
 ```
 
@@ -343,6 +345,6 @@ editor.setTheme({...});
 
 ## Document
 
-- [vscode extension](https://marketplace.visualstudio.com/items?itemName=dineug.vuerd-vscode)
+- [Web App](https://erd-editor.io)
+- [VSCode Extension](https://marketplace.visualstudio.com/items?itemName=dineug.vuerd-vscode)
 - [Editing Guide](https://docs.erd-editor.io/docs/category/guides)
-- [Import Schema SQL Support Syntax](https://github.com/dineug/erd-editor/blob/main/packages/schema-sql-parser/src/schema_sql_test_case.md)

package/dist/components/erd/Erd.d.ts

@@ -1,6 +1,7 @@
 import { FC } from '@dineug/r-html';
 export type ErdProps = {
     isDarkMode: boolean;
+    mouseTracking: boolean;
 };
 declare const Erd: FC<ErdProps>;
 export default Erd;

package/dist/components/erd/canvas/shared-mouse-tracker/SharedMouseTracker.d.ts

@@ -0,0 +1,4 @@
+import { FC } from '@dineug/r-html';
+export type SharedMouseTrackerProps = {};
+declare const SharedMouseTracker: FC<SharedMouseTrackerProps>;
+export default SharedMouseTracker;

package/dist/components/erd/canvas/shared-mouse-tracker/shared-mouse-cursor/SharedMouseCursor.d.ts

@@ -0,0 +1,7 @@
+import { FC } from '@dineug/r-html';
+import { SharedMouseTracker } from "../../../../../engine/modules/editor/state";
+export type SharedMouseCursorProps = {
+    tracker: SharedMouseTracker;
+};
+declare const SharedMouseCursor: FC<SharedMouseCursorProps>;
+export default SharedMouseCursor;

package/dist/components/erd/canvas/shared-mouse-tracker/shared-mouse-cursor/SharedMouseCursor.styles.d.ts

@@ -0,0 +1 @@
+export declare const cursor: import("@dineug/r-html").CSSTemplateLiterals;

package/dist/components/erd-editor/ErdEditor.d.ts

@@ -1,4 +1,5 @@
 import { DatabaseVendor } from "../../constants/sql/database";
+import { SharedStore, SharedStoreConfig } from "../../engine/shared-store";
 import { ThemeOptions } from "../../themes/radix-ui-theme";
 import { Theme as ThemeType } from "../../themes/tokens";
 import { KeyBindingMap, KeyBindingName } from "../../utils/keyboard-shortcut";
@@ -17,10 +18,14 @@ export interface ErdEditorElement extends ErdEditorProps, HTMLElement {
     focus: () => void;
     blur: () => void;
     clear: () => void;
+    destroy: () => void;
     setInitialValue: (value: string) => void;
     setPresetTheme: (themeOptions: Partial<ThemeOptions>) => void;
     setTheme: (theme: Partial<ThemeType>) => void;
     setKeyBindingMap: (keyBindingMap: Partial<Omit<KeyBindingMap, typeof KeyBindingName.edit | typeof KeyBindingName.stop | typeof KeyBindingName.search | typeof KeyBindingName.undo | typeof KeyBindingName.redo | typeof KeyBindingName.zoomIn | typeof KeyBindingName.zoomOut>>) => void;
     setSchemaSQL: (value: string) => void;
     getSchemaSQL: (databaseVendor?: DatabaseVendor) => string;
+    getSharedStore: (config?: SharedStoreConfig & {
+        mouseTracker?: boolean;
+    }) => SharedStore;
 }

package/dist/components/erd-editor/useErdEditorAttachElement.d.ts

@@ -1,5 +1,6 @@
 import { Ref } from '@dineug/r-html';
 import { AppContext } from "../appContext";
+import { Unsubscribe } from "../../internal-types";
 import { ThemeOptions } from "../../themes/radix-ui-theme";
 import { Theme } from "../../themes/tokens";
 import { ErdEditorElement, ErdEditorProps } from './ErdEditor';
@@ -9,13 +10,14 @@ type Props = {
     app: AppContext;
     root: Ref<HTMLDivElement>;
 };
-export declare function useErdEditorAttachElement({ props, ctx, app: { store, keyBindingMap, emitter }, root, }: Props): {
+export declare function useErdEditorAttachElement({ props, ctx, app: { store, keyBindingMap, emitter, shortcut$, keydown$ }, root, }: Props): {
     theme: Theme;
     themeState: {
         options: ThemeOptions;
         preset: Theme;
         custom: Partial<Theme>;
     };
+    destroySet: Set<Unsubscribe>;
     hasDarkMode: () => boolean;
 };
 export {};

package/dist/components/toolbar/Toolbar.d.ts

@@ -1,6 +1,7 @@
 import { FC } from '@dineug/r-html';
 export type ToolbarProps = {
     enableThemeBuilder: boolean;
+    readonly: boolean;
 };
 declare const Toolbar: FC<ToolbarProps>;
 export default Toolbar;

package/dist/engine/actions.d.ts

@@ -28,6 +28,9 @@ 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 SharedStreamActionTypes: ReadonlyArray<ActionType>;
+export declare const SharedActionTypes: ReadonlyArray<ActionType>;
+export declare const SharedFollowingActionTypes: ReadonlyArray<ActionType>;
 export declare const StreamRegroupMoveActionTypes: ReadonlyArray<ActionType>;
 export declare const StreamRegroupColorActionTypes: ReadonlyArray<ActionType>;
 export declare const StreamRegroupScrollActionTypes: ReadonlyArray<ActionType>;

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

@@ -3,7 +3,7 @@ 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 type PushStreamHistory = (undoActions: AnyAction[], redoActions: AnyAction[], actions: AnyAction[]) => 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/index.d.ts

@@ -0,0 +1 @@
+export { createReplicationStore, type ReplicationStore, } from './replication-store';

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

@@ -28,6 +28,7 @@ export declare const ActionType: {
     readonly changeOpenMap: "editor.changeOpenMap";
     readonly dragstartColumn: "editor.dragstartColumn";
     readonly dragendColumn: "editor.dragendColumn";
+    readonly sharedMouseTracker: "editor.sharedMouseTracker";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -89,5 +90,9 @@ export type ActionMap = {
         columnIds: string[];
     };
     [ActionType.dragendColumn]: void;
+    [ActionType.sharedMouseTracker]: {
+        x: number;
+        y: number;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;

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

@@ -188,6 +188,17 @@ export declare const dragendColumnAction: {
     toString(): string;
     type: string;
 };
+export declare const sharedMouseTrackerAction: {
+    (payload: {
+        x: number;
+        y: number;
+    }): import("@dineug/r-html").AnyAction<{
+        x: number;
+        y: number;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const editorReducers: {
     "editor.changeHasHistory": ReducerType<"editor.changeHasHistory">;
     "editor.selectAll": ReducerType<"editor.selectAll">;
@@ -213,6 +224,7 @@ export declare const editorReducers: {
     "editor.changeOpenMap": ReducerType<"editor.changeOpenMap">;
     "editor.dragstartColumn": ReducerType<"editor.dragstartColumn">;
     "editor.dragendColumn": ReducerType<"editor.dragendColumn">;
+    "editor.sharedMouseTracker": ReducerType<"editor.sharedMouseTracker">;
 };
 export declare const actions: {
     changeHasHistoryAction: {
@@ -403,4 +415,15 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    sharedMouseTrackerAction: {
+        (payload: {
+            x: number;
+            y: number;
+        }): import("@dineug/r-html").AnyAction<{
+            x: number;
+            y: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
 };

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

@@ -1,5 +1,6 @@
 import { Point, ValuesType } from "../../../internal-types";
 export type Editor = {
+    id: string;
     selectedMap: Record<string, SelectType>;
     hasUndo: boolean;
     hasRedo: boolean;
@@ -10,6 +11,7 @@ export type Editor = {
     openMap: Record<string, boolean>;
     draggableColumn: DraggableColumn | null;
     draggingColumnMap: Record<string, boolean>;
+    sharedMouseTrackerMap: Record<string, SharedMouseTracker>;
 };
 export type Viewport = {
     width: number;
@@ -34,6 +36,13 @@ export type DraggableColumn = {
     tableId: string;
     columnIds: string[];
 };
+export type SharedMouseTracker = {
+    id: string;
+    x: number;
+    y: number;
+    nickname: string;
+    timeoutId: any;
+};
 export declare const SelectType: {
     readonly table: "table";
     readonly memo: "memo";

package/dist/engine/replication-store.d.ts

@@ -0,0 +1,23 @@
+import { AnyAction } from '@dineug/r-html';
+import { EngineContext } from "./context";
+import { Unsubscribe, ValuesType } from "../internal-types";
+type ReducerRecord = {
+    [P in keyof InternalActionMap]: (payload: InternalActionMap[P]) => void;
+};
+declare const InternalActionType: {
+    readonly change: "change";
+};
+type InternalActionType = ValuesType<typeof InternalActionType>;
+type InternalActionMap = {
+    [InternalActionType.change]: void;
+};
+export type ReplicationStore = {
+    readonly value: string;
+    on: (reducers: Partial<ReducerRecord>) => Unsubscribe;
+    setInitialValue: (value: string) => void;
+    dispatch: (actions: Array<AnyAction> | AnyAction) => void;
+    dispatchSync: (actions: Array<AnyAction> | AnyAction) => void;
+    destroy: () => void;
+};
+export declare function createReplicationStore(context: EngineContext): ReplicationStore;
+export {};

package/dist/engine/rx-operators/bufferCircuitBreaker.d.ts

@@ -0,0 +1,3 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+export declare const bufferCircuitBreaker: (openingNotifier$: Observable<any>, closingNotifier$: Observable<any>) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;

package/dist/engine/rx-operators/groupByStreamActions.d.ts

@@ -1,5 +1,5 @@
 import { AnyAction } from '@dineug/r-html';
-import { Observable } from 'rxjs';
+import { MonoTypeOperatorFunction, Observable } from 'rxjs';
 type Regroup = [string, Array<string> | ReadonlyArray<string>];
-export declare const groupByStreamActions: (streamActionTypes: Array<string> | ReadonlyArray<string>, regroups?: Regroup[]) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+export declare const groupByStreamActions: (streamActionTypes: Array<string> | ReadonlyArray<string>, regroups?: Regroup[], bufferClosingNotifierOperator?: MonoTypeOperatorFunction<Array<AnyAction>>) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
 export {};

package/dist/engine/rx-operators/ignoreTagFilter.d.ts

@@ -1,3 +1,3 @@
 import { AnyAction } from '@dineug/r-html';
 import { Observable } from 'rxjs';
-export declare const ignoreTagFilter: (tag: number) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+export declare const ignoreTagFilter: (tags: number[]) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;

package/dist/engine/rx-operators/index.d.ts

@@ -1,4 +1,6 @@
 export * from './actionsFilter';
+export * from './bufferCircuitBreaker';
 export * from './groupByStreamActions';
 export * from './ignoreTagFilter';
 export * from './notEmptyActions';
+export * from './sharedStreamActionsCompressor';

package/dist/engine/rx-operators/readonlyIgnoreFilter.d.ts

@@ -1,3 +1,3 @@
 import { AnyAction } from '@dineug/r-html';
 import { Observable } from 'rxjs';
-export declare const readonlyIgnoreFilter: (getReadonly: () => boolean) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+export declare const readonlyIgnoreFilter: (getReadonly: () => boolean, passTags?: number[]) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;

package/dist/engine/rx-operators/sharedStreamActionsCompressor.d.ts

@@ -0,0 +1,3 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+export declare const sharedStreamActionsCompressor: (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;

package/dist/engine/shared-store.d.ts

@@ -0,0 +1,15 @@
+import { AnyAction } from '@dineug/r-html';
+import { RxStore } from "./rx-store";
+import { Unsubscribe } from "../internal-types";
+export type SharedStore = {
+    connection: () => void;
+    disconnect: () => void;
+    dispatch: (actions: Array<AnyAction> | AnyAction) => void;
+    dispatchSync: (actions: Array<AnyAction> | AnyAction) => void;
+    subscribe: (fn: (value: AnyAction[]) => void) => Unsubscribe;
+    destroy: () => void;
+};
+export type SharedStoreConfig = {
+    getNickname?: () => string;
+};
+export declare function createSharedStore(store: RxStore, config?: SharedStoreConfig): SharedStore;

package/dist/engine/store.d.ts

@@ -2,4 +2,4 @@ import { Store as StoreType } from '@dineug/r-html';
 import { EngineContext } from "./context";
 import { RootState } from "./state";
 export type Store = StoreType<RootState, EngineContext>;
-export declare function createStore(context: EngineContext): Store;
+export declare function createStore(context: EngineContext, enableObservable?: boolean): Store;

package/dist/engine/tag.d.ts

@@ -2,6 +2,9 @@ import { AnyAction, CompositionActions } from '@dineug/r-html';
 import { GeneratorAction } from "./generator.actions";
 export declare const Tag: {
     readonly shared: 1;
+    readonly changeOnly: 2;
+    readonly following: 4;
 };
-export declare function attachActionTag(tag: number, actions: AnyAction[]): AnyAction[];
-export declare const attachSharedTag$: (...compositionActions: CompositionActions) => GeneratorAction;
+export declare function attachActionTag(tag: number, action: AnyAction): AnyAction;
+export declare function attachActionsTag(tag: number, actions: AnyAction[]): AnyAction[];
+export declare const attachChangeOnlyTag$: (...compositionActions: CompositionActions) => GeneratorAction;

package/dist/engine.js

@@ -0,0 +1,44 @@
+import { D as A, E as w, u as x, O as E, F as l, J as $, p as G, bs as d, I as p, Y as I, c$ as O, br as T, aA as j, d5 as k, U as F, cY as J, cS as R } from "./schemaGCService-gIQm27aj.js";
+/*!
+ * @dineug/erd-editor
+ * @version 3.1.0 | Sat Jan 06 2024
+ * @author SeungHwan-Lee <dineug2@gmail.com>
+ * @license MIT
+ */
+const b = {
+  change: "change"
+};
+function Y(u) {
+  const o = /* @__PURE__ */ new Set(), s = A(u, !1), m = w(s), c = new x(), S = new E((e) => s.subscribe((a) => e.next(a))).pipe(l(p), $(200)), n = /* @__PURE__ */ new Set(), f = new R(), g = (e) => (n.has(e) || n.add(e), () => {
+    n.delete(e);
+  }), i = (e, a) => {
+    n.forEach((t) => {
+      const h = Reflect.get(t, e);
+      I(h, a);
+    });
+  }, y = (e) => {
+    const a = O(e);
+    s.dispatchSync(T(j(a) ? "{}" : a)), f.run(d(s.state)).then((t) => {
+      (t.tableIds.length || t.tableColumnIds.length || t.relationshipIds.length || t.indexIds.length || t.indexColumnIds.length || t.memoIds.length) && (k(s.state, t), i(b.change, void 0));
+    });
+  }, r = (e) => {
+    c.next([e].flat());
+  }, C = (e) => {
+    F(() => r(e));
+  }, v = () => {
+    Array.from(o).forEach((e) => e.unsubscribe()), o.clear(), n.clear(), s.destroy(), m.destroy();
+  };
+  return o.add(S.subscribe(() => i(b.change, void 0))).add(c.pipe(l(p), G((e) => e.map((a) => J(a, "tags")))).subscribe(s.dispatchSync)), Object.freeze({
+    get value() {
+      return d(s.state);
+    },
+    on: g,
+    setInitialValue: y,
+    dispatch: C,
+    dispatchSync: r,
+    destroy: v
+  });
+}
+export {
+  Y as createReplicationStore
+};