@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/utils/map-columns/mapping.js

@@ -0,0 +1,41 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+//#region src/utils/map-columns/mapping.ts
+var toColumnMapping = ({ start, end }) => ({
+	start: start.columnIds,
+	end: end.columnIds
+});
+function getLiveTable({ doc, collections }, tableId) {
+	if (!doc.tableIds.includes(tableId)) return void 0;
+	return query(collections).collection("tableEntities").selectById(tableId);
+}
+function getLiveRelationship({ doc, collections }, relationshipId) {
+	if (!doc.relationshipIds.includes(relationshipId)) return void 0;
+	return query(collections).collection("relationshipEntities").selectById(relationshipId);
+}
+var isLiveColumn = (table, columnId) => !!table && table.columnIds.includes(columnId);
+function sameSet(a, b) {
+	const left = new Set(a);
+	const right = new Set(b);
+	return left.size === right.size && [...left].every((id) => right.has(id));
+}
+var sameMembers = (a, b) => a.length === b.length && new Set(a).size === a.length && new Set(b).size === b.length && sameSet(a, b);
+function repeatedIds(ids) {
+	const seen = /* @__PURE__ */ new Set();
+	const repeated = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		if (seen.has(id)) repeated.add(id);
+		seen.add(id);
+	}
+	return repeated;
+}
+var isNormalMapping = ({ start, end }) => start.length === end.length && new Set(start).size === start.length && new Set(end).size === end.length;
+var toPairKeys = ({ start, end }) => start.slice(0, Math.min(start.length, end.length)).map((id, index) => JSON.stringify([id, end[index]]));
+var samePairs = (a, b) => sameSet(toPairKeys(a), toPairKeys(b));
+function holdsPairs(relationship, mapping) {
+	const stored = toColumnMapping(relationship);
+	return isNormalMapping(stored) && samePairs(stored, mapping);
+}
+var toPickedColumnIds = (rows) => rows.flatMap(({ pick }) => pick?.kind === "existing" ? [pick.columnId] : []);
+var getUsedColumnIds = (rows, rowIndex) => new Set(toPickedColumnIds(rows.filter((_, index) => index !== rowIndex)));
+//#endregion
+export { getLiveRelationship, getLiveTable, getUsedColumnIds, holdsPairs, isLiveColumn, isNormalMapping, repeatedIds, sameMembers, samePairs, sameSet, toColumnMapping, toPickedColumnIds };

package/dist/utils/map-columns/prefill.js

@@ -0,0 +1,32 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { tableNamePart } from "../tableName.js";
+import { prefixKeyName, toNameKey } from "../../engine/modules/relationship/fkColumns.js";
+import { toPickedColumnIds } from "./mapping.js";
+//#region src/utils/map-columns/prefill.ts
+function toPrefillNames(tableName, columnName, bracketType, unique) {
+	const names = [prefixKeyName(tableName, columnName), prefixKeyName(tableNamePart(tableName, bracketType), columnName)];
+	if (unique) names.push(columnName);
+	return new Set(names.map(toNameKey).filter(Boolean));
+}
+function prefillPicks({ collections, settings }, { parentTable, childTable, keyKind, rows }) {
+	const columns = query(collections).collection("tableColumnEntities");
+	const childColumns = columns.selectByIds(childTable.columnIds);
+	const taken = new Set(toPickedColumnIds(rows));
+	const fills = {};
+	for (const { parentColumnId, pick } of rows) {
+		const parent = columns.selectById(parentColumnId);
+		if (pick || !parent) continue;
+		const names = toPrefillNames(parentTable.name, parent.name, settings.bracketType, keyKind === "unique");
+		const matches = childColumns.filter(({ id, name }) => id !== parent.id && !taken.has(id) && names.has(toNameKey(name)));
+		if (matches.length !== 1) continue;
+		const [{ id }] = matches;
+		taken.add(id);
+		fills[parentColumnId] = {
+			kind: "existing",
+			columnId: id
+		};
+	}
+	return fills;
+}
+//#endregion
+export { prefillPicks, toPrefillNames };

package/dist/utils/map-columns/toMapColumnsActions.js

@@ -0,0 +1,63 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { addRelationshipAction, changeRelationshipColumnsAction } from "../../engine/modules/relationship/atom.actions.js";
+import { toForeignKeyActions } from "../../engine/modules/relationship/fkColumns.js";
+import { toAlignTypeActions } from "./alignTypes.js";
+import { getLiveTable } from "./mapping.js";
+import { findColumnKey } from "./candidateKeys.js";
+import { getDraftEnds } from "./validate.js";
+//#region src/utils/map-columns/toMapColumnsActions.ts
+function orderRows(state, draft, startTableId) {
+	const startTable = getLiveTable(state, startTableId);
+	const key = startTable && draft.keyId !== null && draft.keyId !== "current" ? findColumnKey(state, startTable, draft.keyId) : void 0;
+	if (!key) return draft.rows;
+	return key.columnIds.flatMap((columnId) => draft.rows.filter(({ parentColumnId }) => parentColumnId === columnId));
+}
+function toMapColumnsActions(state, draft, createId) {
+	const ends = getDraftEnds(state, draft);
+	const startTable = ends && getLiveTable(state, ends.startTableId);
+	const endTable = ends && getLiveTable(state, ends.endTableId);
+	if (!ends || !startTable || !endTable) return [];
+	const columns = query(state.collections).collection("tableColumnEntities");
+	const rows = orderRows(state, draft, startTable.id);
+	const newParents = rows.flatMap(({ parentColumnId, pick }) => {
+		const parent = pick?.kind === "new" && parentColumnId !== null ? columns.selectById(parentColumnId) : void 0;
+		return parent ? [parent] : [];
+	});
+	const newColumnIds = newParents.map(() => createId());
+	const newIdOf = new Map(newParents.map(({ id }, index) => [id, newColumnIds[index]]));
+	const startColumnIds = rows.map(({ parentColumnId }) => parentColumnId ?? "");
+	const endColumnIds = rows.map(({ parentColumnId, pick }) => pick?.kind === "existing" ? pick.columnId : newIdOf.get(parentColumnId ?? "") ?? "");
+	const toEnds = () => ({
+		start: {
+			tableId: startTable.id,
+			columnIds: [...startColumnIds]
+		},
+		end: {
+			tableId: endTable.id,
+			columnIds: [...endColumnIds]
+		}
+	});
+	return [
+		...toForeignKeyActions(newParents, endTable.id, newColumnIds, {
+			startTableName: startTable.name,
+			endColumnNames: columns.selectByIds(endTable.columnIds).map(({ name }) => name),
+			database: state.settings.database,
+			domainIds: state.doc.domainIds
+		}),
+		...toAlignTypeActions(state, {
+			relationshipId: ends.relationship?.id,
+			...toEnds(),
+			newColumnIds
+		}),
+		draft.mode === "create" ? addRelationshipAction({
+			id: createId(),
+			relationshipType: draft.relationshipType,
+			...toEnds()
+		}) : changeRelationshipColumnsAction({
+			id: draft.relationshipId,
+			...toEnds()
+		})
+	];
+}
+//#endregion
+export { toMapColumnsActions };

package/dist/utils/map-columns/validate.js

@@ -0,0 +1,81 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { getLiveRelationship, getLiveTable, holdsPairs, isLiveColumn, isNormalMapping, repeatedIds, sameMembers, sameSet } from "./mapping.js";
+import { findColumnKey } from "./candidateKeys.js";
+//#region src/utils/map-columns/validate.ts
+function getDraftEnds({ collections }, draft) {
+	if (draft.mode === "create") return {
+		startTableId: draft.startTableId,
+		endTableId: draft.endTableId
+	};
+	const relationship = query(collections).collection("relationshipEntities").selectById(draft.relationshipId);
+	if (!relationship) return null;
+	return {
+		startTableId: relationship.start.tableId,
+		endTableId: relationship.end.tableId,
+		relationship
+	};
+}
+var toColumnIds = (rows) => ({
+	start: rows.map(({ parentColumnId }) => parentColumnId ?? ""),
+	end: rows.map(({ pick }) => pick?.kind === "existing" ? pick.columnId : "")
+});
+var isComplete = (rows) => rows.every(({ invalid, parentColumnId, pick }) => !invalid && parentColumnId !== null && pick?.kind === "existing");
+function validateRows(rows, startTable, endTable) {
+	const repeatedParents = repeatedIds(rows.flatMap(({ parentColumnId }) => parentColumnId === null ? [] : [parentColumnId]));
+	const claimed = /* @__PURE__ */ new Set();
+	return rows.map(({ parentColumnId, pick, invalid }) => {
+		if (invalid || parentColumnId === null) return "invalid";
+		if (repeatedParents.has(parentColumnId)) return "invalid";
+		if (!isLiveColumn(startTable, parentColumnId)) return "removedParent";
+		if (!pick) return "unpicked";
+		if (pick.kind === "new") return null;
+		if (!isLiveColumn(endTable, pick.columnId)) return "removedChild";
+		if (claimed.has(pick.columnId)) return "inUse";
+		claimed.add(pick.columnId);
+		return null;
+	});
+}
+function hasDuplicate({ doc, collections }, { startTableId, endTableId }, rows, relationshipId) {
+	const { start, end } = toColumnIds(rows);
+	return query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds).some((relationship) => relationship.id !== relationshipId && relationship.start.tableId === startTableId && relationship.end.tableId === endTableId && sameSet(relationship.start.columnIds, start) && sameSet(relationship.end.columnIds, end));
+}
+function validateMapping(state, draft) {
+	const ends = getDraftEnds(state, draft);
+	const startTable = ends ? getLiveTable(state, ends.startTableId) : void 0;
+	const endTable = ends ? getLiveTable(state, ends.endTableId) : void 0;
+	const { rows } = draft;
+	const set = [];
+	if (draft.keyId !== "current") {
+		const key = startTable && draft.keyId !== null ? findColumnKey(state, startTable, draft.keyId) : void 0;
+		const parentIds = rows.map(({ parentColumnId }) => parentColumnId);
+		if (!key || parentIds.includes(null) || !sameMembers(parentIds, key.columnIds)) set.push("noKey");
+	}
+	if (ends && rows.length && isComplete(rows)) {
+		if (ends.startTableId === ends.endTableId && rows.every(({ parentColumnId, pick }) => pick?.kind === "existing" && pick.columnId === parentColumnId)) set.push("selfOnly");
+		if (hasDuplicate(state, ends, rows, draft.mode === "edit" ? draft.relationshipId : void 0)) set.push("duplicate");
+	}
+	if (ends?.relationship && isComplete(rows) && holdsPairs(ends.relationship, toColumnIds(rows))) set.push("unchanged");
+	return {
+		rows: validateRows(rows, startTable, endTable),
+		set
+	};
+}
+var hasMappingIssues = ({ rows, set }, ignore = []) => rows.some(Boolean) || set.some((issue) => !ignore.includes(issue));
+function hasMappingTargets(state, draft) {
+	if (draft.mode === "edit" && !getLiveRelationship(state, draft.relationshipId)) return false;
+	const ends = getDraftEnds(state, draft);
+	return !!ends && !!getLiveTable(state, ends.startTableId) && !!getLiveTable(state, ends.endTableId);
+}
+function isSameResult(state, draft) {
+	const ends = getDraftEnds(state, draft);
+	if (!ends) return false;
+	const startTable = getLiveTable(state, ends.startTableId);
+	const endTable = getLiveTable(state, ends.endTableId);
+	const { rows } = draft;
+	const mapping = toColumnIds(rows);
+	if (!isComplete(rows) || !isNormalMapping(mapping) || !mapping.start.every((id) => isLiveColumn(startTable, id)) || !mapping.end.every((id) => isLiveColumn(endTable, id))) return false;
+	if (ends.relationship) return holdsPairs(ends.relationship, mapping);
+	return query(state.collections).collection("relationshipEntities").selectByIds(state.doc.relationshipIds).some((relationship) => relationship.start.tableId === ends.startTableId && relationship.end.tableId === ends.endTableId && holdsPairs(relationship, mapping));
+}
+//#endregion
+export { getDraftEnds, hasMappingIssues, hasMappingTargets, isSameResult, validateMapping };

package/dist/utils/memo.js

@@ -0,0 +1,6 @@
+import { Show } from "../constants/schema.js";
+import { bHas } from "./bit.js";
+//#region src/utils/memo.ts
+var isMemoShown = ({ settings }) => !bHas(settings.show, Show.hideMemo);
+//#endregion
+export { isMemoShown };

package/dist/utils/pinch.d.ts

@@ -18,6 +18,10 @@ export type Pinch = {
  * the step to take on every move after, or null to let the pinch go by.
  */
 export type PinchStart = (center: Point) => ((pinch: Pinch) => void) | null;
+export type PinchOptions = {
+    /** Whether the box takes a pinch at all; while not, the page keeps each. */
+    interactive?: () => boolean;
+};
 /**
  * The pinches a scene box takes besides the wheel: two fingers on a touch
  * screen, and Safari's trackpad pinch, which reaches a page as gesture events.
@@ -27,7 +31,7 @@ export type PinchStart = (center: Point) => ((pinch: Pinch) => void) | null;
  * const pinch = createPinch(() => root.value, center => step);
  * onMounted(() => addUnsubscribe(pinch.listen()));
  */
-export declare function createPinch(box: () => HTMLElement, start: PinchStart): {
+export declare function createPinch(box: () => HTMLElement, start: PinchStart, { interactive }?: PinchOptions): {
     handleTouchstart: (event: MouseEvent | TouchEvent) => boolean;
     listen: () => Subscription;
 };

package/dist/utils/pinch.js

@@ -0,0 +1,99 @@
+import { isMod } from "./keyboard-shortcut/index.js";
+import { isMultiTouch } from "./domEvent.js";
+import { moveEnd$, touchmove$ } from "./globalEventObservable.js";
+import { clamp } from "es-toolkit";
+import { Subscription, fromEvent, takeUntil } from "rxjs";
+//#region src/utils/pinch.ts
+var NOTCH_DELTA_MIN = 25;
+var PINCH_DELTA_MAX = 10;
+function isPinchWheel(event) {
+	if (!event.ctrlKey) return false;
+	return !isMod(event) || Math.abs(event.deltaY) < NOTCH_DELTA_MIN;
+}
+function pinchWheelScale({ deltaY }) {
+	const delta = clamp(deltaY, -10, PINCH_DELTA_MAX);
+	return Math.exp(-delta / 100);
+}
+function spreadOf(touches, box) {
+	if (touches.length < 2) return null;
+	const a = touches[0];
+	const b = touches[1];
+	return {
+		center: {
+			x: (a.clientX + b.clientX) / 2 - box.x,
+			y: (a.clientY + b.clientY) / 2 - box.y
+		},
+		distance: Math.hypot(b.clientX - a.clientX, b.clientY - a.clientY)
+	};
+}
+function createPinch(box, start, { interactive = () => true } = {}) {
+	let touch = null;
+	let gestureStep = null;
+	const touching = () => touch !== null && !touch.closed;
+	const pointIn = (event) => {
+		const { x, y, width, height } = box().getBoundingClientRect();
+		return Number.isFinite(event.clientX + event.clientY) ? {
+			x: event.clientX - x,
+			y: event.clientY - y
+		} : {
+			x: width / 2,
+			y: height / 2
+		};
+	};
+	const handleTouchstart = (event) => {
+		if (!isMultiTouch(event)) return false;
+		if (!interactive()) return true;
+		const rect = box().getBoundingClientRect();
+		const from = spreadOf(event.touches, rect);
+		const step = from && from.distance > 0 ? start(from.center) : null;
+		touch?.unsubscribe();
+		gestureStep = null;
+		if (!from || !step) return true;
+		touch = touchmove$.pipe(takeUntil(moveEnd$)).subscribe((move) => {
+			const to = spreadOf(move.touches, rect);
+			if (!to) return;
+			step({
+				scale: to.distance / from.distance,
+				center: to.center
+			});
+		});
+		return true;
+	};
+	const handleGesturestart = (event) => {
+		gestureStep = null;
+		if (!interactive()) return;
+		event.preventDefault();
+		gestureStep = touching() ? null : start(pointIn(event));
+	};
+	const handleGesturechange = (event) => {
+		if (!interactive()) return;
+		event.preventDefault();
+		if (!gestureStep || touching()) return;
+		gestureStep({
+			scale: event.scale,
+			center: pointIn(event)
+		});
+	};
+	const handleGestureend = (event) => {
+		if (interactive()) event.preventDefault();
+		gestureStep = null;
+	};
+	const listen = () => {
+		const $box = box();
+		const gesture$ = (type) => fromEvent($box, type);
+		const subscription = new Subscription(() => {
+			touch?.unsubscribe();
+			gestureStep = null;
+		});
+		subscription.add(gesture$("gesturestart").subscribe(handleGesturestart));
+		subscription.add(gesture$("gesturechange").subscribe(handleGesturechange));
+		subscription.add(gesture$("gestureend").subscribe(handleGestureend));
+		return subscription;
+	};
+	return {
+		handleTouchstart,
+		listen
+	};
+}
+//#endregion
+export { createPinch, isPinchWheel, pinchWheelScale };

package/dist/utils/promise.js

@@ -0,0 +1,16 @@
+//#region src/utils/promise.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function closePromise() {
+	let callback = () => {};
+	return [new Promise((resolve) => {
+		callback = resolve;
+	}), () => callback()];
+}
+function withTimeout(promise, ms, message) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(message)), ms);
+		promise.then(resolve, reject).finally(() => clearTimeout(timer));
+	});
+}
+//#endregion
+export { closePromise, delay, withTimeout };

package/dist/utils/referentialAction.js

@@ -0,0 +1,23 @@
+import { ReferentialAction, ReferentialActionToSQL } from "../constants/schema.js";
+//#region src/utils/referentialAction.ts
+var SEPARATOR = /[\s_]+/g;
+function toReferentialAction(spelling) {
+	const value = spelling.trim().replace(SEPARATOR, " ").toUpperCase();
+	const entry = Object.entries(ReferentialActionToSQL).find(([, sql]) => sql === value);
+	return entry ? Number(entry[0]) : ReferentialAction.none;
+}
+var ACTION_LETTERS = {
+	[ReferentialAction.noAction]: "NA",
+	[ReferentialAction.cascade]: "C",
+	[ReferentialAction.setNull]: "SN",
+	[ReferentialAction.setDefault]: "SD",
+	[ReferentialAction.restrict]: "R"
+};
+function referentialActionLabel({ onDelete, onUpdate }) {
+	return [ACTION_LETTERS[onDelete] ? `D:${ACTION_LETTERS[onDelete]}` : "", ACTION_LETTERS[onUpdate] ? `U:${ACTION_LETTERS[onUpdate]}` : ""].filter(Boolean).join(" ");
+}
+function referentialActionTitle({ onDelete, onUpdate }) {
+	return [ReferentialActionToSQL[onDelete] ? `ON DELETE ${ReferentialActionToSQL[onDelete]}` : "", ReferentialActionToSQL[onUpdate] ? `ON UPDATE ${ReferentialActionToSQL[onUpdate]}` : ""].filter(Boolean).join("\n");
+}
+//#endregion
+export { referentialActionLabel, referentialActionTitle, toReferentialAction };

package/dist/utils/rx-operators/fromCopy.js

@@ -0,0 +1,7 @@
+import { Observable } from "rxjs";
+//#region src/utils/rx-operators/fromCopy.ts
+var fromCopy = (emitter) => new Observable((subscriber) => emitter.on({ copy: ({ payload: { event } }) => {
+	subscriber.next(event);
+} }));
+//#endregion
+export { fromCopy };

package/dist/utils/rx-operators/fromPaste.js

@@ -0,0 +1,7 @@
+import { Observable } from "rxjs";
+//#region src/utils/rx-operators/fromPaste.ts
+var fromPaste = (emitter) => new Observable((subscriber) => emitter.on({ paste: ({ payload: { event } }) => {
+	subscriber.next(event);
+} }));
+//#endregion
+export { fromPaste };

package/dist/utils/rx-operators/fromShadowDraggable.js

@@ -0,0 +1,5 @@
+import { debounceTime, fromEvent, map, merge, takeUntil, throttleTime } from "rxjs";
+//#region src/utils/rx-operators/fromShadowDraggable.ts
+var fromShadowDraggable = (elements, prepare) => merge(...elements.map((el) => fromEvent(el, "dragover").pipe(throttleTime(300), map(() => prepare(el))))).pipe(debounceTime(50), takeUntil(merge(...elements.map((el) => fromEvent(el, "dragend")))));
+//#endregion
+export { fromShadowDraggable };

package/dist/utils/safeCallback.js

@@ -0,0 +1,10 @@
+//#region src/utils/safeCallback.ts
+function safeCallback(callback, ...args) {
+	try {
+		return callback?.(...args);
+	} catch (e) {
+		console.error(e);
+	}
+}
+//#endregion
+export { safeCallback };