@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/erd-editor-schema/dist/convert/v2ToV3.js

@@ -0,0 +1,142 @@
+import { migrateScrollToOrigin } from "../v3/parser/migrateScroll.js";
+import { propOr } from "../helper.js";
+import { createIndex } from "../v3/parser/index.entity.js";
+import { createIndexColumn } from "../v3/parser/indexColumn.entity.js";
+import { createMemo } from "../v3/parser/memo.entity.js";
+import { createRelationship } from "../v3/parser/relationship.entity.js";
+import { toFullColumnOrder, toLockedValues } from "../v3/parser/settings.js";
+import { createTable } from "../v3/parser/table.entity.js";
+import { createColumn } from "../v3/parser/tableColumn.entity.js";
+import { parser } from "../v3/parser/index.js";
+import { SchemaV3Constants } from "../v3/schema/index.js";
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+//#region ../erd-editor-schema/dist/convert/v2ToV3.js
+function v2ToV3(schemaV2) {
+	const schemaV3 = parser({});
+	assignCanvas(schemaV3.settings, schemaV2.canvas);
+	assignTable(schemaV3, schemaV2.table);
+	assignMemo(schemaV3, schemaV2.memo);
+	assignRelationship(schemaV3, schemaV2.relationship);
+	return schemaV3;
+}
+function assignCanvas(target, source) {
+	target.zoomLevel = source.zoomLevel;
+	const { originX, originY } = migrateScrollToOrigin(source);
+	target.originX = originX;
+	target.originY = originY;
+	target.databaseName = source.databaseName;
+	target.canvasType = SchemaV3Constants.CanvasType.ERD;
+	target.show = Object.keys(source.show).reduce((acc, key) => {
+		if (propOr(source.show, key, false)) return acc | propOr(SchemaV3Constants.Show, key, 0);
+		return acc;
+	}, 0);
+	target.database = Reflect.get(SchemaV3Constants.Database, source.database) ?? SchemaV3Constants.Database.MySQL;
+	target.language = source.language === "C#" ? SchemaV3Constants.Language.csharp : propOr(SchemaV3Constants.Language, source.language, SchemaV3Constants.Language.GraphQL);
+	target.tableNameCase = propOr(SchemaV3Constants.NameCase, source.tableCase, SchemaV3Constants.NameCase.pascalCase);
+	target.columnNameCase = propOr(SchemaV3Constants.NameCase, source.columnCase, SchemaV3Constants.NameCase.camelCase);
+	target.bracketType = propOr(SchemaV3Constants.BracketType, source.bracketType, SchemaV3Constants.BracketType.none);
+	target.relationshipDataTypeSync = source.setting.relationshipDataTypeSync;
+	target.columnOrder = toFullColumnOrder(source.setting.columnOrder.map((key) => SchemaV3Constants.ColumnType[key])) ?? target.columnOrder;
+	target.lockedValues = toLockedValues(target);
+}
+function assignTable(target, source) {
+	const tables = source.tables.filter(({ id }) => Boolean(id));
+	const indexes = source.indexes.filter(({ id }) => Boolean(id));
+	target.doc.tableIds = tables.map(({ id }) => id);
+	target.doc.indexIds = indexes.map(({ id }) => id);
+	for (const table of tables) {
+		const newTable = createTable();
+		newTable.id = table.id;
+		newTable.name = table.name;
+		newTable.comment = table.comment;
+		newTable.columnIds = table.columns.map(({ id }) => id);
+		newTable.seqColumnIds = [...newTable.columnIds];
+		newTable.ui.y = table.ui.top;
+		newTable.ui.x = table.ui.left;
+		newTable.ui.zIndex = table.ui.zIndex;
+		newTable.ui.widthName = table.ui.widthName;
+		newTable.ui.widthComment = table.ui.widthComment;
+		newTable.ui.color = table.ui.color ?? "";
+		for (const column of table.columns) {
+			const newColumn = createColumn();
+			newColumn.id = column.id;
+			newColumn.tableId = table.id;
+			newColumn.name = column.name;
+			newColumn.comment = column.comment;
+			newColumn.dataType = column.dataType;
+			newColumn.default = column.default;
+			newColumn.options = Object.keys(column.option).reduce((acc, key) => {
+				if (propOr(column.option, key, false)) return acc | propOr(SchemaV3Constants.ColumnOption, key, 0);
+				return acc;
+			}, 0);
+			newColumn.ui.widthName = column.ui.widthName;
+			newColumn.ui.widthComment = column.ui.widthComment;
+			newColumn.ui.widthDataType = column.ui.widthDataType;
+			newColumn.ui.widthDefault = column.ui.widthDefault;
+			if (column.ui.pfk) newColumn.ui.keys = SchemaV3Constants.ColumnUIKey.primaryKey | SchemaV3Constants.ColumnUIKey.foreignKey;
+			else if (column.ui.pk) newColumn.ui.keys = SchemaV3Constants.ColumnUIKey.primaryKey;
+			else if (column.ui.fk) newColumn.ui.keys = SchemaV3Constants.ColumnUIKey.foreignKey;
+			target.collections.tableColumnEntities[newColumn.id] = newColumn;
+		}
+		target.collections.tableEntities[newTable.id] = newTable;
+	}
+	for (const index of indexes) {
+		const newIndex = createIndex();
+		newIndex.id = index.id;
+		newIndex.name = index.name;
+		newIndex.tableId = index.tableId;
+		newIndex.unique = index.unique;
+		for (const indexColumn of index.columns) {
+			const id = uuid25();
+			const newIndexColumn = createIndexColumn();
+			newIndex.indexColumnIds.push(id);
+			newIndex.seqIndexColumnIds.push(id);
+			newIndexColumn.id = id;
+			newIndexColumn.indexId = index.id;
+			newIndexColumn.columnId = indexColumn.id;
+			newIndexColumn.orderType = propOr(SchemaV3Constants.OrderType, indexColumn.orderType, SchemaV3Constants.OrderType.ASC);
+			target.collections.indexColumnEntities[newIndexColumn.id] = newIndexColumn;
+		}
+		target.collections.indexEntities[newIndex.id] = newIndex;
+	}
+}
+function assignMemo(target, source) {
+	const memos = source.memos.filter(({ id }) => Boolean(id));
+	target.doc.memoIds = memos.map(({ id }) => id);
+	for (const value of memos) {
+		const newValue = createMemo();
+		newValue.id = value.id;
+		newValue.value = value.value;
+		newValue.ui.y = value.ui.top;
+		newValue.ui.x = value.ui.left;
+		newValue.ui.width = value.ui.width;
+		newValue.ui.height = value.ui.height;
+		newValue.ui.zIndex = value.ui.zIndex;
+		newValue.ui.color = value.ui.color ?? "";
+		target.collections.memoEntities[newValue.id] = newValue;
+	}
+}
+function assignRelationship(target, source) {
+	const relationships = source.relationships.filter(({ id }) => Boolean(id));
+	target.doc.relationshipIds = relationships.map(({ id }) => id);
+	for (const value of relationships) {
+		const newValue = createRelationship();
+		newValue.id = value.id;
+		newValue.identification = value.identification;
+		newValue.relationshipType = propOr(SchemaV3Constants.RelationshipType, value.relationshipType, SchemaV3Constants.RelationshipType.ZeroN);
+		newValue.startRelationshipType = propOr(SchemaV3Constants.StartRelationshipType, value.startRelationshipType === "Ring" ? "ring" : "dash", SchemaV3Constants.StartRelationshipType.dash);
+		newValue.start.tableId = value.start.tableId;
+		newValue.start.columnIds = value.start.columnIds;
+		newValue.start.x = value.start.x;
+		newValue.start.y = value.start.y;
+		newValue.start.direction = propOr(SchemaV3Constants.Direction, value.start.direction, SchemaV3Constants.Direction.bottom);
+		newValue.end.tableId = value.end.tableId;
+		newValue.end.columnIds = value.end.columnIds;
+		newValue.end.x = value.end.x;
+		newValue.end.y = value.end.y;
+		newValue.end.direction = propOr(SchemaV3Constants.Direction, value.end.direction, SchemaV3Constants.Direction.bottom);
+		target.collections.relationshipEntities[newValue.id] = newValue;
+	}
+}
+//#endregion
+export { v2ToV3 };

package/dist/erd-editor-schema/dist/dictionaryRows.js

@@ -0,0 +1,86 @@
+import { isPlainObject } from "es-toolkit";
+//#region ../erd-editor-schema/dist/dictionaryRows.js
+var DictionaryFields = {
+	wordEntities: [
+		"id",
+		"name",
+		"abbreviation",
+		"englishName",
+		"description",
+		"synonyms",
+		"forbiddenWords"
+	],
+	termEntities: [
+		"id",
+		"name",
+		"physicalName",
+		"domainId",
+		"description",
+		"synonyms"
+	],
+	domainEntities: [
+		"id",
+		"name",
+		"category",
+		"dataType",
+		"description"
+	]
+};
+function withOrderKey(fields) {
+	return [
+		...fields.slice(0, 2),
+		"order",
+		...fields.slice(2)
+	];
+}
+var RuntimeDictionaryFields = {
+	wordEntities: withOrderKey(DictionaryFields.wordEntities),
+	termEntities: withOrderKey(DictionaryFields.termEntities),
+	domainEntities: withOrderKey(DictionaryFields.domainEntities)
+};
+var DictionaryKeyList = Object.keys(DictionaryFields);
+var KEPT_VALUES = 2;
+var isEmptyValue = (value) => value === "" || Array.isArray(value) && value.length === 0;
+function toDictionaryRows(key, entities, fields = DictionaryFields[key]) {
+	return {
+		fields: [...fields],
+		rows: entities.map((entity) => {
+			const row = fields.map((field) => Reflect.get(entity, field));
+			let end = row.length;
+			while (end > KEPT_VALUES && isEmptyValue(row[end - 1])) end--;
+			return row.slice(0, end);
+		})
+	};
+}
+function fromDictionaryRows(json) {
+	if (!isPlainObject(json)) return [];
+	const { fields, rows } = json;
+	if (Array.isArray(fields) && Array.isArray(rows)) return rows.filter(Array.isArray).map((row) => Object.fromEntries(fields.slice(0, row.length).map((field, index) => [field, row[index]])));
+	return Object.values(json).filter(isPlainObject);
+}
+var ROWS_PLACEHOLDER = /\n {6}"rows": \[\]/g;
+var isDictionaryRows = (value) => isPlainObject(value) && Array.isArray(value.rows);
+function stringifyDocument(source) {
+	if (!source.collections) return JSON.stringify(source, null, 2);
+	const blocks = [];
+	const collections = { ...source.collections };
+	for (const [key, collection] of Object.entries(collections)) {
+		if (!DictionaryKeyList.includes(key) || !isDictionaryRows(collection)) continue;
+		blocks.push(collection.rows);
+		collections[key] = {
+			...collection,
+			rows: []
+		};
+	}
+	let next = 0;
+	return JSON.stringify({
+		...source,
+		collections
+	}, null, 2).replace(ROWS_PLACEHOLDER, (placeholder) => {
+		const rows = blocks[next++] ?? [];
+		if (rows.length === 0) return placeholder;
+		return `\n      "rows": [\n${rows.map((row) => `        ${JSON.stringify(row)}`).join(",\n")}\n      ]`;
+	});
+}
+//#endregion
+export { DictionaryFields, DictionaryKeyList, RuntimeDictionaryFields, fromDictionaryRows, stringifyDocument, toDictionaryRows };

package/dist/erd-editor-schema/dist/helper.js

@@ -0,0 +1,28 @@
+import { isNumber, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/helper.js
+function assign(valid, target, source) {
+	return (key) => {
+		if (!source) return;
+		const value = source[key];
+		if (valid(value)) target[key] = value;
+	};
+}
+function entryId(key, entry) {
+	const id = Reflect.get(entry, "id");
+	return isString(id) && id !== "" ? id : key;
+}
+function validString(list) {
+	return (value) => isString(value) && list.includes(value);
+}
+function validNumber(list) {
+	return (value) => isNumber(value) && list.includes(value);
+}
+function propOr(target, propertyKey, defaultValue) {
+	return Reflect.get(target, propertyKey) ?? defaultValue;
+}
+function restoreSequence(ids, seqIds) {
+	const seq = new Set(seqIds);
+	return ids.every((id) => seq.has(id)) ? seqIds : [...ids];
+}
+//#endregion
+export { assign, entryId, propOr, restoreSequence, validNumber, validString };

package/dist/erd-editor-schema/dist/normalizeSettings.js

@@ -0,0 +1,24 @@
+import { LockSettingFields, LockSettingTypeList, NameViewMode, isSettingLocked } from "./v3/schema/settings.js";
+import { toSavedColumnOrder } from "./v3/parser/settings.js";
+import { pick } from "es-toolkit";
+//#region ../erd-editor-schema/dist/normalizeSettings.js
+function normalizeSettings(source) {
+	const { lockedValues, lockSettings, ddlScripts, nameViewMode, ...rest } = source;
+	const settings = {
+		...rest,
+		columnOrder: toSavedColumnOrder(rest.columnOrder),
+		lockSettings,
+		...ddlScripts && (ddlScripts.before !== "" || ddlScripts.after !== "") ? { ddlScripts: {
+			before: ddlScripts.before,
+			after: ddlScripts.after
+		} } : {},
+		...nameViewMode === void 0 ? {} : { nameViewMode }
+	};
+	LockSettingTypeList.forEach((lockSettingType) => {
+		if (lockedValues && isSettingLocked(lockSettings, lockSettingType)) Object.assign(settings, pick(lockedValues, LockSettingFields[lockSettingType]));
+	});
+	if (settings.nameViewMode === NameViewMode.physical) delete settings.nameViewMode;
+	return settings;
+}
+//#endregion
+export { normalizeSettings };

package/dist/erd-editor-schema/dist/orderKey.js

@@ -0,0 +1,139 @@
+//#region ../erd-editor-schema/dist/orderKey.js
+var DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var ZERO = DIGITS[0];
+var LAST = DIGITS[61];
+var SMALLEST_INTEGER = `A${ZERO.repeat(26)}`;
+var FIRST_KEY = `a${ZERO}`;
+function integerLength(head) {
+	if (head >= "a" && head <= "z") return head.charCodeAt(0) - 95;
+	if (head >= "A" && head <= "Z") return 92 - head.charCodeAt(0);
+	return 0;
+}
+var KEY_CHARACTERS = /^[A-Za-z][0-9A-Za-z]*$/;
+function isOrderKey(value) {
+	if (typeof value !== "string" || !KEY_CHARACTERS.test(value)) return false;
+	const length = integerLength(value[0]);
+	if (value.length < length || value === SMALLEST_INTEGER) return false;
+	return value.length === length || value[value.length - 1] !== ZERO;
+}
+function midpoint(a, b) {
+	if (b !== null) {
+		let shared = 0;
+		while ((a[shared] ?? ZERO) === b[shared]) shared++;
+		if (shared > 0) return b.slice(0, shared) + midpoint(a.slice(shared), b.slice(shared));
+	}
+	const digitA = a ? DIGITS.indexOf(a[0]) : 0;
+	const digitB = b !== null ? DIGITS.indexOf(b[0]) : 62;
+	if (digitB - digitA > 1) return DIGITS[Math.round((digitA + digitB) / 2)];
+	if (b !== null && b.length > 1) return b.slice(0, 1);
+	return DIGITS[digitA] + midpoint(a.slice(1), null);
+}
+function integerPart(key) {
+	return key.slice(0, integerLength(key[0]));
+}
+function incrementInteger(integer) {
+	const [head, ...digits] = integer.split("");
+	let carry = true;
+	for (let index = digits.length - 1; carry && index >= 0; index--) {
+		const next = DIGITS.indexOf(digits[index]) + 1;
+		if (next === 62) digits[index] = ZERO;
+		else {
+			digits[index] = DIGITS[next];
+			carry = false;
+		}
+	}
+	if (!carry) return head + digits.join("");
+	if (head === "Z") return `a${ZERO}`;
+	if (head === "z") return null;
+	const nextHead = String.fromCharCode(head.charCodeAt(0) + 1);
+	if (nextHead > "a") digits.push(ZERO);
+	else digits.pop();
+	return nextHead + digits.join("");
+}
+function decrementInteger(integer) {
+	const [head, ...digits] = integer.split("");
+	let borrow = true;
+	for (let index = digits.length - 1; borrow && index >= 0; index--) {
+		const next = DIGITS.indexOf(digits[index]) - 1;
+		if (next === -1) digits[index] = LAST;
+		else {
+			digits[index] = DIGITS[next];
+			borrow = false;
+		}
+	}
+	if (!borrow) return head + digits.join("");
+	if (head === "a") return `Z${LAST}`;
+	if (head === "A") return null;
+	const nextHead = String.fromCharCode(head.charCodeAt(0) - 1);
+	if (nextHead < "Z") digits.push(LAST);
+	else digits.pop();
+	return nextHead + digits.join("");
+}
+function generateOrderKeyBetween(a, b) {
+	if (a !== null && !isOrderKey(a)) throw new RangeError(`Bad key: ${a}`);
+	if (b !== null && !isOrderKey(b)) throw new RangeError(`Bad key: ${b}`);
+	if (a !== null && b !== null && a >= b) throw new RangeError(`${a} is not below ${b}`);
+	if (a === null) {
+		if (b === null) return FIRST_KEY;
+		const integer = integerPart(b);
+		const fraction = b.slice(integer.length);
+		if (integer === SMALLEST_INTEGER) return integer + midpoint("", fraction);
+		if (integer < b) return integer;
+		const lower = decrementInteger(integer);
+		if (lower === null) throw new RangeError("No key below");
+		return lower;
+	}
+	const integer = integerPart(a);
+	const fraction = a.slice(integer.length);
+	if (b === null) {
+		const higher = incrementInteger(integer);
+		return higher === null ? integer + midpoint(fraction, null) : higher;
+	}
+	const integerB = integerPart(b);
+	if (integer === integerB) return integer + midpoint(fraction, b.slice(integerB.length));
+	const higher = incrementInteger(integer);
+	if (higher !== null && higher < b) return higher;
+	return integer + midpoint(fraction, null);
+}
+function generateOrderKeys(a, b, n) {
+	if (n <= 0) return [];
+	if (n === 1) return [generateOrderKeyBetween(a, b)];
+	if (b === null) {
+		const keys = [generateOrderKeyBetween(a, null)];
+		while (keys.length < n) keys.push(generateOrderKeyBetween(keys[keys.length - 1], null));
+		return keys;
+	}
+	if (a === null) {
+		const keys = [generateOrderKeyBetween(null, b)];
+		while (keys.length < n) keys.unshift(generateOrderKeyBetween(null, keys[0]));
+		return keys;
+	}
+	const half = Math.floor(n / 2);
+	const middle = generateOrderKeyBetween(a, b);
+	return [
+		...generateOrderKeys(a, middle, half),
+		middle,
+		...generateOrderKeys(middle, b, n - half - 1)
+	];
+}
+var compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function compareByOrder(a, b) {
+	const keyedA = isOrderKey(a.order);
+	if (keyedA !== isOrderKey(b.order)) return keyedA ? -1 : 1;
+	return keyedA && compareText(a.order, b.order) || compareText(a.id, b.id);
+}
+function settleOrderKeys(entities, ids) {
+	const keyless = /* @__PURE__ */ new Set();
+	let last = null;
+	for (const id of ids) {
+		const entity = entities[id];
+		if (entity && !isOrderKey(entity.order)) keyless.add(entity);
+	}
+	for (const entity of Object.values(entities)) if (!isOrderKey(entity.order)) keyless.add(entity);
+	else if (last === null || entity.order > last) last = entity.order;
+	const keys = generateOrderKeys(last, null, keyless.size);
+	let index = 0;
+	for (const entity of keyless) entity.order = keys[index++];
+}
+//#endregion
+export { compareByOrder, generateOrderKeyBetween, generateOrderKeys, isOrderKey, settleOrderKeys };

package/dist/erd-editor-schema/dist/parser.js

@@ -0,0 +1,73 @@
+import { DictionaryKeyList, RuntimeDictionaryFields, stringifyDocument, toDictionaryRows } from "./dictionaryRows.js";
+import { resetPreLockView } from "./v3/parser/settings.js";
+import { parser as parser$1 } from "./v3/parser/index.js";
+import { parser as parser$2 } from "./v2/parser/index.js";
+import { v2ToV3 } from "./convert/v2ToV3.js";
+import { normalizeSettings } from "./normalizeSettings.js";
+import { mapValues, omit, pick } from "es-toolkit";
+//#region ../erd-editor-schema/dist/parser.js
+function parser(source) {
+	const json = JSON.parse(source);
+	if (Reflect.get(json, "version") === "3.0.0") return parser$1(json);
+	const schema = v2ToV3(parser$2(json));
+	resetPreLockView(schema.settings);
+	return schema;
+}
+function toJson(schemaV3) {
+	const source = pick(schemaV3, [
+		"$schema",
+		"version",
+		"settings",
+		"doc",
+		"collections"
+	]);
+	return stringifyDocument({
+		...source,
+		settings: normalizeSettings(source.settings),
+		...withoutEmptyFields(source)
+	});
+}
+var TABLE_DEFAULTS = {
+	logicalName: "",
+	groupId: "",
+	nameDerived: false
+};
+var COLUMN_DEFAULTS = {
+	logicalName: "",
+	domainId: ""
+};
+var DICTIONARY_IDS = {
+	wordEntities: "wordIds",
+	termEntities: "termIds",
+	domainEntities: "domainIds"
+};
+function withoutDefaults(entity, defaults) {
+	const left = Object.keys(defaults).filter((key) => Reflect.get(entity, key) === defaults[key]);
+	return left.length ? omit(entity, left) : entity;
+}
+function withoutEmptyFields({ doc, collections }) {
+	const hasGroups = (doc.tableGroupIds?.length ?? 0) !== 0 || Object.keys(collections.tableGroupEntities ?? {}).length !== 0;
+	const written = {
+		doc: hasGroups ? { ...doc } : omit(doc, ["tableGroupIds"]),
+		collections: {
+			...hasGroups ? collections : omit(collections, ["tableGroupEntities"]),
+			tableEntities: mapValues(collections.tableEntities ?? {}, (table) => withoutDefaults(table, TABLE_DEFAULTS))
+		}
+	};
+	if (collections.tableColumnEntities) written.collections.tableColumnEntities = mapValues(collections.tableColumnEntities, (column) => withoutDefaults(column, COLUMN_DEFAULTS));
+	for (const key of DictionaryKeyList) {
+		const idsKey = DICTIONARY_IDS[key];
+		const ids = doc[idsKey] ?? [];
+		const entities = Object.values(collections[key] ?? {});
+		if (ids.length === 0 && entities.length === 0) {
+			delete written.doc[idsKey];
+			delete written.collections[key];
+		} else {
+			written.doc[idsKey] = ids;
+			written.collections[key] = toDictionaryRows(key, entities, RuntimeDictionaryFields[key]);
+		}
+	}
+	return written;
+}
+//#endregion
+export { parser, toJson };

package/dist/erd-editor-schema/dist/query/index.js

@@ -0,0 +1,98 @@
+import { addOperator, removeOperator, replaceOperator } from "./lww.js";
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js";
+//#region ../erd-editor-schema/dist/query/index.js
+var Query = class {
+	constructor(collections) {
+		_defineProperty(this, "collections", void 0);
+		this.collections = collections;
+	}
+	collection(collection) {
+		return new CollectionQuery(this.collections[collection], collection);
+	}
+};
+var CollectionQuery = class {
+	constructor(collection, collectionKey) {
+		_defineProperty(this, "collection", void 0);
+		_defineProperty(this, "collectionKey", void 0);
+		this.collection = collection;
+		this.collectionKey = collectionKey;
+	}
+	selectById(id) {
+		return this.collection[id];
+	}
+	selectByIds(ids) {
+		ids.length;
+		return ids.map((id) => this.selectById(id)).filter(Boolean);
+	}
+	selectEntities() {
+		return this.collection;
+	}
+	selectAll() {
+		return Object.values(this.collection);
+	}
+	setOne(entity) {
+		this.collection[entity.id] = entity;
+		return this;
+	}
+	setMany(entities) {
+		entities.forEach((entity) => this.setOne(entity));
+		return this;
+	}
+	setAll(entities) {
+		this.removeAll();
+		this.setMany(entities);
+		return this;
+	}
+	addOne(entity) {
+		if (this.selectById(entity.id)) return this;
+		this.setOne(entity);
+		return this;
+	}
+	addMany(entities) {
+		entities.forEach((entity) => this.addOne(entity));
+		return this;
+	}
+	removeOne(id) {
+		if (this.selectById(id)) Reflect.deleteProperty(this.collection, id);
+		return this;
+	}
+	removeMany(ids) {
+		ids.forEach((id) => this.removeOne(id));
+		return this;
+	}
+	removeAll() {
+		this.collection = {};
+		return this;
+	}
+	updateOne(id, recipe) {
+		const entity = this.selectById(id);
+		if (entity) recipe(entity);
+		return this;
+	}
+	updateMany(ids, recipe) {
+		ids.forEach((id) => this.updateOne(id, recipe));
+		return this;
+	}
+	getOrCreate(id, recipe) {
+		const entity = this.selectById(id);
+		if (entity) return entity;
+		const newEntity = recipe(id);
+		this.setOne(newEntity);
+		return this.selectById(id);
+	}
+	addOperator(lww, version, id, recipe) {
+		addOperator(lww, version, id, this.collectionKey, recipe);
+		return this;
+	}
+	removeOperator(lww, version, id, recipe) {
+		removeOperator(lww, version, id, this.collectionKey, recipe);
+		return this;
+	}
+	replaceOperator(lww, version, id, path, recipe) {
+		replaceOperator(lww, version, id, this.collectionKey, path, recipe);
+		return this;
+	}
+};
+var query = (collections) => new Query(collections);
+//#endregion
+export { query };

package/dist/erd-editor-schema/dist/query/lww.js

@@ -0,0 +1,38 @@
+//#region ../erd-editor-schema/dist/query/lww.js
+function createLWWTuple(tag) {
+	return [
+		tag,
+		-1,
+		-1,
+		{}
+	];
+}
+function getOrCreate(lww, id, tag) {
+	const value = lww[id];
+	if (value) return value;
+	lww[id] = createLWWTuple(tag);
+	return lww[id];
+}
+function addOperator(lww, version, id, tag, recipe) {
+	const tuple = getOrCreate(lww, id, tag);
+	const prevVersion = tuple[1];
+	const removeVersion = tuple[2];
+	if (prevVersion < version) tuple[1] = version;
+	if (removeVersion < version) recipe();
+}
+function removeOperator(lww, version, id, tag, recipe) {
+	const tuple = getOrCreate(lww, id, tag);
+	const prevVersion = tuple[2];
+	const addVersion = tuple[1];
+	if (prevVersion < version) tuple[2] = version;
+	if (addVersion <= version) recipe();
+}
+function replaceOperator(lww, version, id, tag, path, recipe) {
+	const tuple = getOrCreate(lww, id, tag);
+	if ((tuple[3][path] ?? -1) <= version) {
+		tuple[3][path] = version;
+		recipe();
+	}
+}
+//#endregion
+export { addOperator, removeOperator, replaceOperator };