@case-framework/survey-core 0.1.0

package/build/editor.mjs

@@ -0,0 +1,603 @@
+import { D as structuredCloneMethod, T as generateId, n as GroupItemCore, r as SurveyItemTranslations, s as ReservedSurveyItemTypes, t as Survey } from "./survey-C3ZHI-5z.mjs";
+
+//#region src/editor/item-copy-paste.ts
+var ItemCopyPaste = class ItemCopyPaste {
+	survey;
+	constructor(survey) {
+		this.survey = survey;
+	}
+	/**
+	* Copy a survey item and all its data to clipboard format
+	* When copying a group, automatically includes all items in the subtree
+	* @param itemId - The id of the item to copy
+	* @returns Clipboard data that can be serialized to JSON for clipboard
+	*/
+	copyItem(itemId) {
+		if (!this.survey.surveyItems.get(itemId)) throw new Error(`Item with id '${itemId}' not found`);
+		const itemsToCopy = this.collectItemsForCopy(itemId);
+		const items = itemsToCopy.map((id) => {
+			const item = this.survey.surveyItems.get(id);
+			if (!item) throw new Error(`Item with id '${id}' not found during copy`);
+			return {
+				itemId: id,
+				itemData: item.rawItem
+			};
+		});
+		const translations = {};
+		itemsToCopy.forEach((id) => {
+			try {
+				const itemTranslations = this.survey.getItemTranslations(id);
+				if (itemTranslations?.locales?.length) {
+					const serializedTranslations = {};
+					itemTranslations.locales.forEach((locale) => {
+						const localeContent = itemTranslations.getAllForLocale(locale);
+						if (localeContent) serializedTranslations[locale] = localeContent;
+					});
+					translations[id] = serializedTranslations;
+				} else translations[id] = {};
+			} catch {
+				translations[id] = {};
+			}
+		});
+		return {
+			type: "survey-item",
+			version: "1.0.0",
+			items,
+			translations,
+			rootItemId: itemId,
+			timestamp: Date.now()
+		};
+	}
+	/**
+	* Collect all items that should be copied, including subtree for groups
+	* @param itemId - The root item id
+	* @returns Array of item keys to copy
+	*/
+	collectItemsForCopy(itemId) {
+		const itemsToCopy = [itemId];
+		const item = this.survey.surveyItems.get(itemId);
+		if (!item) return [];
+		if (item instanceof GroupItemCore) {
+			const childIds = item.items;
+			if (childIds.length > 0) childIds.forEach((childId) => {
+				const childItems = this.collectItemsForCopy(childId);
+				itemsToCopy.push(...childItems);
+			});
+		}
+		return itemsToCopy;
+	}
+	/**
+	* Add an item to its parent group.
+	* Ensures key uniqueness among siblings.
+	* @param target - Target location information
+	* @param item - The item to add (may have key adjusted for uniqueness)
+	*/
+	addItemToParentGroup(target, item) {
+		const parentGroup = this.survey.surveyItems.get(target.parentId);
+		if (!parentGroup) throw new Error(`Parent item with id '${target.parentId}' not found`);
+		if (!(parentGroup instanceof GroupItemCore)) throw new Error(`Parent item '${target.parentId}' is not a group item`);
+		const siblings = parentGroup.items.map((id) => this.survey.surveyItems.get(id)).filter((s) => s !== void 0);
+		const siblingKeys = new Set(siblings.map((s) => s.key));
+		let uniqueKey = item.key;
+		if (siblingKeys.has(uniqueKey)) {
+			let counter = 1;
+			const originalKey = item.key;
+			while (siblingKeys.has(uniqueKey)) {
+				uniqueKey = originalKey + `_${counter}`;
+				counter++;
+			}
+			if (uniqueKey !== item.key) {
+				const updatedRawItem = {
+					...item.rawItem,
+					key: uniqueKey
+				};
+				const newItem = this.survey.createItemFromRaw(updatedRawItem);
+				this.survey.surveyItems.delete(item.id);
+				this.survey.surveyItems.set(newItem.id, newItem);
+				item = newItem;
+			}
+		}
+		const insertIndex = target.index !== void 0 ? Math.min(target.index, parentGroup.items.length) : parentGroup.items.length;
+		parentGroup.addChild(item.id, insertIndex);
+	}
+	/**
+	* Paste a survey item from clipboard data to a target location
+	* Handles multiple items and subtrees from the clipboard data
+	* @param clipboardData - The clipboard data containing the item(s) to paste
+	* @param target - Target location where to paste the item
+	* @returns The id of the pasted root item
+	*/
+	pasteItem(clipboardData, target) {
+		if (!ItemCopyPaste.isValidClipboardData(clipboardData)) throw new Error("Invalid clipboard data format");
+		const idMapping = {};
+		clipboardData.items.forEach(({ itemId }) => {
+			idMapping[itemId] = generateId();
+		});
+		clipboardData.items.forEach(({ itemId, itemData }) => {
+			const newId = idMapping[itemId];
+			if (newId) {
+				const updatedItemData = this.updateItemIdsInData(itemData, idMapping);
+				updatedItemData.id = newId;
+				const newItem = this.survey.createItemFromRaw(updatedItemData);
+				this.survey.surveyItems.set(newItem.id, newItem);
+				if (itemId === clipboardData.rootItemId) this.addItemToParentGroup(target, newItem);
+			}
+		});
+		const updatedTranslations = this.updateTranslations(clipboardData.translations, idMapping);
+		Object.keys(updatedTranslations).forEach((itemId) => {
+			const itemTranslations = new SurveyItemTranslations();
+			const serializedData = updatedTranslations[itemId];
+			Object.keys(serializedData).forEach((locale) => {
+				itemTranslations.setAllForLocale(locale, serializedData[locale]);
+			});
+			this.survey.translations.setItemTranslations(itemId, itemTranslations);
+		});
+		return idMapping[clipboardData.rootItemId];
+	}
+	/**
+	* Update all item ids in the raw item data recursively
+	*/
+	updateItemIdsInData(itemData, idMapping) {
+		const updatedData = JSON.parse(JSON.stringify(itemData));
+		if (updatedData.itemType === ReservedSurveyItemTypes.Group && updatedData.config) {
+			const config = updatedData.config;
+			if (config.items) config.items = config.items.map((childId) => idMapping[childId] ?? childId);
+		}
+		this.updateExpressionsInItemData(updatedData, idMapping);
+		return updatedData;
+	}
+	/**
+	* Update expressions in item data that reference the old ids
+	*/
+	updateExpressionsInItemData(itemData, idMapping) {
+		if (itemData.displayConditions?.root) this.updateExpressionReferences(itemData.displayConditions.root, idMapping);
+		if (itemData.displayConditions?.components) Object.values(itemData.displayConditions.components).forEach((expr) => {
+			if (expr) this.updateExpressionReferences(expr, idMapping);
+		});
+		if (itemData.disabledConditions?.components) Object.values(itemData.disabledConditions.components).forEach((expr) => {
+			if (expr) this.updateExpressionReferences(expr, idMapping);
+		});
+		if (itemData.validations) Object.values(itemData.validations).forEach((expr) => {
+			if (expr) this.updateExpressionReferences(expr, idMapping);
+		});
+	}
+	/**
+	* Update references in a single expression (recursive)
+	*/
+	updateExpressionReferences(expression, idMapping) {
+		if (!expression || typeof expression !== "object") return;
+		const expr = expression;
+		if (Array.isArray(expr.data)) expr.data.forEach((arg) => {
+			if (arg && typeof arg === "object" && arg !== null && "str" in arg) {
+				const argObj = arg;
+				if (typeof argObj.str === "string" && Object.prototype.hasOwnProperty.call(idMapping, argObj.str)) argObj.str = idMapping[argObj.str];
+				this.updateExpressionReferences(arg, idMapping);
+			}
+		});
+		Object.keys(expr).forEach((key) => {
+			const val = expr[key];
+			if (val && typeof val === "object") this.updateExpressionReferences(val, idMapping);
+		});
+	}
+	/**
+	* Update translation keys for the pasted item
+	*/
+	updateTranslations(translations, idMapping) {
+		const newTranslations = {};
+		Object.keys(translations).forEach((itemId) => {
+			const itemTranslations = translations[itemId];
+			const newItemId = idMapping[itemId];
+			newTranslations[newItemId] = itemTranslations;
+		});
+		return newTranslations;
+	}
+	/**
+	* Validate clipboard data format
+	*/
+	static isValidClipboardData(data) {
+		if (typeof data !== "object" || data === null || data === void 0) return false;
+		const clipboardData = data;
+		return clipboardData.type === "survey-item" && clipboardData.version === "1.0.0" && clipboardData.rootItemId !== void 0;
+	}
+};
+
+//#endregion
+//#region src/editor/undo-redo.ts
+const CommitSource = {
+	USER: "user",
+	SYSTEM: "system"
+};
+var MemoryCalculator = class {
+	static encoder = new TextEncoder();
+	static calculateSize(obj) {
+		const jsonString = JSON.stringify(obj);
+		return this.encoder.encode(jsonString).length;
+	}
+	static formatBytes(bytes) {
+		const units = [
+			"B",
+			"KB",
+			"MB",
+			"GB"
+		];
+		let size = bytes;
+		let unitIndex = 0;
+		while (size >= 1024 && unitIndex < units.length - 1) {
+			size /= 1024;
+			unitIndex++;
+		}
+		return `${size.toFixed(1)} ${units[unitIndex]}`;
+	}
+};
+var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
+	history = [];
+	currentIndex = -1;
+	_config;
+	constructor(initialSurvey, config = {}, meta = {
+		label: "Initial state",
+		source: CommitSource.SYSTEM
+	}) {
+		this._config = {
+			maxTotalMemoryMB: 50,
+			minHistorySize: 10,
+			maxHistorySize: 200,
+			...config
+		};
+		this.saveSnapshot(initialSurvey, meta);
+	}
+	saveSnapshot(survey, meta) {
+		const memorySize = MemoryCalculator.calculateSize(survey);
+		this.history = this.history.slice(0, this.currentIndex + 1);
+		this.history.push({
+			survey: structuredCloneMethod(survey),
+			timestamp: Date.now(),
+			meta,
+			memorySize
+		});
+		this.currentIndex++;
+		this.cleanupHistory();
+	}
+	cleanupHistory() {
+		let totalMemory = this.getTotalMemoryUsage();
+		const maxMemoryBytes = this._config.maxTotalMemoryMB * 1024 * 1024;
+		while (this.history.length > this._config.minHistorySize && (totalMemory > maxMemoryBytes || this.history.length > this._config.maxHistorySize)) {
+			const removedSnapshot = this.history.shift();
+			this.currentIndex--;
+			if (removedSnapshot) totalMemory -= removedSnapshot.memorySize;
+		}
+	}
+	getTotalMemoryUsage() {
+		return this.history.reduce((total, entry) => total + entry.memorySize, 0);
+	}
+	commit(survey, meta) {
+		this.saveSnapshot(survey, meta);
+	}
+	getCurrentState() {
+		if (this.currentIndex < 0 || this.currentIndex >= this.history.length) throw new Error("Invalid history state");
+		return structuredCloneMethod(this.history[this.currentIndex].survey);
+	}
+	undo() {
+		if (!this.canUndo()) return null;
+		this.currentIndex--;
+		return this.getCurrentState();
+	}
+	redo() {
+		if (!this.canRedo()) return null;
+		this.currentIndex++;
+		return this.getCurrentState();
+	}
+	canUndo() {
+		return this.currentIndex > 0;
+	}
+	canRedo() {
+		return this.currentIndex < this.history.length - 1;
+	}
+	getUndoMeta() {
+		if (!this.canUndo()) return null;
+		return this.history[this.currentIndex].meta;
+	}
+	getRedoMeta() {
+		if (!this.canRedo()) return null;
+		return this.history[this.currentIndex + 1].meta;
+	}
+	getMemoryUsage() {
+		return {
+			totalMB: this.getTotalMemoryUsage() / (1024 * 1024),
+			entries: this.history.length
+		};
+	}
+	getConfig() {
+		return { ...this._config };
+	}
+	/**
+	* Get the full history list with metadata
+	*/
+	getHistory() {
+		return this.history.map((entry, index) => ({
+			index,
+			meta: entry.meta,
+			timestamp: entry.timestamp,
+			memorySize: entry.memorySize,
+			isCurrent: index === this.currentIndex
+		}));
+	}
+	/**
+	* Get the current index in the history
+	*/
+	getCurrentIndex() {
+		return this.currentIndex;
+	}
+	/**
+	* Get the total number of history entries
+	*/
+	getHistoryLength() {
+		return this.history.length;
+	}
+	/**
+	* Jump to a specific index in the history (can go forward or backward)
+	* @param targetIndex The index to jump to
+	* @returns The survey state at the target index, or null if invalid
+	*/
+	jumpToIndex(targetIndex) {
+		if (targetIndex < 0 || targetIndex >= this.history.length || targetIndex === this.currentIndex) return null;
+		this.currentIndex = targetIndex;
+		return this.getCurrentState();
+	}
+	/**
+	* Check if we can jump to a specific index
+	*/
+	canJumpToIndex(targetIndex) {
+		return targetIndex >= 0 && targetIndex < this.history.length && targetIndex !== this.currentIndex;
+	}
+	/**
+	* Serialize the undo/redo state to JSON
+	* @returns A JSON-serializable object containing the complete state
+	*/
+	serialize() {
+		return {
+			history: this.history.map((entry) => ({
+				survey: entry.survey,
+				timestamp: entry.timestamp,
+				meta: entry.meta,
+				memorySize: entry.memorySize
+			})),
+			currentIndex: this.currentIndex,
+			config: { ...this._config }
+		};
+	}
+	/**
+	* Create a new SurveyEditorUndoRedo instance from JSON data
+	* @param jsonData The serialized undo/redo state
+	* @returns A new SurveyEditorUndoRedo instance with the restored state
+	*/
+	static deserialize(jsonData) {
+		if (!jsonData.history || !Array.isArray(jsonData.history) || jsonData.history.length === 0) throw new Error("Invalid object: history must be an array and must not be empty");
+		if (typeof jsonData.currentIndex !== "number" || jsonData.currentIndex < 0 || jsonData.currentIndex >= jsonData.history.length) throw new Error("Invalid object: currentIndex must be a valid index within the history array");
+		if (!jsonData.config) throw new Error("Invalid object: config is required");
+		const instance = new SurveyEditorUndoRedo(jsonData.history[0].survey, jsonData.config);
+		instance.history = jsonData.history.map((entry) => ({
+			survey: structuredCloneMethod(entry.survey),
+			timestamp: entry.timestamp,
+			meta: entry.meta,
+			memorySize: entry.memorySize
+		}));
+		instance.currentIndex = jsonData.currentIndex;
+		return instance;
+	}
+};
+
+//#endregion
+//#region src/editor/survey-editor.ts
+var SurveyEditor = class SurveyEditor {
+	_survey;
+	_undoRedo;
+	_hasUncommittedChanges = false;
+	_pluginRegistry;
+	constructor(survey, config = {}, meta) {
+		this._survey = survey;
+		const { pluginRegistry, ...undoRedoConfig } = config;
+		this._pluginRegistry = pluginRegistry;
+		this._undoRedo = new SurveyEditorUndoRedo(survey.serialize(), undoRedoConfig, meta);
+	}
+	get survey() {
+		return this._survey;
+	}
+	get hasUncommittedChanges() {
+		return this._hasUncommittedChanges;
+	}
+	get undoRedo() {
+		return this._undoRedo;
+	}
+	commit(meta) {
+		this._undoRedo.commit(this._survey.serialize(), meta);
+		this._hasUncommittedChanges = false;
+	}
+	commitIfNeeded() {
+		if (this._hasUncommittedChanges) this.commit({
+			label: "Latest content changes",
+			source: CommitSource.SYSTEM
+		});
+	}
+	undo() {
+		if (this._hasUncommittedChanges) {
+			this._survey = Survey.fromJson(this._undoRedo.getCurrentState(), this._pluginRegistry);
+			this._hasUncommittedChanges = false;
+			return true;
+		} else {
+			const previousState = this._undoRedo.undo();
+			if (previousState) {
+				this._survey = Survey.fromJson(previousState, this._pluginRegistry);
+				this._hasUncommittedChanges = false;
+				return true;
+			}
+			return false;
+		}
+	}
+	redo() {
+		if (this._hasUncommittedChanges) return false;
+		const nextState = this._undoRedo.redo();
+		if (nextState) {
+			this._survey = Survey.fromJson(nextState, this._pluginRegistry);
+			this._hasUncommittedChanges = false;
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Jump to a specific index in the history (can go forward or backward)
+	*/
+	jumpToIndex(targetIndex) {
+		if (this._hasUncommittedChanges) return false;
+		const targetState = this._undoRedo.jumpToIndex(targetIndex);
+		if (targetState) {
+			this._survey = Survey.fromJson(targetState, this._pluginRegistry);
+			this._hasUncommittedChanges = false;
+			return true;
+		}
+		return false;
+	}
+	canUndo() {
+		return this._hasUncommittedChanges || this._undoRedo.canUndo();
+	}
+	canRedo() {
+		return !this._hasUncommittedChanges && this._undoRedo.canRedo();
+	}
+	getUndoMeta() {
+		if (this._hasUncommittedChanges) return {
+			label: "Latest content changes",
+			source: CommitSource.SYSTEM
+		};
+		return this._undoRedo.getUndoMeta();
+	}
+	getRedoMeta() {
+		if (this._hasUncommittedChanges) return null;
+		return this._undoRedo.getRedoMeta();
+	}
+	getMemoryUsage() {
+		return this._undoRedo.getMemoryUsage();
+	}
+	getUndoRedoConfig() {
+		return this._undoRedo.getConfig();
+	}
+	/**
+	* Serialize the SurveyEditor state to JSON
+	* @returns A JSON-serializable object containing the complete editor state
+	*/
+	toJson() {
+		return {
+			version: "1.0.0",
+			survey: this._survey.serialize(),
+			undoRedo: this._undoRedo.serialize(),
+			hasUncommittedChanges: this._hasUncommittedChanges
+		};
+	}
+	/**
+	* Create a new SurveyEditor instance from JSON data
+	* @param jsonData The serialized editor state
+	* @param pluginRegistry Optional plugin registry for deserializing survey state (required when survey contains custom item types)
+	* @returns A new SurveyEditor instance with the restored state
+	*/
+	static fromJson(jsonData, pluginRegistry) {
+		if (!jsonData.survey) throw new Error("Invalid object: survey is required");
+		if (!jsonData.undoRedo) throw new Error("Invalid object: undoRedo is required");
+		if (typeof jsonData.hasUncommittedChanges !== "boolean") throw new Error("Invalid object: hasUncommittedChanges must be a boolean");
+		if (jsonData.version && !jsonData.version.startsWith("1.")) console.warn(`Warning: Loading SurveyEditor with version ${jsonData.version}, current version is 1.0.0`);
+		const editor = new SurveyEditor(Survey.fromJson(jsonData.survey, pluginRegistry), { pluginRegistry });
+		editor._undoRedo = SurveyEditorUndoRedo.deserialize(jsonData.undoRedo);
+		editor._hasUncommittedChanges = jsonData.hasUncommittedChanges;
+		return editor;
+	}
+	markAsModified() {
+		this._hasUncommittedChanges = true;
+	}
+	addItem(target, item, content) {
+		this.markAsModified();
+		let parentGroup;
+		if (!target) {
+			const rootItem = this._survey.rootItem;
+			if (!rootItem) throw new Error("No root group found in survey");
+			if (!(rootItem instanceof GroupItemCore)) throw new Error("Root item is not a group item");
+			parentGroup = rootItem;
+		} else {
+			const targetItem = this._survey.surveyItems.get(target.parentId);
+			if (!targetItem) throw new Error(`Parent item with id '${target.parentId}' not found`);
+			if (!(targetItem instanceof GroupItemCore)) throw new Error(`Parent item '${target.parentId}' is not a group item (${targetItem.type})`);
+			parentGroup = targetItem;
+		}
+		if (parentGroup.hasChild(item.id)) throw new Error(`Item ${item.id} already in this group`);
+		const siblings = Array.from(this._survey.surveyItems.values()).filter((sItem) => parentGroup.items?.includes(sItem.id));
+		let counter = 1;
+		while (siblings.some((sibling) => sibling.key === item.key)) {
+			item.key += `_${counter}`;
+			counter++;
+		}
+		let insertIndex;
+		if (target?.index !== void 0) insertIndex = Math.min(target.index, parentGroup.items.length);
+		else insertIndex = parentGroup.items.length;
+		this._survey.surveyItems.set(item.id, item);
+		parentGroup.items.splice(insertIndex, 0, item.id);
+		if (content) this._survey.translations.setItemTranslations(item.id, content);
+	}
+	removeItem(itemId, nested = false) {
+		this.markAsModified();
+		const item = this._survey.surveyItems.get(itemId);
+		if (!item) return false;
+		const parentItem = this._survey.getParentItem(itemId);
+		if (!parentItem) throw new Error(`Item with id '${itemId}' is the root item`);
+		if (item instanceof GroupItemCore) for (const childId of item.getChildrenIds()) this.removeItem(childId, true);
+		this._survey.surveyItems.delete(itemId);
+		this._survey.translations?.onItemDeleted(itemId);
+		if (!nested) parentItem.removeChild(itemId);
+		return true;
+	}
+	moveItem(itemId, newTarget) {
+		this.markAsModified();
+		const item = this._survey.surveyItems.get(itemId);
+		if (!item) throw new Error(`Item with id '${itemId}' not found`);
+		const targetItem = this._survey.surveyItems.get(newTarget.parentId);
+		if (!targetItem) throw new Error(`Target parent with id '${newTarget.parentId}' not found`);
+		if (!(targetItem instanceof GroupItemCore)) throw new Error(`Target parent '${newTarget.parentId}' is not a group item (${targetItem.type})`);
+		if (this._survey.isDescendantOf(newTarget.parentId, itemId)) throw new Error(`Cannot move item '${itemId}' to its descendant '${newTarget.parentId}'`);
+		const currentParentItem = this._survey.getParentItem(itemId);
+		if (currentParentItem?.id === newTarget.parentId) throw new Error(`Item '${itemId}' is already in the target parent '${newTarget.parentId}'`);
+		if (currentParentItem) currentParentItem.removeChild(itemId);
+		const targetGroup = targetItem;
+		const siblings = Array.from(this._survey.surveyItems.values()).filter((sItem) => targetGroup.hasChild(sItem.id));
+		let counter = 1;
+		while (siblings.some((sibling) => sibling.key === item.key)) {
+			item.key += `_${counter}`;
+			counter++;
+		}
+		const insertIndex = newTarget.index !== void 0 ? Math.min(newTarget.index, targetGroup.items.length) : targetGroup.items.length;
+		targetGroup.items.splice(insertIndex, 0, itemId);
+		return true;
+	}
+	updateItemTranslations(itemId, updatedContent) {
+		this.markAsModified();
+		if (!this._survey.surveyItems.get(itemId)) throw new Error(`Item with id '${itemId}' not found`);
+		this._survey.translations.setItemTranslations(itemId, updatedContent);
+		return true;
+	}
+	/**
+	* Copy a survey item and all its data to clipboard format
+	* @param itemKey - The full key of the item to copy
+	* @returns Clipboard data that can be serialized to JSON for clipboard
+	*/
+	copyItem(itemKey) {
+		return new ItemCopyPaste(this._survey).copyItem(itemKey);
+	}
+	/**
+	* Paste a survey item from clipboard data to a target location
+	* @param clipboardData - The clipboard data containing the item to paste
+	* @param target - Target location where to paste the item
+	* @returns The full key of the pasted item
+	*/
+	pasteItem(clipboardData, target) {
+		this.markAsModified();
+		return new ItemCopyPaste(this._survey).pasteItem(clipboardData, target);
+	}
+};
+
+//#endregion
+export { CommitSource, ItemCopyPaste, SurveyEditor, SurveyEditorUndoRedo };
+//# sourceMappingURL=editor.mjs.map