@dineug/erd-editor 3.9.2 → 4.0.0

package/dist/internal-types/index.d.ts

@@ -10,12 +10,14 @@ export type Memo = GetEntity<'memoEntities'>;
 export type Relationship = GetEntity<'relationshipEntities'>;
 export type Index = GetEntity<'indexEntities'>;
 export type IndexColumn = GetEntity<'indexColumnEntities'>;
+export type TableGroup = GetEntity<'tableGroupEntities'>;
 export type TableEntities = GetEntities<'tableEntities'>;
 export type TableColumnEntities = GetEntities<'tableColumnEntities'>;
 export type MemoEntities = GetEntities<'memoEntities'>;
 export type RelationshipEntities = GetEntities<'relationshipEntities'>;
 export type IndexEntities = GetEntities<'indexEntities'>;
 export type IndexColumnEntities = GetEntities<'indexColumnEntities'>;
+export type TableGroupEntities = GetEntities<'tableGroupEntities'>;
 export type Doc = ERDEditorSchemaV3['doc'];
 export type Collections = ERDEditorSchemaV3['collections'];
 export type Settings = ERDEditorSchemaV3['settings'];
@@ -28,10 +30,6 @@ export type RelationshipPoint = {
     y: number;
     direction: number;
 };
-export type EntityMeta = {
-    updateAt: number;
-    createAt: number;
-};
 export type Unsubscribe = () => void;
 export type Ctx = Parameters<typeof useContext>[0];
 export type DeepPartial<T> = T extends string | number | bigint | boolean | null | undefined | symbol ? T | undefined : T extends Array<infer ArrayType> ? Array<DeepPartial<ArrayType>> : T extends ReadonlyArray<infer ArrayType> ? ReadonlyArray<ArrayType> : {

package/dist/konva/scene/contentBounds.d.ts

@@ -1,8 +1,8 @@
 import { RootState } from '../../engine/state';
 import { Rect } from './metrics';
 import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
-/** The smallest box holding both. */
-export declare function unionRect(a: Rect, b: Rect): Rect;
+import { TableGroupWrap } from '../../utils/tableGroup';
+export { unionRect } from './metrics';
 /** A table and the point it is about to be moved to, named before the move is dispatched. */
 export type TableMove = {
     id: string;
@@ -10,11 +10,17 @@ export type TableMove = {
     y: number;
 };
 /**
- * The box every table and memo of the document fits inside, in scene units, or
- * null for a document holding none. Computed afresh on every call: the state is
+ * The box every table, shown memo and shown group of the document fits inside, in
+ * scene units, or null for a document holding none. Computed afresh on every call: the state is
  * one mutable proxy written in place, so a cache keyed on it never sees a move.
  */
 export declare function getContentRect(state: RootState): Rect | null;
+/**
+ * Whether getContentRect has a box, read off the document's lists alone: a
+ * table, a shown memo or a shown group. A render asking only that observes no
+ * table's rect, so a drag step or a peer's move does not run it again.
+ */
+export declare function hasContent(state: RootState): boolean;
 /**
  * The box the scene drawn from a source fits inside: the document's content
  * rect, or for a view the tables it shows at their view points and no memo,
@@ -22,15 +28,15 @@ export declare function getContentRect(state: RootState): Rect | null;
  */
 export declare function getSceneContentRect(state: RootState, source?: GeometrySource): Rect | null;
 /**
- * One box per table and memo the source shows, each table at the point named
- * for it. The reader that asks which entity is nearest needs them apart, where
- * the box below folds them together, and both are the same pass over the scene.
+ * One box per table, memo and group the source shows, each table at the point
+ * named for it and each group named at its rect. The reader that asks which
+ * entity is nearest needs them apart, and the box below folds them together.
  */
-export declare function getContentRects(state: RootState, moves?: ReadonlyArray<TableMove>, source?: GeometrySource): Rect[];
+export declare function getContentRects(state: RootState, moves?: ReadonlyArray<TableMove>, source?: GeometrySource, groupRects?: ReadonlyArray<TableGroupWrap>): Rect[];
 /**
- * The content rect as it will stand once each table named is at its point. The
- * placement centres the view on where its tables land in the very dispatch that
- * moves them, so it has to know the box before any reducer has run.
+ * The content rect as it will stand once each table named is at its point and
+ * each group named at its rect. A placement centres the view on where they land
+ * in the dispatch that moves them, so it needs the box before any reducer ran.
  */
-export declare function getContentRectAfter(state: RootState, moves: ReadonlyArray<TableMove>, source?: GeometrySource): Rect | null;
+export declare function getContentRectAfter(state: RootState, moves: ReadonlyArray<TableMove>, source?: GeometrySource, groupRects?: ReadonlyArray<TableGroupWrap>): Rect | null;
 //# sourceMappingURL=contentBounds.d.ts.map

package/dist/konva/scene/metrics.d.ts

@@ -8,6 +8,8 @@ export type Rect = {
     width: number;
     height: number;
 };
+/** The smallest box holding both. */
+export declare function unionRect(a: Rect, b: Rect): Rect;
 /**
  * The box a table occupies in schema coordinates. The size is the one the
  * relationship sort measures anchors against, so a scene node and the connectors
@@ -26,6 +28,11 @@ export declare function getTableWidths(state: RootState, table: Table, source?:
  * height tall. Both of those come from the source, as they do in that sum.
  */
 export declare function getColumnRect(state: RootState, table: Table, index: number, source?: GeometrySource): Rect;
+/**
+ * The band across the top of a table, from its top edge down to where the
+ * first row starts, which holds the name and the comment beside it.
+ */
+export declare function getTableHeaderRect(state: RootState, table: Table, source?: GeometrySource): Rect;
 /** The box a memo occupies, sash and header included. */
 export declare function getMemoRect(memo: Memo): Rect;
 //# sourceMappingURL=metrics.d.ts.map

package/dist/konva/scene/renderScene.d.ts

@@ -1,6 +1,7 @@
 import { DOMTemplateLiterals } from '@dineug/r-html';
 import { Stage } from 'konva/lib/Stage';
 import { AppContext } from '../../components/appContext';
+import { I18n } from '../../i18n/translate';
 import { Theme } from '../../themes/tokens';
 /**
  * What konva accepts as a Stage container. Read off the constructor so this
@@ -20,16 +21,21 @@ export type RenderSceneOptions = {
      * what an editor's own canvas wants and what a realm without one has none of.
      */
     theme?: Theme;
+    /**
+     * The language the scene's own words are drawn in. Left out, it is the one a
+     * DOM ancestor of the container provides, or English where none does.
+     */
+    i18n?: I18n;
 };
 export type RenderedScene = {
     stage: Stage;
     destroy: () => void;
 };
 /**
- * One Stage, one scene, one provider. The provider goes up before the render
- * because a component resolves its context on its first pass, and it targets
- * what the host resolves to, so provider and consumers meet on one object.
+ * One Stage, one scene, and the providers it is given, each up before the render
+ * since a component resolves its context on its first pass, and each on what the
+ * host resolves to, so a provider and its consumers meet on one object.
  */
-export declare function renderScene({ app, container, scene, width, height, theme, }: RenderSceneOptions): RenderedScene;
+export declare function renderScene({ app, container, scene, width, height, theme, i18n, }: RenderSceneOptions): RenderedScene;
 export {};
 //# sourceMappingURL=renderScene.d.ts.map

package/dist/konva/scene/stacking.d.ts

@@ -0,0 +1,21 @@
+import { Memo, Table } from '../../internal-types';
+/** A table or a memo in the one stack both share, told apart by kind. */
+export type StackedEntity = {
+    kind: 'table';
+    entity: Table;
+} | {
+    kind: 'memo';
+    entity: Memo;
+};
+/**
+ * Tables and memos in the one order the scene paints them, lowest z-index first, as nextZIndex
+ * counts them in one sequence. A memo stands over a table of the same z-index, as the scene drew
+ * every memo over every table before tables and memos shared one stack.
+ *
+ * @example
+ * stackTablesAndMemos(tables, memos).map(({ kind, entity }) => `${kind}:${entity.id}`);
+ */
+export declare function stackTablesAndMemos(tables: ReadonlyArray<Table>, memos: ReadonlyArray<Memo>): StackedEntity[];
+/** The repeat key of a stacked entity, its kind beside its id. */
+export declare const stackedKey: ({ kind, entity }: StackedEntity) => string;
+//# sourceMappingURL=stacking.d.ts.map

package/dist/konva/scene/viewLayout.d.ts

@@ -10,6 +10,7 @@ export type VisibleIds = {
     tableIds: string[];
     memoIds: string[];
     relationshipIds: string[];
+    tableGroupIds: string[];
 };
 /** The tables a view lights and the relationships between them and what lit them. */
 export type HighlightIds = {
@@ -51,7 +52,7 @@ export declare function getReachedTableIds(state: RootState, centerIds: string[]
 /**
  * What a scene drawn from the source given shows: the whole document, or the
  * tables a view's last layout landed whatever its centers reach now, so a
- * narrowing draws the last landing until its own lands. No memo, and only the joining relationships.
+ * narrowing draws the last landing until its own lands. No memo, no group, and only the joining relationships.
  */
 export declare function getVisibleIds(state: RootState, source?: GeometrySource): VisibleIds;
 /**