@dineug/erd-editor 3.10.0 → 4.1.0

package/dist/peer/index.d.ts

@@ -1,5 +1,5 @@
-export { COLUMN_MIN_WIDTH, MEMO_MIN_HEIGHT, MEMO_MIN_WIDTH, } from '../constants/layout';
-export { BracketType, CanvasType, ColumnOption, ColumnType, Database, Language, NameCase, OrderType, ReferentialAction, RelationshipType, SaveSettingType, Show, } from '../constants/schema';
+export { MEMO_MIN_HEIGHT, MEMO_MIN_WIDTH, TABLE_GROUP_MIN_HEIGHT, TABLE_GROUP_MIN_WIDTH, } from '../constants/layout';
+export { BracketType, CanvasType, ColumnOption, ColumnType, Database, DDLScriptPosition, Language, LockSettingType, NameCase, OrderType, ReferentialAction, RelationshipType, Show, } from '../constants/schema';
 export { type DatabaseVendor, DatabaseVendorList, DatabaseVendorToDatabase, } from '../constants/sql/database';
 export { type ActionType, ChangeActionTypes, SharedFollowingActionTypes, StreamActionTypes, } from '../engine/actions';
 export { createEngineContext, type EngineContext } from '../engine/context';
@@ -20,10 +20,13 @@ export { actions as tableActions } from '../engine/modules/table/atom.actions';
 export { actions$ as tableActions$ } from '../engine/modules/table/generator.actions';
 export { actions as tableColumnActions } from '../engine/modules/table-column/atom.actions';
 export { actions$ as tableColumnActions$ } from '../engine/modules/table-column/generator.actions';
+export { actions as tableGroupActions } from '../engine/modules/table-group/atom.actions';
+export { actions$ as tableGroupActions$ } from '../engine/modules/table-group/generator.actions';
 export { createPeerStore, type DispatchFocus, type DispatchOptions, type DispatchReport, type PeerStore, PeerStoreError, PeerStoreErrorCode, type PeerStoreOptions, type RevertResult, } from '../engine/peer-store';
 export type { RootState } from '../engine/state';
 export { defaultToWidth } from '../engine/to-width';
 export { bHas } from '../utils/bit';
 export { measureTableSize } from '../utils/calcTable';
-export { createSchemaSQL } from '../utils/schema-sql';
+export { createSchemaSQL, SchemaSQLHeaderList, type SchemaSQLOptions, SchemaSQLStatementsList, } from '../utils/schema-sql';
+export { getTablesGroupRect } from '../utils/tableGroup';
 //# sourceMappingURL=index.d.ts.map

package/dist/peer/index.js

@@ -1,61 +1,62 @@
-import { D as e, Ea as t, Ia as n, Jn as r, K as i, Kt as a, L as o, La as s, Ln as ee, Ma as c, N as l, Na as u, Nn as d, Oi as f, On as p, Pa as m, Qn as h, R as g, Ra as _, Rt as v, T as y, Ta as b, Tn as x, U as S, Ui as C, Va as w, Vi as T, Wa as E, Xn as D, Zn as te, _ as O, _a as k, an as A, ba as j, bn as M, ca as ne, dn as re, hn as ie, ja as ae, ka as N, kn as P, mr as F, nt as I, sa as L, sr as R, t as z, ui as B, un as V, va as H, wa as U, x as W, xa as G, y as K, ya as q } from "../loadValue-Mdc5K4qO.js";
-import { c as J, d as oe, f as se, l as ce, n as le, t as ue } from "../shared-store-D82WVL5a.js";
+import { $ as e, B as t, C as n, Cn as r, F as i, Fn as a, Fr as o, Go as s, Ho as c, Jn as ee, Ma as l, Mo as u, On as d, P as f, Pa as p, Po as m, Pt as h, Qo as g, Rn as _, U as v, Un as y, Uo as b, Ut as x, Vo as S, Wo as C, Xo as w, Zo as T, as as E, dr as D, es as O, f as k, fs as A, gs as j, hn as M, is as te, ji as ne, jo as re, k as ie, ln as ae, lr as N, ls as P, m as F, mn as I, ms as L, os as R, qi as z, qo as B, rs as V, sr as H, ss as U, t as W, ts as G, u as K, ur as q, us as J, vn as oe, vo as se, wt as ce, x as le, xr as ue, yo as de, zn as fe } from "../loadValue-BKvXDYoC.js";
+import { d as pe, f as me, h as he, m as ge, n as _e, t as ve } from "../shared-store-2IUOt99m.js";
 //#region src/engine/presence.ts
-var de = d / 3, fe = (e) => {
+var ye = y / 3, be = (e) => {
 	e?.unref?.();
-}, pe = [
+}, xe = [
 	"sharedMouseTrackerMap",
 	"sharedFocusTrackerMap",
 	"sharedSelectionTrackerMap",
 	"sharedDragSelectTrackerMap"
 ];
-function me(e) {
-	for (let t of pe) {
+function Se(e) {
+	for (let t of xe) {
 		let n = e[t];
 		for (let e of Object.keys(n)) clearTimeout(n[e].timeoutId), Reflect.deleteProperty(n, e);
 	}
 }
-function he(e) {
+function Ce(e) {
 	let t = "", n = (n) => {
-		let r = J(e.state.editor.focusTable), i = ce(r);
-		(i !== t || n) && (t = i, e.dispatch(R({ focus: r })));
+		let r = pe(e.state.editor.focusTable), i = me(r);
+		(i !== t || n) && (t = i, e.dispatch(ue({ focus: r })));
 	}, r = e.subscribe((e) => {
-		n(e.some((e) => e.type === h.type));
+		n(e.some((e) => e.type === D.type));
 	}), i = setInterval(() => {
 		t && n(!0);
-	}, de);
-	return fe(i), Object.freeze({ destroy: () => {
+	}, ye);
+	return be(i), Object.freeze({ destroy: () => {
 		r(), clearInterval(i);
 	} });
 }
 //#endregion
 //#region src/engine/stream-flush.ts
-function ge(e, t) {
+function we(e, t) {
 	return Object.freeze({ flush: () => {
 		e.flushStreamBuffers(), t.flushStreamBuffers();
 	} });
 }
 //#endregion
 //#region src/engine/to-width.ts
-var _e = 2, Y = 10, X = (e) => Math.round(e.length * Y) + _e, Z = {
+var Y = 2, Te = 10, X = (e) => Math.round(e.length * Te) + Y, Z = {
 	readonly: "readonly",
 	destroyed: "destroyed"
-}, ve = {
+}, Ee = {
 	readonly: "the document is readonly, so no edit was made",
 	destroyed: "this document session was closed; open the document again"
 }, Q = class extends Error {
 	constructor(e, t) {
-		super(ve[e]), K(this, "code", void 0), K(this, "operation", void 0), this.name = "PeerStoreError", this.code = e, this.operation = t;
+		super(Ee[e]), k(this, "code", void 0), k(this, "operation", void 0), this.name = "PeerStoreError", this.code = e, this.operation = t;
 	}
-}, $ = k(W), ye = k(e), be = k([
+}, $ = S(F), De = S(n), Oe = S([
 	"table.add",
 	"column.add",
 	"memo.add",
 	"index.add",
 	"indexColumn.add",
-	"relationship.add"
+	"relationship.add",
+	"tableGroup.add"
 ]);
-function xe(e) {
+function ke(e) {
 	let t = 0, n = 0;
 	return {
 		history: Object.freeze({
@@ -82,64 +83,67 @@ function xe(e) {
 		getLimit: () => n
 	};
 }
-function Se(e) {
+function Ae(e) {
 	if (!e) return [];
-	let { tableId: t, columnId: n, focusType: i } = e;
-	return n === void 0 ? [D({
+	let { tableId: t, columnId: n, focusType: r } = e;
+	return n === void 0 ? [N({
 		tableId: t,
-		focusType: i
-	})] : [r({
+		focusType: r
+	})] : [H({
 		tableId: t,
 		columnId: n,
-		focusType: i,
+		focusType: r,
 		$mod: !1,
 		shiftKey: !1
 	})];
 }
-function Ce({ nickname: e, toWidth: t = X, presence: n = !0, readonly: r = !1 }) {
-	let i = null, a = oe(O({ toWidth: t }), {
+function je({ nickname: t, toWidth: n = X, presence: r = !0, readonly: i = !1 }) {
+	let a = null, o = ge(K({
+		toWidth: n,
+		routes: !1
+	}), {
 		manualStreamFlush: !0,
 		observable: !1,
-		getHistory: (e) => (i = xe(se(e)), i.history)
-	}), o = () => i?.getPushes() ?? 0, s = () => i?.getLimit() ?? 0, c = ue(a, { getNickname: () => e }, { manualStreamFlush: !0 }), l = ge(a, c), u = /* @__PURE__ */ new Set(), d = a.state.editor.id, f = r, p = !1, m = null, g = !1, _ = 0, v = [], y = [], b = null;
-	a.dispatchSync(ee({
+		getHistory: (e) => (a = ke(he(e)), a.history)
+	}), s = () => a?.getPushes() ?? 0, c = () => a?.getLimit() ?? 0, l = ve(o, { getNickname: () => t }, { manualStreamFlush: !0 }), u = we(o, l), d = /* @__PURE__ */ new Set(), f = o.state.editor.id, p = i, m = !1, h = null, g = !1, _ = 0, v = [], y = [], b = null;
+	o.dispatchSync(ee({
 		width: 0,
 		height: 0
 	}));
-	let x = n ? he(a) : null, S = () => {
-		m ||= c.subscribe((e) => {
+	let x = r ? Ce(o) : null, S = () => {
+		h ||= l.subscribe((e) => {
 			e.some((e) => $(e.type)) && _++;
-			for (let t of Array.from(u)) V(t, e);
+			for (let t of Array.from(d)) I(t, e);
 		});
 	}, C = (e) => {
-		if (p) throw new Q(Z.destroyed, e);
-	}, T = (e) => {
+		if (m) throw new Q(Z.destroyed, e);
+	}, w = (e) => {
 		if (b) throw Error(`${e} cannot run inside a group`);
-	}, D = (e) => {
-		if (C(e), f) throw new Q(Z.readonly, e);
-	}, k = () => {
-		let e = s();
+	}, T = (e) => {
+		if (C(e), p) throw new Q(Z.readonly, e);
+	}, E = () => {
+		let e = c();
 		if (!e) return;
 		let t = v.reduce((e, { historyEntries: t }) => e + t, 0);
 		for (; t > e;) t -= v.shift().historyEntries;
 		for (; v.length > e;) v.splice(v.findIndex(({ historyEntries: e }) => !e), 1);
-	}, A = (e, t = {}) => {
-		D("dispatch"), S();
-		let n = _, r = o(), i = E(a.state, a.context, [...Se(t.focus), ...e]);
-		a.dispatchSync(i), i.some((e) => ye(e.type)) && l.flush();
-		let s = {
+	}, O = (e, t = {}) => {
+		T("dispatch"), S();
+		let n = _, r = s(), i = j(o.state, o.context, [...Ae(t.focus), ...e]);
+		o.dispatchSync(i), i.some((e) => De(e.type)) && u.flush();
+		let a = {
 			label: t.label ?? null,
 			actions: i.filter((e) => $(e.type)),
-			createdIds: i.filter((e) => be(e.type)).map((e) => e.payload.id),
+			createdIds: i.filter((e) => Oe(e.type)).map((e) => e.payload.id),
 			batches: _ - n,
-			historyEntries: o() - r
+			historyEntries: s() - r
 		};
-		return b ? (b.unit.historyEntries += s.historyEntries, b.dispatched = !0) : v.push({
-			label: s.label,
-			historyEntries: s.historyEntries
-		}), s.historyEntries && (y = []), b || k(), s;
-	}, j = (e, t) => {
-		if (D("group"), b) return t();
+		return b ? (b.unit.historyEntries += a.historyEntries, b.dispatched = !0) : v.push({
+			label: a.label,
+			historyEntries: a.historyEntries
+		}), a.historyEntries && (y = []), b || E(), a;
+	}, k = (e, t) => {
+		if (T("group"), b) return t();
 		let n = {
 			unit: {
 				label: e,
@@ -151,45 +155,48 @@ function Ce({ nickname: e, toWidth: t = X, presence: n = !0, readonly: r = !1 })
 		try {
 			return t();
 		} finally {
-			b = null, n.dispatched && (v.push(n.unit), k());
+			b = null, n.dispatched && (v.push(n.unit), E());
 		}
 	}, M = (e, t) => {
 		for (let n = 0; n < e.historyEntries; n++) t();
-		l.flush();
+		u.flush();
 	};
 	return Object.freeze({
-		editorId: d,
+		editorId: f,
 		get value() {
-			return w(a.state);
+			return A(o.state);
+		},
+		get runtimeValue() {
+			return L(o.state);
 		},
 		get state() {
-			return a.state;
+			return o.state;
 		},
 		get isReadonly() {
-			return f;
+			return p;
 		},
 		get isDestroyed() {
-			return p;
+			return m;
 		},
 		setReadonly: (e) => {
-			f = e;
+			p = e;
 		},
-		setInitialValue: (e) => {
-			C("setInitialValue"), T("setInitialValue"), a.dispatchSync(te(), I(z(e))), a.resetHistory(), v = [], y = [];
+		setInitialValue: (t) => {
+			C("setInitialValue"), w("setInitialValue"), o.dispatchSync(q(), e(W(t))), o.resetHistory(), v = [], y = [];
 		},
 		mergeClock: (e) => {
-			a.context.clock.merge(e);
+			o.context.clock.merge(e);
 		},
-		dispatch: A,
+		dispatch: O,
 		receive: (e) => {
-			p || c.dispatchSync(e);
+			m || l.dispatchSync(e);
 		},
-		group: j,
+		group: k,
 		undo: () => {
-			D("undo"), T("undo"), S();
+			T("undo"), w("undo"), S();
 			let e = [], t = v.pop();
 			for (; t && !t.historyEntries;) t.label !== null && e.push(t.label), t = v.pop();
-			return t ? (M(t, a.undo), y.push(t), {
+			return t ? (M(t, o.undo), y.push(t), {
 				label: t.label,
 				entries: t.historyEntries,
 				skipped: e
@@ -200,9 +207,9 @@ function Ce({ nickname: e, toWidth: t = X, presence: n = !0, readonly: r = !1 })
 			};
 		},
 		redo: () => {
-			D("redo"), T("redo"), S();
+			T("redo"), w("redo"), S();
 			let e = y.pop();
-			return e ? (M(e, a.redo), v.push(e), {
+			return e ? (M(e, o.redo), v.push(e), {
 				label: e.label,
 				entries: e.historyEntries,
 				skipped: []
@@ -212,16 +219,16 @@ function Ce({ nickname: e, toWidth: t = X, presence: n = !0, readonly: r = !1 })
 				skipped: []
 			};
 		},
-		subscribe: (e) => (C("subscribe"), u.add(e), g || (g = !0, m ? a.dispatchSync(h()) : S()), () => {
-			u.delete(e);
+		subscribe: (e) => (C("subscribe"), d.add(e), g || (g = !0, h ? o.dispatchSync(D()) : S()), () => {
+			d.delete(e);
 		}),
 		flushStreamBuffers: () => {
-			p || l.flush();
+			m || u.flush();
 		},
 		destroy: () => {
-			p || (p = !0, x?.destroy(), m?.(), m = null, u.clear(), c.destroy(), a.destroy(), me(a.state.editor), v = [], y = []);
+			m || (m = !0, x?.destroy(), h?.(), h = null, d.clear(), l.destroy(), o.destroy(), Se(o.state.editor), v = [], y = []);
 		}
 	});
 }
 //#endregion
-export { G as BracketType, H as COLUMN_MIN_WIDTH, U as CanvasType, W as ChangeActionTypes, b as ColumnOption, t as ColumnType, N as Database, L as DatabaseVendorList, ne as DatabaseVendorToDatabase, T as FocusType, ae as Language, q as MEMO_MIN_HEIGHT, j as MEMO_MIN_WIDTH, c as NameCase, u as OrderType, Q as PeerStoreError, Z as PeerStoreErrorCode, m as ReferentialAction, n as RelationshipType, s as SaveSettingType, C as SelectType, y as SharedFollowingActionTypes, _ as Show, e as StreamActionTypes, f as bHas, O as createEngineContext, Ce as createPeerStore, le as createSchemaSQL, X as defaultToWidth, i as editorActions$, P as indexActions, S as indexActions$, p as indexColumnActions, g as indexColumnActions$, B as measureTableSize, x as memoActions, A as memoActions$, M as relationshipActions, o as relationshipActions$, F as settingsActions, l as settingsActions$, ie as tableActions, a as tableActions$, re as tableColumnActions, v as tableColumnActions$ };
+export { B as BracketType, w as CanvasType, F as ChangeActionTypes, T as ColumnOption, g as ColumnType, O as DDLScriptPosition, G as Database, se as DatabaseVendorList, de as DatabaseVendorToDatabase, u as FocusType, V as Language, te as LockSettingType, c as MEMO_MIN_HEIGHT, b as MEMO_MIN_WIDTH, E as NameCase, R as OrderType, Q as PeerStoreError, Z as PeerStoreErrorCode, U as ReferentialAction, P as RelationshipType, l as SchemaSQLHeaderList, p as SchemaSQLStatementsList, m as SelectType, le as SharedFollowingActionTypes, J as Show, n as StreamActionTypes, C as TABLE_GROUP_MIN_HEIGHT, s as TABLE_GROUP_MIN_WIDTH, re as bHas, K as createEngineContext, je as createPeerStore, _e as createSchemaSQL, X as defaultToWidth, v as editorActions$, ne as getTablesGroupRect, fe as indexActions, t as indexActions$, _ as indexColumnActions, i as indexColumnActions$, z as measureTableSize, a as memoActions, ae as memoActions$, d as relationshipActions, f as relationshipActions$, o as settingsActions, ie as settingsActions$, r as tableActions, x as tableActions$, oe as tableColumnActions, h as tableColumnActions$, M as tableGroupActions, ce as tableGroupActions$ };

package/dist/services/elk-layout/elkGraph.d.ts

@@ -1,6 +1,6 @@
 import { RootState } from '../../engine/state';
 import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
-import { ElkPlacement } from './elkLayoutOptions';
+import { ElkCompoundKind, ElkPlacement } from './elkLayoutOptions';
 export type ElkLayoutNode = {
     id: string;
     width: number;
@@ -14,6 +14,8 @@ export type ElkLayoutNode = {
     y?: number;
     /** What is laid out inside this node, which is what makes it a group rather than a table. */
     children?: ElkLayoutNode[];
+    /** What a node holding children stands for, left out for the box of unrelated tables. */
+    kind?: ElkCompoundKind;
 };
 /**
  * Which tables a request covers and what it measures them by. The source picks
@@ -52,9 +54,9 @@ export type ElkLayoutPoint = {
     y: number;
 };
 /**
- * What ELK is asked to place, at the sizes the source draws. Nodes carry a
- * hint of where they already stand where the placement reads one, and grouping
- * folds the tables no relationship reaches into one packed box.
+ * What ELK is asked to place, at the sizes the source draws, with a hint where
+ * the placement reads one. A document placement keeps each table group in a
+ * node, and grouping folds the tables no relationship reaches into one box.
  *
  * @example
  * createElkLayoutRequest(state, TablePlacement.viewLayered, { source: 'flow' });

package/dist/services/elk-layout/elkLayoutOptions.d.ts

@@ -15,6 +15,17 @@ export declare function usesPorts(placement: ElkPlacement): boolean;
  * edges alone, and a hint sent with one of those would be paid for and ignored.
  */
 export declare function usesCoordinateHints(placement: ElkPlacement): boolean;
+/**
+ * Whether the placement keeps each table group's members together inside a
+ * node of the group. The views draw no group, so their preset never does.
+ */
+export declare function keepsTableGroups(placement: ElkPlacement): boolean;
+/**
+ * What a node holding children stands for: a table group, drawn round its
+ * members, or a component, the groups and tables relationships join across
+ * group borders. Left out, it is the box of the tables joined to nothing.
+ */
+export type ElkCompoundKind = 'tableGroup' | 'component';
 /**
  * The box the tables joined to nothing are gathered in, told what the
  * reference tells its own and nothing besides: the ratio, under the layered
@@ -37,6 +48,15 @@ export declare function elkLayoutOptions(placement: ElkPlacement): LayoutOptions
  * const layoutOptions = elkNodeLayoutOptions(placement);
  */
 export declare function elkNodeLayoutOptions(placement: ElkPlacement): LayoutOptions | null;
+/**
+ * What a node holding children is told. A table group and a component lay their
+ * children out as the root is laid out, its spacing included, which ELK would
+ * otherwise take from its own defaults; the box of unrelated tables, the ratio.
+ *
+ * @example
+ * const layoutOptions = elkCompoundLayoutOptions(placement, node.kind);
+ */
+export declare function elkCompoundLayoutOptions(placement: ElkPlacement, kind?: ElkCompoundKind): LayoutOptions;
 /**
  * Every algorithm the placements name. ELK registers the metadata of these and
  * no others, so it is read off the options rather than listed: a placement

package/dist/services/elk-layout/elkLayoutService.d.ts

@@ -3,9 +3,9 @@ import { ElkLayoutEdge, ElkLayoutPoint, ElkLayoutRequest } from './elkGraph';
 /** One port per relationship endpoint, grouped by the table it sits on. */
 export declare function portsByNode(edges: ElkLayoutEdge[]): Map<string, ElkPort[]>;
 /**
- * The graph ELK is handed. An ERD nests no table in another, so the one node
- * that ever holds children is the group a request packs its unrelated tables
- * into, and every edge stays at the root whatever level its ends sit on.
+ * The graph ELK is handed: a table group holds its members, a component what is
+ * joined across group borders, the box the unrelated tables, and each edge sits
+ * in the deepest node holding both its ends, the root in a document with no group.
  */
 export declare function toElkGraph({ placement, nodes, edges, }: ElkLayoutRequest): ElkNode;
 /**

package/dist/services/export-png/ExportScene.d.ts

@@ -7,9 +7,9 @@ export type ExportSceneProps = {
     scale: number;
 };
 /**
- * Everything the document draws on one layer, with no culling. The zoom reaches
- * the image, in the scale the layer is placed at and in the spelling a table is
- * drawn with; the scroll and the viewport do not, so the whole document is held.
+ * Everything the document draws on one layer, the groups behind it all, with
+ * no culling and every table in full, as at the export's zoom. The scroll and
+ * the viewport do not reach it, so the whole document is held.
  */
 declare const ExportScene: FC<ExportSceneProps>;
 export default ExportScene;

package/dist/services/export-png/documentScene.d.ts

@@ -1,4 +1,5 @@
 import { Stage } from 'konva/lib/Stage';
+import { LocaleMessages } from '../../i18n/translate';
 import { Rect } from '../../konva/scene/metrics';
 import { Theme } from '../../themes/tokens';
 export type DocumentSceneOptions = {
@@ -6,10 +7,16 @@ export type DocumentSceneOptions = {
     theme: Theme;
     toWidth: (text: string) => number;
     /**
-     * The zoom to draw at, for a caller whose editor is at one the document does
-     * not carry. Left out, the document's own zoom is what the image is drawn at.
+     * The longest side the Stage may take, in pixels, which caps the scale below
+     * the export's zoom for a preview or for an svg read off the nodes. The store
+     * keeps that zoom all the same, so either holds the shapes the export does.
      */
-    zoomLevel?: number;
+    maxSide?: number;
+    /**
+     * The language and dictionary the scene's own words are drawn in, a table
+     * with no name say. Left out, the scene draws them in English.
+     */
+    i18n?: LocaleMessages;
 };
 export type DocumentScene = {
     stage: Stage;
@@ -17,17 +24,15 @@ export type DocumentScene = {
     box: Rect;
     /** The factor between that box and the Stage the scene was drawn on. */
     scale: number;
-    /** The zoom that was asked for, which scale is that cut to what a canvas holds. */
-    zoomLevel: number;
     destroy: () => void;
 };
 /**
- * The whole document on a Stage of its own, off any screen. The store is built
- * here rather than borrowed, so the editor's scroll and selection cannot reach
- * the image and it holds the whole document however it was being looked at.
+ * The whole document on a Stage of its own, off any screen, at the export's
+ * zoom. The store is built here rather than borrowed, so the editor's zoom,
+ * scroll and selection cannot reach the image, which holds the whole document.
  *
  * @example
  * const scene = await renderDocumentScene({ doc, theme, toWidth });
  */
-export declare function renderDocumentScene({ doc, theme, toWidth, zoomLevel, }: DocumentSceneOptions): Promise<DocumentScene>;
+export declare function renderDocumentScene({ doc, theme, toWidth, maxSide, i18n, }: DocumentSceneOptions): Promise<DocumentScene>;
 //# sourceMappingURL=documentScene.d.ts.map

package/dist/services/export-png/exportBox.d.ts

@@ -1,11 +1,17 @@
 import { RootState } from '../../engine/state';
 import { Rect } from '../../konva/scene/metrics';
+type Size = Pick<Rect, 'width' | 'height'>;
 /**
  * The breathing room around the drawn document, in scene units, and nothing
  * more: a connector measured against a retired sort epoch is already inflated
  * by getRouteBBox itself, and the union below holds that box before this is added.
  */
 export declare const EXPORT_MARGIN = 80;
+/**
+ * The zoom every export is drawn at, whatever the editor shows or the document
+ * was saved with: one image pixel per scene unit before the scale.
+ */
+export declare const EXPORT_ZOOM_LEVEL = 1;
 /**
  * Everything the image has to hold: every table and memo, every connector the
  * document is set to show, and the margin around the lot. An empty document is
@@ -16,12 +22,41 @@ export declare const EXPORT_MARGIN = 80;
  */
 export declare function getExportRect(state: RootState): Rect;
 /**
- * What the box is drawn at: the zoom the image was asked for, cut to whatever a
- * canvas can hold. A document is unbounded now, so this is what keeps the Stage
- * itself inside the ceiling that fitPixelRatio keeps the raster inside.
+ * What the box is drawn at: the export's zoom, cut to whatever a canvas can
+ * hold. A document is unbounded now, so this is what keeps the Stage itself
+ * inside the ceiling that fitPixelRatio keeps the raster inside.
+ *
+ * @example
+ * const scale = getExportScale(getExportRect(store.state));
+ */
+export declare function getExportScale({ width, height }: Rect): number;
+/** The raster an export comes out at, and the one it was asked for. */
+export type ExportSize = {
+    width: number;
+    height: number;
+    /** The box times the scale, which a canvas ceiling may cut. */
+    askedWidth: number;
+    askedHeight: number;
+    /** Whether a ceiling cut the raster below what was asked for. */
+    reduced: boolean;
+};
+/**
+ * The Stage a box drawn at the scale takes, a pixel each way at least: a canvas
+ * truncates a side under one to none, from which no image can be drawn, and a
+ * document far longer than it is thick is cut that thin by a preview's side.
+ *
+ * @example
+ * const { width, height } = getStageSize(box, scale);
+ */
+export declare function getStageSize(box: Size, scale: number): Size;
+/**
+ * The pixels a png of the box comes out at, worked out the way the render
+ * works them out: the Stage fitted to the ceilings first, then its raster at
+ * the scale. A dialog reads it to say what a file will hold before it exists.
  *
  * @example
- * const scale = getExportScale(getExportRect(store.state), settings.zoomLevel);
+ * const { width, height, reduced } = getExportSize(box, 2);
  */
-export declare function getExportScale({ width, height }: Rect, zoomLevel?: number): number;
+export declare function getExportSize(box: Size, pixelRatio: number): ExportSize;
+export {};
 //# sourceMappingURL=exportBox.d.ts.map

package/dist/services/export-png/exportPngService.d.ts

@@ -1,4 +1,5 @@
 import { RenderPngRequest, RenderPngResult } from './renderPng';
+import { RenderSvgRequest } from './renderSvg';
 /**
  * A png request as it crosses a realm boundary. The measurement itself cannot
  * cross, so what travels is the widths the asking realm read for the probe
@@ -7,6 +8,10 @@ import { RenderPngRequest, RenderPngResult } from './renderPng';
 export type ExportPngRequest = RenderPngRequest & {
     fontProbe: number[];
 };
+/** An svg request as it crosses a realm boundary, gated by the same probe. */
+export type ExportSvgRequest = RenderSvgRequest & {
+    fontProbe: number[];
+};
 /**
  * Draws a document off the thread that asked for it. Text is measured here
  * rather than sent, because a table's reserved widths were laid out by a
@@ -20,6 +25,16 @@ export declare class ExportPngService {
      */
     probeFontWidths(): Promise<number[]>;
     render(request: ExportPngRequest): Promise<RenderPngResult>;
+    /**
+     * The document as an svg, laid out by the same measure the png is. Its text
+     * is placed where this realm wrapped and cut it, so the probe gates it too.
+     */
+    renderSvg(request: ExportSvgRequest): Promise<string>;
+    /**
+     * This realm's measure, once it is shown to lay the probe out as the asking
+     * realm did. Every drawing a request asks for goes through it first.
+     */
+    private createMatchingToWidth;
     private createToWidth;
 }
 //# sourceMappingURL=exportPngService.d.ts.map

package/dist/services/export-png/exportTheme.d.ts

@@ -0,0 +1,26 @@
+import { ThemeOptions } from '../../themes/radix-ui-theme';
+import { Theme } from '../../themes/tokens';
+/** What the canvas is painted with once the background is off: nothing at all. */
+export declare const TRANSPARENT_BACKGROUND = "rgba(0,0,0,0)";
+export type ExportThemeOptions = {
+    /** The palette the canvas is painted with now, overrides included. */
+    sceneTheme: Theme;
+    /** The gray and accent the editor's preset is built from. */
+    themeOptions: Pick<ThemeOptions, 'grayColor' | 'accentColor'>;
+    /** Whether the editor shows its dark appearance now. */
+    isDarkMode: boolean;
+    /** Whether the image is drawn dark. */
+    darkMode: boolean;
+    /** Whether the image keeps the canvas colour behind what it draws. */
+    background: boolean;
+};
+/**
+ * The palette an image is drawn with. The appearance on screen keeps every
+ * colour the canvas shows, overrides included; the other one is the preset of
+ * the same gray and accent, since no override was ever written for it.
+ *
+ * @example
+ * const theme = createExportTheme({ sceneTheme, themeOptions, isDarkMode, darkMode, background });
+ */
+export declare function createExportTheme({ sceneTheme, themeOptions: { grayColor, accentColor }, isDarkMode, darkMode, background, }: ExportThemeOptions): Theme;
+//# sourceMappingURL=exportTheme.d.ts.map