@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/keyboard-shortcut/index.js

@@ -0,0 +1,243 @@
+import { hasAppleDevice } from "../device-detect/index.js";
+import { ModifierKey, matchesPress, parseKeybinding } from "./utils.js";
+import { bindKeys } from "./bindKeys.js";
+//#region src/utils/keyboard-shortcut/index.ts
+var KeyBindingName = {
+	edit: "edit",
+	stop: "stop",
+	search: "search",
+	findReplace: "findReplace",
+	undo: "undo",
+	redo: "redo",
+	addTable: "addTable",
+	addColumn: "addColumn",
+	addMemo: "addMemo",
+	addTableGroup: "addTableGroup",
+	groupSelectedTables: "groupSelectedTables",
+	removeTable: "removeTable",
+	removeColumn: "removeColumn",
+	removeSelection: "removeSelection",
+	primaryKey: "primaryKey",
+	selectAllTable: "selectAllTable",
+	selectAllColumn: "selectAllColumn",
+	relationshipZeroOne: "relationshipZeroOne",
+	relationshipZeroN: "relationshipZeroN",
+	relationshipOneOnly: "relationshipOneOnly",
+	relationshipOneN: "relationshipOneN",
+	tableProperties: "tableProperties",
+	focusView: "focusView",
+	zoomIn: "zoomIn",
+	zoomOut: "zoomOut",
+	zoomReset: "zoomReset",
+	handTool: "handTool",
+	zenMode: "zenMode"
+};
+var KeyBindingNameList = Object.values(KeyBindingName);
+var PANEL_PASSING_BINDINGS = [
+	KeyBindingName.findReplace,
+	KeyBindingName.search,
+	KeyBindingName.undo,
+	KeyBindingName.redo,
+	KeyBindingName.zoomIn,
+	KeyBindingName.zoomOut,
+	KeyBindingName.zoomReset
+];
+var PANEL_KEYS = /* @__PURE__ */ new Set([
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight",
+	"Tab",
+	"Enter",
+	" ",
+	"Home",
+	"End"
+]);
+function stopsAtPanel(event, keyBindingMap, passing = PANEL_PASSING_BINDINGS) {
+	if (isComposing(event)) return true;
+	const matches = (name) => matchesShortcut(event, keyBindingMap[name]);
+	if (passing.some(matches)) return false;
+	return PANEL_KEYS.has(event.key) || KeyBindingNameList.some(matches);
+}
+var createKeyBindingMap = () => ({
+	[KeyBindingName.edit]: [{ shortcut: "Enter" }],
+	[KeyBindingName.stop]: [{ shortcut: "Escape" }],
+	[KeyBindingName.search]: [{
+		shortcut: "$mod+KeyK",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.findReplace]: [{
+		shortcut: "$mod+KeyF",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.undo]: [{
+		shortcut: "$mod+KeyZ",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.redo]: [{
+		shortcut: "$mod+Shift+KeyZ",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.addTable]: [{
+		shortcut: "Alt+KeyN",
+		preventDefault: true
+	}],
+	[KeyBindingName.addColumn]: [{
+		shortcut: "Alt+Enter",
+		preventDefault: true
+	}],
+	[KeyBindingName.addMemo]: [{
+		shortcut: "Alt+KeyM",
+		preventDefault: true
+	}],
+	[KeyBindingName.addTableGroup]: [{
+		shortcut: "Alt+KeyG",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.groupSelectedTables]: [{
+		shortcut: "KeyT KeyG",
+		preventDefault: true
+	}],
+	[KeyBindingName.removeTable]: [{
+		shortcut: "$mod+Backspace",
+		preventDefault: true
+	}, {
+		shortcut: "$mod+Delete",
+		preventDefault: true
+	}],
+	[KeyBindingName.removeColumn]: [{
+		shortcut: "Alt+Backspace",
+		preventDefault: true
+	}, {
+		shortcut: "Alt+Delete",
+		preventDefault: true
+	}],
+	[KeyBindingName.removeSelection]: [{
+		shortcut: "Delete",
+		preventDefault: true
+	}, {
+		shortcut: "Backspace",
+		preventDefault: true
+	}],
+	[KeyBindingName.primaryKey]: [{
+		shortcut: "Alt+KeyK",
+		preventDefault: true
+	}],
+	[KeyBindingName.selectAllTable]: [{
+		shortcut: "$mod+KeyA",
+		preventDefault: true
+	}, {
+		shortcut: "$mod+Alt+KeyA",
+		preventDefault: true
+	}],
+	[KeyBindingName.selectAllColumn]: [{
+		shortcut: "Alt+KeyA",
+		preventDefault: true
+	}],
+	[KeyBindingName.relationshipZeroOne]: [{
+		shortcut: "$mod+Alt+Digit1",
+		preventDefault: true
+	}],
+	[KeyBindingName.relationshipZeroN]: [{
+		shortcut: "$mod+Alt+Digit2",
+		preventDefault: true
+	}],
+	[KeyBindingName.relationshipOneOnly]: [{
+		shortcut: "$mod+Alt+Digit3",
+		preventDefault: true
+	}],
+	[KeyBindingName.relationshipOneN]: [{
+		shortcut: "$mod+Alt+Digit4",
+		preventDefault: true
+	}],
+	[KeyBindingName.tableProperties]: [{
+		shortcut: "Alt+Space",
+		preventDefault: true
+	}],
+	[KeyBindingName.focusView]: [{
+		shortcut: "Alt+KeyF",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.zoomIn]: [{
+		shortcut: "$mod+Equal",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.zoomOut]: [{
+		shortcut: "$mod+Minus",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.zoomReset]: [{
+		shortcut: "$mod+Digit0",
+		preventDefault: true,
+		stopPropagation: true
+	}],
+	[KeyBindingName.handTool]: [{
+		shortcut: "Space",
+		preventDefault: true
+	}],
+	[KeyBindingName.zenMode]: [{
+		shortcut: "Alt+KeyZ",
+		preventDefault: true,
+		stopPropagation: true
+	}]
+});
+function pickKeyBindingMap(keyBindingMap, names) {
+	for (const name of KeyBindingNameList) if (!names.includes(name) && keyBindingMap[name].length) keyBindingMap[name] = [];
+}
+function matchesShortcut(event, options) {
+	return options.some(({ shortcut }) => {
+		const presses = parseKeybinding(shortcut);
+		return matchesPress(event, presses[presses.length - 1]);
+	});
+}
+var MacModifierKeyMap = {
+	[ModifierKey.Shift]: "⇧",
+	[ModifierKey.Meta]: "⌘",
+	[ModifierKey.Alt]: "⌥",
+	[ModifierKey.Control]: "⌃"
+};
+var WindowsModifierKeyMap = {
+	[ModifierKey.Shift]: "Shift",
+	[ModifierKey.Meta]: "Cmd",
+	[ModifierKey.Alt]: "Alt",
+	[ModifierKey.Control]: "Ctrl"
+};
+function modifierKeyToString(key) {
+	return (hasAppleDevice() ? MacModifierKeyMap : WindowsModifierKeyMap)[key] ?? key;
+}
+function codeToString(code) {
+	if (code.startsWith("Key")) return code.slice(3);
+	if (code.startsWith("Digit")) return code.slice(5);
+	if (code === "Backspace") return "⌫";
+	if (code === "Escape") return "ESC";
+	if (code === "Equal") return "Plus";
+	return code;
+}
+function shortcutToTuple(shortcut) {
+	return shortcut ? parseKeybinding(shortcut).map(([mods, key]) => [mods.map(modifierKeyToString), codeToString(key)]) : [];
+}
+function isMod(event) {
+	return hasAppleDevice() ? event.metaKey : event.ctrlKey;
+}
+var IME_KEY_CODE = 229;
+function isComposing(event) {
+	return event.isComposing || event.keyCode === IME_KEY_CODE;
+}
+function toShortcutTitle(keyBindingMap, name, keyBindingName) {
+	const [option] = keyBindingMap[keyBindingName] ?? [];
+	const shortcut = option ? simpleShortcutToString(option.shortcut) : "";
+	return shortcut ? `${name} (${shortcut})` : name;
+}
+function simpleShortcutToString(shortcut) {
+	return shortcutToTuple(shortcut).map(([mods, key]) => [...mods, key].join(" + ")).join(" ");
+}
+//#endregion
+export { KeyBindingName, KeyBindingNameList, PANEL_PASSING_BINDINGS, bindKeys, createKeyBindingMap, isComposing, isMod, matchesShortcut, pickKeyBindingMap, shortcutToTuple, simpleShortcutToString, stopsAtPanel, toShortcutTitle };

package/dist/utils/keyboard-shortcut/utils.js

@@ -0,0 +1,32 @@
+import { hasAppleDevice, hasWindows } from "../device-detect/index.js";
+//#region src/utils/keyboard-shortcut/utils.ts
+var ModifierKey = {
+	Shift: "Shift",
+	Meta: "Meta",
+	Alt: "Alt",
+	Control: "Control"
+};
+var MODIFIER_KEYS = Object.values(ModifierKey);
+function parseKeybinding(str) {
+	const MOD = hasAppleDevice() ? "Meta" : "Control";
+	return str.trim().split(" ").map((press) => {
+		let mods = press.split(/\b\+/);
+		const key = mods.pop();
+		mods = mods.map((mod) => mod === "$mod" ? MOD : mod);
+		return [mods, key];
+	});
+}
+function altGraphAliases() {
+	if (hasWindows()) return ["Control", "Alt"];
+	if (hasAppleDevice()) return ["Alt"];
+	return [];
+}
+function isModifierHeld(event, mod) {
+	if (typeof event.getModifierState !== "function") return false;
+	return event.getModifierState(mod) || event.getModifierState("AltGraph") && altGraphAliases().includes(mod);
+}
+function matchesPress(event, [mods, key]) {
+	return (key.toUpperCase() === event.key.toUpperCase() || key === event.code) && mods.every((mod) => isModifierHeld(event, mod)) && !MODIFIER_KEYS.some((mod) => !mods.includes(mod) && key !== mod && isModifierHeld(event, mod));
+}
+//#endregion
+export { ModifierKey, isModifierHeld, matchesPress, parseKeybinding };

package/dist/utils/loadValue.js

@@ -0,0 +1,11 @@
+import { createSchema } from "../erd-editor-schema/dist/v3/parser/index.js";
+import { toJson } from "../erd-editor-schema/dist/parser.js";
+import { toSafeString } from "./validation.js";
+import { isEmpty } from "es-toolkit/compat";
+//#region src/utils/loadValue.ts
+function toLoadValue(value) {
+	const safeValue = toSafeString(value);
+	return isEmpty(safeValue) ? toJson(createSchema()) : safeValue;
+}
+//#endregion
+export { toLoadValue };

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

@@ -0,0 +1,48 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { changeColumnDataTypeAction } from "../../engine/modules/table-column/atom.actions.js";
+import { toReferenceDataType } from "../../engine/modules/relationship/referenceType.js";
+import { getDataTypeSyncColumns } from "../../engine/modules/table-column/utils/dataType.js";
+import { toDomainUnlinkActions } from "../../engine/modules/dictionary/domainTypes.js";
+//#region src/utils/map-columns/alignTypes.ts
+function toAlignTypeActions(state, { relationshipId, start, end, newColumnIds }) {
+	const { doc: { relationshipIds }, collections, settings: { relationshipDataTypeSync, database } } = state;
+	if (!relationshipDataTypeSync) return [];
+	const columns = query(collections).collection("tableColumnEntities");
+	const isNew = (id) => newColumnIds.includes(id);
+	const seeds = [];
+	start.columnIds.forEach((parentId, index) => {
+		const childId = end.columnIds[index];
+		const parent = columns.selectById(parentId);
+		if (childId === void 0 || isNew(childId) || !parent?.dataType.trim()) return;
+		seeds.push({
+			id: childId,
+			tableId: end.tableId,
+			value: toReferenceDataType(parent.dataType, database)
+		});
+	});
+	if (!seeds.length) return [];
+	const mapping = {
+		start,
+		end
+	};
+	const relationships = [...query(collections).collection("relationshipEntities").selectByIds(relationshipIds).filter(({ id }) => id !== relationshipId), mapping];
+	const written = getDataTypeSyncColumns(seeds.reverse(), state, [], relationships).filter(({ id, value }) => {
+		const column = columns.selectById(id);
+		return !isNew(id) && !!column && column.dataType !== value;
+	});
+	return [...written.map((payload) => changeColumnDataTypeAction(payload)), ...toDomainUnlinkActions(state, written)];
+}
+function getTypeNote({ settings: { relationshipDataTypeSync, database } }, parent, child) {
+	const dataType = toReferenceDataType(parent.dataType, database);
+	if (dataType === child.dataType) return null;
+	return relationshipDataTypeSync && parent.dataType.trim() ? {
+		kind: "becomes",
+		dataType
+	} : {
+		kind: "differ",
+		parentType: parent.dataType,
+		childType: child.dataType
+	};
+}
+//#endregion
+export { getTypeNote, toAlignTypeActions };

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

@@ -0,0 +1,337 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { getColumnKeys } from "../tableKeys.js";
+import { toForeignKeyNames } from "../../engine/modules/relationship/fkColumns.js";
+import { getLiveRelationship, getLiveTable, isLiveColumn, isNormalMapping, repeatedIds, sameMembers, sameSet, toColumnMapping } from "./mapping.js";
+import { CURRENT_KEY_ID, findColumnKey, getCandidateKeys, toCurrentKey } from "./candidateKeys.js";
+import { prefillPicks } from "./prefill.js";
+import { hasMappingIssues, validateMapping } from "./validate.js";
+//#region src/utils/map-columns/buildRows.ts
+var existing = (columnId) => ({
+	kind: "existing",
+	columnId
+});
+var toMappingRow = (parentColumnId, pick, invalid) => invalid ? {
+	parentColumnId,
+	pick,
+	invalid
+} : {
+	parentColumnId,
+	pick
+};
+function toPlaceRows({ start, end }) {
+	const repeatedStart = repeatedIds(start);
+	const repeatedEnd = repeatedIds(end);
+	return Array.from({ length: Math.max(start.length, end.length) }, (_, index) => {
+		const parentColumnId = start[index] ?? null;
+		const childId = end[index];
+		const invalid = parentColumnId === null || childId === void 0 || repeatedStart.has(parentColumnId) || repeatedEnd.has(childId);
+		return toMappingRow(parentColumnId, childId === void 0 ? null : existing(childId), invalid);
+	});
+}
+function toStoredPick({ start, end }, parentColumnId) {
+	const index = start.indexOf(parentColumnId);
+	if (index === -1 || start.lastIndexOf(parentColumnId) !== index) return null;
+	const childId = end[index];
+	return childId === void 0 ? null : existing(childId);
+}
+function openOnMapping(mapping, keys) {
+	const key = isNormalMapping(mapping) ? keys.find(({ columnIds }) => sameMembers(columnIds, mapping.start)) : void 0;
+	if (!key) return {
+		keyId: CURRENT_KEY_ID,
+		rows: toPlaceRows(mapping),
+		keys: [...keys, toCurrentKey(mapping.start)]
+	};
+	return {
+		keyId: key.id,
+		rows: key.columnIds.map((parentColumnId) => ({
+			parentColumnId,
+			pick: toStoredPick(mapping, parentColumnId)
+		})),
+		keys
+	};
+}
+function releaseRepeatedPicks(rows, isSet) {
+	const claimed = /* @__PURE__ */ new Set();
+	const claim = (row) => {
+		if (row.invalid || row.pick?.kind !== "existing") return;
+		if (claimed.has(row.pick.columnId)) row.pick = null;
+		else claimed.add(row.pick.columnId);
+	};
+	const copies = rows.map((row) => ({ ...row }));
+	copies.filter(isSet).forEach(claim);
+	copies.filter((row) => !isSet(row)).forEach(claim);
+	return copies;
+}
+function createRows(session, keys, childTable) {
+	const key = keys.find(({ id }) => id === session.keyId) ?? keys[0];
+	if (!key) return {
+		keyId: null,
+		rows: []
+	};
+	const rows = key.columnIds.map((parentColumnId) => {
+		const pick = session.picks[parentColumnId] ?? null;
+		return {
+			parentColumnId,
+			pick: pick?.kind === "existing" && !isLiveColumn(childTable, pick.columnId) ? null : pick
+		};
+	});
+	return {
+		keyId: key.id,
+		rows: releaseRepeatedPicks(rows, () => true)
+	};
+}
+function editRows(session, relationship, opened) {
+	if (!session.touched) return opened;
+	const { picks } = session;
+	const isPicked = (parentColumnId) => parentColumnId !== null && Object.hasOwn(picks, parentColumnId);
+	const key = opened.keys.find(({ id }) => id === session.keyId) ?? opened.keys.find(({ id }) => id === opened.keyId);
+	const mapping = toColumnMapping(relationship);
+	const rows = key.id === "current" ? toPlaceRows(mapping).map((row) => !row.invalid && isPicked(row.parentColumnId) ? {
+		...row,
+		pick: picks[row.parentColumnId]
+	} : row) : key.columnIds.map((parentColumnId) => ({
+		parentColumnId,
+		pick: isPicked(parentColumnId) ? picks[parentColumnId] : toStoredPick(mapping, parentColumnId)
+	}));
+	return {
+		keyId: key.id,
+		rows: releaseRepeatedPicks(rows, (row) => isPicked(row.parentColumnId))
+	};
+}
+function keyChanged(state, base, parentTable, keyId) {
+	const opened = base.keys[keyId];
+	if (keyId === "current" || !opened) return false;
+	const key = findColumnKey(state, parentTable, keyId);
+	return !key || !sameSet(key.columnIds, opened);
+}
+function isChangedRemotely(state, session, relationship, parentTable) {
+	const { base } = session;
+	const sameList = (a, b) => a.length === b.length && a.every((id, index) => id === b[index]);
+	return !sameList(relationship.start.columnIds, base.startColumnIds) || !sameList(relationship.end.columnIds, base.endColumnIds) || keyChanged(state, base, parentTable, base.keyId) || session.touched && keyChanged(state, base, parentTable, session.keyId);
+}
+function toNewColumnNames({ collections }, rows, parentTable, childTable) {
+	const columns = query(collections).collection("tableColumnEntities");
+	const childNames = columns.selectByIds(childTable.columnIds).map(({ name }) => name);
+	const parentName = (row) => row.parentColumnId === null ? void 0 : columns.selectById(row.parentColumnId)?.name;
+	return rows.map((row, rowIndex) => {
+		if (row.invalid || parentName(row) === void 0) return "";
+		const named = rows.filter((other, index) => index === rowIndex || !other.invalid && other.pick?.kind === "new" && parentName(other) !== void 0);
+		return toForeignKeyNames(parentTable.name, named.map((other) => parentName(other)), childNames)[named.indexOf(row)];
+	});
+}
+function toNotice(keyId, rows, keys) {
+	if (keyId !== "current") return null;
+	const hasKey = keys.some(({ kind }) => kind !== "current");
+	if (rows.some(({ invalid, removedParent }) => invalid || removedParent)) return hasKey ? "fixMapping" : "addKeyToFix";
+	if (!hasKey) return "noKey";
+	return rows.some(({ removedChild }) => removedChild) ? null : "notAKey";
+}
+function toView(state, { parentTable, childTable, relationshipType, keys, keyId, rows, changedRemotely, toDraft }) {
+	const newColumnNames = toNewColumnNames(state, rows, parentTable, childTable);
+	const views = rows.map((row, index) => ({
+		...row,
+		removedParent: row.parentColumnId !== null && !isLiveColumn(parentTable, row.parentColumnId),
+		removedChild: row.pick?.kind === "existing" && !isLiveColumn(childTable, row.pick.columnId),
+		newColumnName: newColumnNames[index]
+	}));
+	const draft = toDraft(rows.map(({ parentColumnId, pick, invalid }) => toMappingRow(parentColumnId, pick, invalid)));
+	const issues = validateMapping(state, draft);
+	return {
+		closed: null,
+		parentTable,
+		childTable,
+		relationshipType,
+		keys,
+		keyId,
+		showReferences: keys.length > 1,
+		rows: views,
+		notice: toNotice(keyId, views, keys),
+		changedRemotely,
+		draft,
+		issues,
+		canConfirm: !hasMappingIssues(issues)
+	};
+}
+function buildCreate(state, session) {
+	const { startTableId, endTableId, relationshipType } = session;
+	const parentTable = getLiveTable(state, startTableId);
+	if (!parentTable) return { closed: {
+		reason: "tableRemoved",
+		tableId: startTableId
+	} };
+	const childTable = getLiveTable(state, endTableId);
+	if (!childTable) return { closed: {
+		reason: "tableRemoved",
+		tableId: endTableId
+	} };
+	const keys = getCandidateKeys(state, parentTable);
+	const { keyId, rows } = createRows(session, keys, childTable);
+	return toView(state, {
+		parentTable,
+		childTable,
+		relationshipType,
+		keys,
+		keyId,
+		rows,
+		changedRemotely: false,
+		toDraft: (draftRows) => ({
+			mode: "create",
+			startTableId,
+			endTableId,
+			relationshipType,
+			keyId,
+			rows: draftRows
+		})
+	});
+}
+function buildEdit(state, session) {
+	const { relationshipId } = session;
+	const entity = query(state.collections).collection("relationshipEntities").selectById(relationshipId);
+	if (entity) {
+		for (const { tableId } of [entity.start, entity.end]) if (!getLiveTable(state, tableId)) return { closed: {
+			reason: "tableRemoved",
+			tableId
+		} };
+	}
+	const relationship = getLiveRelationship(state, relationshipId);
+	if (!relationship) return { closed: { reason: "relationshipRemoved" } };
+	const parentTable = getLiveTable(state, relationship.start.tableId);
+	const childTable = getLiveTable(state, relationship.end.tableId);
+	const opened = openOnMapping(toColumnMapping(relationship), getCandidateKeys(state, parentTable));
+	const { keyId, rows } = editRows(session, relationship, opened);
+	return toView(state, {
+		parentTable,
+		childTable,
+		relationshipType: relationship.relationshipType,
+		keys: opened.keys,
+		keyId,
+		rows,
+		changedRemotely: isChangedRemotely(state, session, relationship, parentTable),
+		toDraft: (draftRows) => ({
+			mode: "edit",
+			relationshipId,
+			keyId,
+			rows: draftRows
+		})
+	});
+}
+function buildMapColumns(state, session) {
+	return session.mode === "create" ? buildCreate(state, session) : buildEdit(state, session);
+}
+function openCreateSession(state, { startTableId, endTableId, relationshipType }) {
+	const session = {
+		mode: "create",
+		startTableId,
+		endTableId,
+		relationshipType,
+		keyId: null,
+		picks: {}
+	};
+	const view = buildMapColumns(state, session);
+	if (view.closed !== null || view.keyId === null) return session;
+	return changeMapColumnsKey(state, session, view.keyId);
+}
+function openEditSession(state, relationshipId) {
+	const relationship = query(state.collections).collection("relationshipEntities").selectById(relationshipId);
+	const parentTable = relationship && getLiveTable(state, relationship.start.tableId);
+	const mapping = relationship ? toColumnMapping(relationship) : {
+		start: [],
+		end: []
+	};
+	const { keyId } = openOnMapping(mapping, parentTable ? getCandidateKeys(state, parentTable) : []);
+	return {
+		mode: "edit",
+		relationshipId,
+		base: {
+			startColumnIds: [...mapping.start],
+			endColumnIds: [...mapping.end],
+			keyId,
+			keys: Object.fromEntries((parentTable ? getColumnKeys(state, parentTable) : []).map(({ id, columnIds }) => [id, [...columnIds]]))
+		},
+		touched: false,
+		keyId,
+		picks: {}
+	};
+}
+var changeMapColumnsKey = (state, session, keyId) => changeKey(state, session, keyId);
+function changeKey(state, session, keyId) {
+	const view = buildMapColumns(state, session);
+	if (view.closed !== null) return session;
+	const key = view.keys.find(({ id }) => id === keyId);
+	if (!key) return session;
+	const keeps = (pick) => pick?.kind !== "existing" || isLiveColumn(view.childTable, pick.columnId);
+	const prefill = (rows) => prefillPicks(state, {
+		parentTable: view.parentTable,
+		childTable: view.childTable,
+		keyKind: key.kind,
+		rows
+	});
+	if (session.mode === "create") {
+		const picks = {};
+		for (const parentColumnId of key.columnIds) {
+			const pick = session.picks[parentColumnId] ?? null;
+			if (pick && keeps(pick)) picks[parentColumnId] = pick;
+		}
+		const rows = key.columnIds.map((parentColumnId) => ({
+			parentColumnId,
+			pick: picks[parentColumnId] ?? null
+		}));
+		return {
+			...session,
+			keyId: key.id,
+			picks: {
+				...picks,
+				...prefill(rows)
+			}
+		};
+	}
+	const relationship = getLiveRelationship(state, session.relationshipId);
+	const mapping = toColumnMapping(relationship);
+	const picks = {};
+	const isCurrent = key.id === CURRENT_KEY_ID;
+	for (const parentColumnId of key.columnIds) if (session.touched && Object.hasOwn(session.picks, parentColumnId)) picks[parentColumnId] = session.picks[parentColumnId];
+	else if (!isCurrent && !keeps(toStoredPick(mapping, parentColumnId))) picks[parentColumnId] = null;
+	if (isCurrent) return {
+		...session,
+		touched: true,
+		keyId: key.id,
+		picks
+	};
+	const rows = key.columnIds.map((parentColumnId) => ({
+		parentColumnId,
+		pick: Object.hasOwn(picks, parentColumnId) ? picks[parentColumnId] : toStoredPick(mapping, parentColumnId)
+	}));
+	return {
+		...session,
+		touched: true,
+		keyId: key.id,
+		picks: {
+			...picks,
+			...prefill(rows)
+		}
+	};
+}
+var pickMapColumn = (state, session, parentColumnId, pick) => pickColumn(state, session, parentColumnId, pick);
+function pickColumn(state, session, parentColumnId, pick) {
+	const view = buildMapColumns(state, session);
+	const picks = {
+		...session.picks,
+		[parentColumnId]: pick
+	};
+	if (view.closed !== null) return {
+		...session,
+		picks
+	};
+	return session.mode === "create" ? {
+		...session,
+		keyId: view.keyId,
+		picks
+	} : {
+		...session,
+		touched: true,
+		keyId: view.keyId,
+		picks
+	};
+}
+//#endregion
+export { buildMapColumns, changeMapColumnsKey, openCreateSession, openEditSession, pickMapColumn };

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

@@ -0,0 +1,24 @@
+import { getColumnKeys } from "../tableKeys.js";
+import { sameSet } from "./mapping.js";
+//#region src/utils/map-columns/candidateKeys.ts
+var CURRENT_KEY_ID = "current";
+function getCandidateKeys(state, table) {
+	const keys = [];
+	for (const { id, kind, columnIds } of getColumnKeys(state, table)) {
+		if (keys.some((key) => sameSet(key.columnIds, columnIds))) continue;
+		keys.push({
+			id,
+			kind,
+			columnIds
+		});
+	}
+	return keys;
+}
+var findColumnKey = (state, table, keyId) => getColumnKeys(state, table).find(({ id }) => id === keyId);
+var toCurrentKey = (columnIds) => ({
+	id: CURRENT_KEY_ID,
+	kind: "current",
+	columnIds: [...columnIds]
+});
+//#endregion
+export { CURRENT_KEY_ID, findColumnKey, getCandidateKeys, toCurrentKey };