@dineug/erd-editor 3.10.0 → 4.0.0

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

@@ -0,0 +1,57 @@
+import { ValuesType } from '../../internal-types';
+export declare const SchemaSQLStatements: {
+    readonly create: "create";
+    readonly ifNotExists: "ifNotExists";
+    readonly recreate: "recreate";
+};
+export type SchemaSQLStatements = ValuesType<typeof SchemaSQLStatements>;
+export declare const SchemaSQLStatementsList: ReadonlyArray<SchemaSQLStatements>;
+export declare const SchemaSQLHeader: {
+    readonly none: "none";
+    readonly use: "use";
+    readonly createAndUse: "createAndUse";
+};
+export type SchemaSQLHeader = ValuesType<typeof SchemaSQLHeader>;
+export declare const SchemaSQLHeaderList: ReadonlyArray<SchemaSQLHeader>;
+/** What getSchemaSQL, an agent's SQL read and the Schema SQL tab pass: an intent, resolved per vendor. */
+export type SchemaSQLOptions = {
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    /** none when left out. */
+    header?: SchemaSQLHeader;
+};
+/** The name a header may write: a plain identifier, so no vendor needs it escaped. */
+export declare const HEADER_NAME_PATTERN: RegExp;
+export type HeaderName = 'valid' | 'empty' | 'invalid';
+export type ResolvedSchemaSQLOptions = {
+    /** What the vendor writes for the statements asked for. */
+    statements: SchemaSQLStatements;
+    /** What the vendor writes for the header asked for, before the name is read. */
+    header: SchemaSQLHeader;
+    /** Whether settings.databaseName can name that header. */
+    headerName: HeaderName;
+};
+export type SchemaSQLSupport = {
+    ifNotExists: boolean;
+    headers: ReadonlyArray<Exclude<SchemaSQLHeader, 'none'>>;
+};
+/**
+ * Whether a database writes CREATE ... IF NOT EXISTS and which headers it has;
+ * every one of them writes drop and re-create.
+ */
+export declare function schemaSQLSupport(database: number): SchemaSQLSupport;
+export declare function isSchemaSQLStatements(value: unknown): value is SchemaSQLStatements;
+export declare function isSchemaSQLHeader(value: unknown): value is SchemaSQLHeader;
+/**
+ * The statements and header a database writes for the ones asked for: one it
+ * lacks falls back to the nearest it has, so the choice outlives a change of
+ * database; an unknown value reads as create and none.
+ */
+export declare function resolveSchemaSQLOptions(database: number, options: SchemaSQLOptions | undefined, databaseName: string): ResolvedSchemaSQLOptions;
+/**
+ * A before or after script as the DDL writes it: line breaks as LF, without the
+ * blank lines ahead of it or the whitespace after it, and on SQL Server ended
+ * with GO; the empty string when nothing is left.
+ */
+export declare function formatScript(text: string, database: number): string;
+//# sourceMappingURL=options.d.ts.map

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

@@ -1,7 +1,27 @@
-import { Column, Index, Relationship, Table } from '../../internal-types';
+import { RootState } from '../../engine/state';
+import { Collections, Column, Index, IndexColumn, Relationship, Table } from '../../internal-types';
+import { SchemaSQLStatements } from './options';
+/** What a script's DROP block and the Oracle name check read off the body just written. */
+export interface WrittenObjects {
+    /** The tables in the order their CREATE TABLE is written. */
+    tables: Table[];
+    /** Oracle: each sequence name as written, its owner included. */
+    sequences: string[];
+    /** Oracle: each identifier written, unquoted, in the order written. */
+    identifiers: string[];
+}
+export declare function createWrittenObjects(): WrittenObjects;
+export interface CreateSchemaOptions {
+    /** Already what the database writes (resolveSchemaSQLOptions); create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
+}
 export interface FormatTableOptions {
     buffer: string[];
     table: Table;
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
 }
 export interface FormatColumnOptions {
     buffer: string[];
@@ -13,11 +33,17 @@ export interface FormatRelationOptions {
     buffer: string[];
     relationship: Relationship;
     fkNames: Name[];
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
 }
 export interface FormatIndexOptions {
     buffer: string[];
     index: Index;
     indexNames: Name[];
+    /** create when left out. */
+    statements?: SchemaSQLStatements;
+    written?: WrittenObjects;
 }
 export interface FormatCommentOptions {
     buffer: string[];
@@ -31,6 +57,36 @@ export interface KeyColumn {
     start: Column[];
     end: Column[];
 }
+/** The columns of a foreign key, end[i] referencing start[i]. */
+export interface ForeignKeyPairs extends KeyColumn {
+    startTable: Table;
+    endTable: Table;
+}
+/**
+ * A relationship read pair by pair: a pair whose start or end column has left
+ * its table is dropped whole, and pairs that reference the whole primary key
+ * follow its declaration order; null when a table or every pair is gone.
+ */
+export declare function toForeignKeyPairs({ doc: { tableIds }, collections }: Pick<RootState, 'doc' | 'collections'>, { start, end }: Relationship): ForeignKeyPairs | null;
+/**
+ * The columns of an index its table still lists, in the index's order, each
+ * with the index column naming it: a column taken out of the table stays in
+ * the collection, but a saved file leaves it out of the index, as this does.
+ */
+export declare function selectIndexColumns(collections: Collections, table: Table, index: Index): Array<{
+    indexColumn: IndexColumn;
+    column: Column;
+}>;
+/**
+ * What one export writes: every table, relationship and index of the document,
+ * or the tables named, their indexes and the foreign keys they hold, whose
+ * parents stay in the document, so a reference out still shows; never an index of a removed table.
+ */
+export declare function toSchemaEntities({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, tableIds?: readonly string[]): {
+    tables: Table[];
+    relationships: Relationship[];
+    indexes: Index[];
+};
 export declare function formatNames<T extends {
     name: string;
 }>(list: T[], backtick?: string, backtick2?: string): string;
@@ -45,13 +101,51 @@ export declare function primaryKeyColumns(columns: Column[]): Column[];
 export declare function unique(columns: Column[]): boolean;
 export declare function uniqueColumns(columns: Column[]): Column[];
 export declare function getBracket(bracketType: number): string;
+/**
+ * The words a CREATE TABLE or CREATE INDEX writes after its object type, and
+ * MariaDB after UNIQUE and FOREIGN KEY, under ifNotExists; nothing otherwise.
+ */
+export declare function ifNotExists(statements?: SchemaSQLStatements): string;
+/**
+ * The parts of an unquoted name, split at each dot outside brackets or double
+ * quotes as SQL Server reads it, so [sales.v2].users is two parts.
+ */
+export declare function splitNameParts(name: string): string[];
+/** Whether a name part is written in one pair of brackets or double quotes. */
+export declare function isDelimitedPart(part: string): boolean;
+/** The name a part in brackets or double quotes holds; any other part as is. */
+export declare function unquoteNamePart(part: string): string;
+/**
+ * A table name split at its last dot outside brackets or double quotes into
+ * schema and table, both as written, where it is unquoted; quoted, the whole
+ * name is one identifier and the schema is empty.
+ */
+export declare function splitTableName(name: string, bracketType: number): [schema: string, table: string];
+/**
+ * The part of a table name that automatic constraint and index names take, one
+ * pair of brackets or quotes off where unquoted, so sales.users and
+ * [sales].[users] give PK_users, which every database reads as one identifier.
+ */
+export declare function tableNamePart(name: string, bracketType: number): string;
+/**
+ * Whether a database's DDL builds automatic names from tableNamePart: the six
+ * generators that read an unquoted dot as a schema do, while Databricks and
+ * Snowflake write the whole table name into them.
+ */
+export declare function splitsTableName(database: number): boolean;
 export declare function orderByNameASC<T extends {
     name: string;
-}>(a: T, b: T): 1 | -1 | 0;
+}>(a: T, b: T): 0 | 1 | -1;
 export declare function autoName<T extends {
     id: string;
     name: string;
 }>(list: T[], id: string, name: string, num?: number): string;
+/**
+ * autoName for an automatic foreign key or index name, also numbering a name
+ * equal to an earlier one but for case, quoted or not, since the databases fold
+ * an unquoted name and MySQL and MariaDB a quoted index name too.
+ */
+export declare function autoNameIgnoreCase(names: Name[], name: string): string;
 export declare function toOrderName(orderType: number): "" | "ASC" | "DESC";
 /** The actions a vendor accepts after ON DELETE and after ON UPDATE. */
 export type ReferentialActionSupport = {
@@ -72,4 +166,9 @@ export declare function referentialActionSupport(database: number): ReferentialA
  */
 export declare function formatReferentialActions({ onDelete, onUpdate }: Pick<Relationship, 'onDelete' | 'onUpdate'>, support: ReferentialActionSupport): string[];
 export declare function toStringLiteral(value: string): string;
+/**
+ * A column default as the DDL of a database writes it after DEFAULT: in
+ * parentheses where its grammar reads that expression only inside them.
+ */
+export declare function formatDefault(value: string, database: number, dataType?: string): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/stageCursor.d.ts

@@ -0,0 +1,20 @@
+/** The closed hand a pan shows for as long as it holds the canvas. */
+export declare const CURSOR_GRABBING = "grabbing";
+/**
+ * Points a stage container at a cursor. A konva node carries none of its own,
+ * so the container wears the one its hover asks for; under a hold the cursor
+ * is only noted, for the release to write back.
+ *
+ * @example
+ * setStageCursor(stage.container(), 'pointer');
+ */
+export declare function setStageCursor(container: HTMLElement, cursor: string): void;
+/**
+ * Keeps a stage container on a cursor for a gesture, whatever the pointer runs
+ * over, and hands back the release that shows what the last hover asked for.
+ *
+ * @example
+ * drag$.subscribe(handleMove).add(holdStageCursor(container, CURSOR_GRABBING));
+ */
+export declare function holdStageCursor(container: HTMLElement, cursor: string): () => void;
+//# sourceMappingURL=stageCursor.d.ts.map

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

@@ -1,6 +1,8 @@
 import { Memo, Point, Settings, Table } from '../../internal-types';
 export type PlacementEntity = {
     sourceId: string;
+    /** A memo stacks over a table of the same z-index, as the scene paints them; a table if left out. */
+    kind?: 'table' | 'memo';
     ui: {
         x: number;
         y: number;

package/dist/utils/tableColor.d.ts

@@ -0,0 +1,29 @@
+/** The colors AML names, each the 500 shade of its Tailwind palette, in AML's order. */
+export declare const AML_COLORS: Readonly<Record<string, string>>;
+/** A DBML headercolor kept as written when it is #rgb or #rrggbb, else ''. */
+export declare function fromDBMLColor(value: string): string;
+/**
+ * One of AML's color names, in any letter case, as its hex; a #rgb, #rrggbb
+ * or #rrggbbaa as written; else ''.
+ */
+export declare function fromAMLColor(value: string): string;
+/**
+ * A table color as DBML's headercolor writes it, which takes #rgb or #rrggbb
+ * alone: a hex keeps its digits less any alpha, and an rgb() or hsl() becomes
+ * its hex. A color that reads as neither is null.
+ */
+export declare function toDBMLColor(color: string): string | null;
+/**
+ * The AML name of a table color, null for one it cannot read: gray under the
+ * gray chroma, else the other name nearest in OKLCH hue around the circle by
+ * its 500 shade, first in AML's order on a tie, so a named hex finds its name.
+ */
+export declare function toAMLColor(color: string): string | null;
+/**
+ * A color as an opaque lower-case #rrggbb, any alpha dropped: a hex of 3, 4, 6
+ * or 8 digits, an rgb(), rgba(), hsl() or hsla(); null for one it cannot read.
+ */
+export declare function toOpaqueHex(color: string): string | null;
+/** An sRGB channel of 0 to 255 as linear light of 0 to 1. */
+export declare function toLinear(channel: number): number;
+//# sourceMappingURL=tableColor.d.ts.map

package/dist/utils/tableGroup.d.ts

@@ -0,0 +1,142 @@
+import { RootState } from '../engine/state';
+import { Point, Table, TableGroup } from '../internal-types';
+import { Rect } from '../konva/scene/metrics';
+import { GeometrySource } from './draw-relationship/geometrySource';
+export type TableGroupRectOptions = {
+    /** Tables the box leaves out though they are members, the ones a drag holds. */
+    excludeTableIds?: ReadonlyArray<string>;
+};
+/** A group's box options, and the members it is read from when the caller holds them. */
+export type TableGroupMemberOptions = TableGroupRectOptions & {
+    /** The group's member tables, which spares a walk over every table of the document. */
+    members?: ReadonlyArray<Table>;
+};
+/**
+ * The group a table is in, or '' for none: a groupId naming no group the
+ * document lists reads as none, whatever the table saved.
+ */
+export declare function getTableGroupId({ doc }: RootState, table: Table): string;
+/** The ids of the tables a group holds, in document order; none for a group the document does not list. */
+export declare function getTableGroupMemberIds(state: RootState, groupId: string): string[];
+/**
+ * A rect grown by the padding on every side and by the title bar on top too,
+ * so the bar a group draws along the top of its box clears what it holds.
+ */
+export declare function padRect(rect: Rect, padding?: number): Rect;
+/**
+ * The box a group is drawn and hit in: its stored rect united with each member
+ * table's rect and the padding around it, title bar included, so a member that
+ * grows never sticks out and nothing is written for it.
+ *
+ * @example
+ * const box = getTableGroupRect(state, group, { excludeTableIds: dragged });
+ */
+export declare function getTableGroupRect(state: RootState, group: TableGroup, { excludeTableIds, members, }?: TableGroupMemberOptions): Rect;
+/**
+ * Each group's box seeded at its stored rect, keyed by id, for one walk over
+ * the tables to grow with growTableGroupBox: every box out of one pass, where
+ * a box apiece walks every table once per group.
+ */
+export declare function seedTableGroupBoxes(groups: ReadonlyArray<TableGroup>): Map<string, Rect>;
+/**
+ * Grows the box of the group a table names by the table's rect and padding; a
+ * table naming no seeded group, a removed one among them, grows none.
+ */
+export declare function growTableGroupBox(boxes: Map<string, Rect>, table: Table, rect: Rect): void;
+/**
+ * The box of every group the document lists, keyed by id, each as
+ * getTableGroupRect reads it, out of one walk over the tables.
+ *
+ * @example
+ * const boxes = getTableGroupRects(state, { excludeTableIds: dragged });
+ */
+export declare function getTableGroupRects(state: RootState, { excludeTableIds }?: TableGroupRectOptions): Map<string, Rect>;
+/**
+ * The member tables of every group the document lists, keyed by id, each list
+ * in document order, out of one walk over the tables; a group with no member
+ * is left out.
+ */
+export declare function getTableGroupMembers(state: RootState): Map<string, Table[]>;
+/**
+ * The rect a group made from tables takes: their bounds and the padding around
+ * them, or null for no table the document lists.
+ */
+export declare function getTablesGroupRect(state: RootState, tableIds: ReadonlyArray<string>): Rect | null;
+/** A group and the rect a placement gives it. */
+export type TableGroupWrap = Rect & {
+    id: string;
+};
+/**
+ * The rect each listed group with a member takes once every table named stands
+ * at its point: its members' bounds and the padding, what an automatic
+ * placement writes. A group with no member keeps its rect and is left out.
+ *
+ * @example
+ * const resizes = getTableGroupWraps(state, points).map(resizeTableGroupAction);
+ */
+export declare function getTableGroupWraps(state: RootState, points?: ReadonlyArray<Point & {
+    id: string;
+}>): TableGroupWrap[];
+/** The centre of a table's box, the point every membership test reads. */
+export declare function getTableCenter(state: RootState, table: Table): Point;
+/** Whether the point lies in the rect, its edges included. */
+export declare function isPointInRect({ x, y }: Point, rect: Rect): boolean;
+/**
+ * The topmost group whose box holds the point: the highest zIndex, and of two
+ * at one the later in doc.tableGroupIds, the one drawn over the other. Null
+ * where no group's box reaches.
+ *
+ * @example
+ * const group = findTableGroupAt(state, getTableCenter(state, table));
+ */
+export declare function findTableGroupAt(state: RootState, point: Point, options?: TableGroupRectOptions): TableGroup | null;
+/** Where findTableGroupsAt reads the boxes: built from the tables, or handed in built. */
+export type TableGroupFindOptions = TableGroupRectOptions & {
+    /** Every group's box, keyed as getTableGroupRects keys them, read in place of building them. */
+    boxes?: ReadonlyMap<string, Rect>;
+};
+/**
+ * The topmost group at each point, as findTableGroupAt finds it, every box
+ * read once for all of them, which a drag of many tables asks every step; no
+ * point, and no box is built.
+ *
+ * @example
+ * const groups = findTableGroupsAt(state, centers, { excludeTableIds: ids });
+ */
+export declare function findTableGroupsAt(state: RootState, points: ReadonlyArray<Point>, { boxes, ...options }?: TableGroupFindOptions): Array<TableGroup | null>;
+/** The zIndex that lifts a group over every other group, tables and memos aside. */
+export declare const nextTableGroupZIndex: (groups: TableGroup[]) => number;
+/**
+ * Whether the document shows its groups, boxes and header colors alike. The
+ * bit hides them, so a document saved before groups existed shows them.
+ */
+export declare const isTableGroupShown: ({ settings }: RootState) => boolean;
+/** A group's color as an opaque hex and the black or white text drawn over it. */
+export type TableGroupColors = {
+    background: string;
+    foreground: string;
+};
+/**
+ * The colors a group paints with, or null for a group with no color or one
+ * toOpaqueHex cannot read, which the neutral theme colors paint instead.
+ */
+export declare function getTableGroupColors(group: TableGroup): TableGroupColors | null;
+/**
+ * The colors a member table's header takes from its group, or null where it
+ * keeps its own: in a view, while groups are hidden, out of any group, or in
+ * a group with no color it can read.
+ *
+ * @example
+ * const tint = getTableHeaderTint(state, table, source);
+ */
+export declare function getTableHeaderTint(state: RootState, table: Table, source?: GeometrySource): TableGroupColors | null;
+/**
+ * The colors a header takes from the group named, one already read as listed ('' for none), as
+ * getTableHeaderTint decides them: a scene naming each table's group off one read of the list hands
+ * it here, so a group coming or going re-renders no table it does not reach.
+ *
+ * @example
+ * const tint = getTableGroupTint(state, props.tableGroupId, source);
+ */
+export declare function getTableGroupTint(state: RootState, groupId: string, source?: GeometrySource): TableGroupColors | null;
+//# sourceMappingURL=tableGroup.d.ts.map

package/dist/utils/tableKeys.d.ts

@@ -19,17 +19,25 @@ export type ColumnKey = {
     name: string;
     columnIds: string[];
 };
-/** One alternate key: a unique index of the table and the columns it keys, in key order. */
-export type AlternateKey = {
+/** A unique index of the table and the columns of the table it keys, in key order. */
+export type UniqueIndexKey = {
     indexId: string;
     columnIds: string[];
 };
+/** One alternate key: a unique index over two or more of the table's columns. */
+export type AlternateKey = UniqueIndexKey;
 /**
  * The keys a table's columns declare, primary key first and then each unique
  * column in column order. Only the columns edit them, so a list showing them
  * beside the index entities shows them read only.
  */
-export declare function getColumnKeys({ collections }: KeyState, table: Table): ColumnKey[];
+export declare function getColumnKeys({ collections, settings }: Pick<RootState, 'collections' | 'settings'>, table: Table): ColumnKey[];
+/**
+ * Each unique index of the table in index list order, with the columns of the
+ * table it keys in key order: over two or more an alternate key, over one the
+ * unique key of that column.
+ */
+export declare function getUniqueIndexKeys(state: KeyState, table: Table): UniqueIndexKey[];
 /**
  * The table's alternate keys, AK1 first: its unique indexes over two or more
  * of its columns, ordered by where those columns stand in the table. Neither

package/dist/workers/elkLayout.shared-worker.js

@@ -1 +1 @@
-import*as e from"comlink";typeof document>`u`&&Reflect.set(globalThis,`document`,{});const t={force:`force`,layeredHorizontal:`layeredHorizontal`,layeredVertical:`layeredVertical`,flow:`flow`,viewLayered:`viewLayered`};t.force;function n(e){return e!==t.force}function r(e){return e===t.flow}const i={"elk.algorithm":`layered`,"elk.layered.spacing.baseValue":`40`,"elk.spacing.componentComponent":`80`,"elk.layered.spacing.edgeNodeBetweenLayers":`120`,"elk.layered.considerModelOrder.strategy":`PREFER_EDGES`,"elk.layered.crossingMinimization.forceNodeModelOrder":`true`,"elk.layered.mergeEdges":`true`,"elk.layered.nodePlacement.strategy":`INTERACTIVE`,"elk.layered.layering.strategy":`INTERACTIVE`},a={"elk.alignment":`LEFT`},o={"elk.aspectRatio":`0.5625`},s={"elk.spacing.nodeNode":`80`,"elk.separateConnectedComponents":`true`,"elk.spacing.componentComponent":`160`},c=e=>({...s,"elk.algorithm":`layered`,"elk.direction":e,"elk.layered.spacing.nodeNodeBetweenLayers":`160`,"elk.layered.cycleBreaking.strategy":`DEPTH_FIRST`});function l(e){switch(e){case t.layeredHorizontal:return c(`RIGHT`);case t.layeredVertical:return c(`DOWN`);case t.flow:return{...c(`RIGHT`),"elk.layered.nodePlacement.strategy":`SIMPLE`,"elk.layered.spacing.edgeNodeBetweenLayers":`80`};case t.viewLayered:return{...i}}}function u(e){return e===t.viewLayered?{...a}:null}const d=[...new Set(Object.values(t).filter(n).map(e=>l(e)[`elk.algorithm`]))],f=`EAST`,p=e=>`edge-${e}-source`,m=e=>`edge-${e}-target`;function h(e,t){return e.side===t.side?e.side===f?e.row-t.row:t.row-e.row:e.side===f?-1:1}function g(e){let t=/* @__PURE__ */ new Map,n=(e,n)=>{let r=t.get(e);r?r.push(n):t.set(e,[n])};return e.forEach((e,t)=>{n(e.source,{id:p(t),row:e.sourceRow,side:f}),n(e.target,{id:m(t),row:e.targetRow,side:`WEST`})}),new Map([...t].map(([e,t])=>[e,t.sort(h).map(({id:e,side:t})=>({id:e,width:8,height:8,layoutOptions:{"elk.port.side":t}}))]))}function _({placement:e,nodes:t,edges:n}){let i=r(e)?g(n):null;return{id:`root`,layoutOptions:l(e),children:t.map(t=>v(t,e,i)),edges:n.map(({source:e,target:t},n)=>({id:`edge-${n}`,sources:[i?p(n):e],targets:[i?m(n):t]}))}}function v({id:e,width:t,height:n,x:r,y:i,children:a},s,c){if(a?.length)return{id:e,width:t,height:n,layoutOptions:{...o},children:a.map(e=>v(e,s,c))};let l={...u(s),...c?{"elk.portConstraints":`FIXED_ORDER`}:{}};return{id:e,width:t,height:n,...r===void 0?{}:{x:r},...i===void 0?{}:{y:i},...Object.keys(l).length?{layoutOptions:l}:{},...c?{ports:c.get(e)??[]}:{}}}function y(e,t,n){return e.flatMap(({id:e,x:r,y:i,children:a})=>{let o=t+(r??0),s=n+(i??0);return a?.length?y(a,o,s):[{id:e,x:o,y:s}]})}let b=null;function x(){return b??=import(`elkjs/lib/elk.bundled.js`).then(({default:e})=>new e({algorithms:d})),b}const S=new class{async ready(){return await x(),!0}async layout(e){return y((await(await x()).layout(_(e))).children??[],0,0)}};self.onconnect=t=>{let n=t.ports[0];e.expose(S,n)};
+import*as e from"comlink";typeof document>`u`&&Reflect.set(globalThis,`document`,{});const t={force:`force`,layeredHorizontal:`layeredHorizontal`,layeredVertical:`layeredVertical`,flow:`flow`,viewLayered:`viewLayered`};t.force;function n(e){return e!==t.force}function r(e){return e===t.flow}const i={"elk.padding":`[top=52,left=24,bottom=24,right=24]`},a={"elk.padding":`[top=0,left=0,bottom=0,right=0]`,"elk.hierarchyHandling":`INCLUDE_CHILDREN`},o={"elk.algorithm":`layered`,"elk.layered.spacing.baseValue":`40`,"elk.spacing.componentComponent":`80`,"elk.layered.spacing.edgeNodeBetweenLayers":`120`,"elk.layered.considerModelOrder.strategy":`PREFER_EDGES`,"elk.layered.crossingMinimization.forceNodeModelOrder":`true`,"elk.layered.mergeEdges":`true`,"elk.layered.nodePlacement.strategy":`INTERACTIVE`,"elk.layered.layering.strategy":`INTERACTIVE`},s={"elk.alignment":`LEFT`},c={"elk.aspectRatio":`0.5625`},l={"elk.spacing.nodeNode":`80`,"elk.separateConnectedComponents":`true`,"elk.spacing.componentComponent":`160`},u=e=>({...l,"elk.algorithm":`layered`,"elk.direction":e,"elk.layered.spacing.nodeNodeBetweenLayers":`160`,"elk.layered.cycleBreaking.strategy":`DEPTH_FIRST`});function d(e){switch(e){case t.layeredHorizontal:return u(`RIGHT`);case t.layeredVertical:return u(`DOWN`);case t.flow:return{...u(`RIGHT`),"elk.layered.nodePlacement.strategy":`SIMPLE`,"elk.layered.spacing.edgeNodeBetweenLayers":`80`};case t.viewLayered:return{...o}}}function f(e){return e===t.viewLayered?{...s}:null}function p(e,t){switch(t){case`tableGroup`:return{...d(e),...i};case`component`:return{...d(e),...a};default:return{...c}}}const m=[...new Set(Object.values(t).filter(n).map(e=>d(e)[`elk.algorithm`]))],h=`EAST`,g=e=>`edge-${e}-source`,_=e=>`edge-${e}-target`;function v(e,t){return e.side===t.side?e.side===h?e.row-t.row:t.row-e.row:e.side===h?-1:1}function y(e){let t=/* @__PURE__ */ new Map,n=(e,n)=>{let r=t.get(e);r?r.push(n):t.set(e,[n])};return e.forEach((e,t)=>{n(e.source,{id:g(t),row:e.sourceRow,side:h}),n(e.target,{id:_(t),row:e.targetRow,side:`WEST`})}),new Map([...t].map(([e,t])=>[e,t.sort(v).map(({id:e,side:t})=>({id:e,width:8,height:8,layoutOptions:{"elk.port.side":t}}))]))}function b(e,t=/* @__PURE__ */ new Map){return e.forEach(({id:e,children:n=[]})=>{n.forEach(n=>t.set(n.id,e)),b(n,t)}),t}function x(e,t){let n=[];for(let r=e.get(t);r;r=e.get(r))n.push(r);return n}function S(e,t,n){let r=new Set(x(e,t));return x(e,n).find(e=>r.has(e))??null}function C({placement:e,nodes:t,edges:n}){let i=r(e)?y(n):null,a=b(t),o=/* @__PURE__ */ new Map;return n.forEach(({source:e,target:t},n)=>{let r=S(a,e,t),s={id:`edge-${n}`,sources:[i?g(n):e],targets:[i?_(n):t]},c=o.get(r);c?c.push(s):o.set(r,[s])}),{id:`root`,layoutOptions:d(e),children:t.map(t=>w(t,e,i,o)),edges:o.get(null)??[]}}function w({id:e,width:t,height:n,x:r,y:i,children:a,kind:o},s,c,l){if(a?.length){let r=l.get(e);return{id:e,width:t,height:n,layoutOptions:p(s,o),children:a.map(e=>w(e,s,c,l)),...r?{edges:r}:{}}}let u={...f(s),...c?{"elk.portConstraints":`FIXED_ORDER`}:{}};return{id:e,width:t,height:n,...r===void 0?{}:{x:r},...i===void 0?{}:{y:i},...Object.keys(u).length?{layoutOptions:u}:{},...c?{ports:c.get(e)??[]}:{}}}function T(e,t,n){return e.flatMap(({id:e,x:r,y:i,children:a})=>{let o=t+(r??0),s=n+(i??0);return a?.length?T(a,o,s):[{id:e,x:o,y:s}]})}let E=null;function D(){return E??=import(`elkjs/lib/elk.bundled.js`).then(({default:e})=>new e({algorithms:m})),E}const O=new class{async ready(){return await D(),!0}async layout(e){return T((await(await D()).layout(C(e))).children??[],0,0)}};self.onconnect=t=>{let n=t.ports[0];e.expose(O,n)};