@case-framework/survey-core 0.3.0 → 0.4.1

package/build/editor.mjs

@@ -1,4 +1,4 @@
-import { I as generateId, R as structuredCloneMethod, l as GroupItemCore, m as ReservedSurveyItemTypes, n as SurveyItemTranslations, t as Survey } from "./survey-DJbgFVPz.mjs";
+import { $ as generateId, a as getContentPlainText, nt as structuredCloneMethod, t as Survey, u as SurveyItemTranslations, v as GroupItemCore } from "./survey-DnLtf19j.mjs";
 //#region src/editor/ai-context.ts
 const DEFAULT_SCOPE_LIMITS = {
 	tiny: 40,
@@ -174,10 +174,7 @@ const normalizeSnippetText = (text, maxChars) => {
 	return text.trim().replace(/\s+/g, " ").slice(0, maxChars);
 };
 const getContentText = (content, maxChars) => {
-	if (!content) return null;
-	const maybeText = content.content;
-	if (typeof maybeText !== "string") return null;
-	const normalized = normalizeSnippetText(maybeText, maxChars);
+	const normalized = normalizeSnippetText(getContentPlainText(content), maxChars);
 	return normalized.length > 0 ? normalized : null;
 };
 function getItemTranslationSnippets(survey, itemId, maxSnippets, textLimit) {
@@ -439,7 +436,7 @@ var ItemCopyPaste = class ItemCopyPaste {
 	*/
 	updateItemIdsInData(itemData, idMapping) {
 		const updatedData = JSON.parse(JSON.stringify(itemData));
-		if (updatedData.itemType === ReservedSurveyItemTypes.Group && updatedData.config) {
+		if (updatedData.itemType === "group" && updatedData.config) {
 			const config = updatedData.config;
 			if (config.items) config.items = config.items.map((childId) => idMapping[childId] ?? childId);
 		}
@@ -460,6 +457,11 @@ var ItemCopyPaste = class ItemCopyPaste {
 		if (itemData.validations) Object.values(itemData.validations).forEach((expr) => {
 			if (expr) this.updateExpressionReferences(expr, idMapping);
 		});
+		if (itemData.prefills) itemData.prefills.forEach((prefill) => {
+			if (prefill.when) this.updateExpressionReferences(prefill.when, idMapping);
+			if (prefill.source.type === "expression") this.updateExpressionReferences(prefill.source.expression, idMapping);
+			if (prefill.source.type === "previousResponse") prefill.source.ref.itemId = idMapping[prefill.source.ref.itemId] ?? prefill.source.ref.itemId;
+		});
 	}
 	/**
 	* Update references in a single expression (recursive)
@@ -528,52 +530,152 @@ var MemoryCalculator = class {
 		return `${size.toFixed(1)} ${units[unitIndex]}`;
 	}
 };
+function cloneAssets(assets) {
+	if (!assets || Object.keys(assets).length === 0) return;
+	return structuredCloneMethod(assets);
+}
+function normalizeHistoryEntry(entry) {
+	if ("kind" in entry) {
+		if (entry.kind === "survey-snapshot") return {
+			kind: "survey-snapshot",
+			survey: structuredCloneMethod(entry.survey),
+			timestamp: entry.timestamp,
+			meta: entry.meta,
+			memorySize: entry.memorySize
+		};
+		return {
+			kind: "asset-change",
+			changes: structuredCloneMethod(entry.changes),
+			timestamp: entry.timestamp,
+			meta: entry.meta,
+			memorySize: entry.memorySize
+		};
+	}
+	return {
+		kind: "survey-snapshot",
+		survey: structuredCloneMethod(entry.survey),
+		timestamp: entry.timestamp,
+		meta: entry.meta,
+		memorySize: entry.memorySize
+	};
+}
 var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	history = [];
 	currentIndex = -1;
 	_config;
+	_initialAssets;
 	constructor(initialSurvey, config = {}, meta = {
 		label: "Initial state",
 		source: CommitSource.SYSTEM
-	}) {
+	}, initialAssets) {
 		this._config = {
 			maxTotalMemoryMB: 50,
 			minHistorySize: 10,
 			maxHistorySize: 200,
 			...config
 		};
+		this._initialAssets = cloneAssets(initialAssets);
 		this.saveSnapshot(initialSurvey, meta);
 	}
-	saveSnapshot(survey, meta) {
-		const memorySize = MemoryCalculator.calculateSize(survey);
+	saveEntry(entry) {
+		const payload = entry.kind === "survey-snapshot" ? {
+			kind: entry.kind,
+			survey: entry.survey
+		} : {
+			kind: entry.kind,
+			changes: entry.changes
+		};
+		const memorySize = MemoryCalculator.calculateSize(payload);
 		this.history = this.history.slice(0, this.currentIndex + 1);
 		this.history.push({
-			survey: structuredCloneMethod(survey),
+			...structuredCloneMethod(entry),
 			timestamp: Date.now(),
-			meta,
 			memorySize
 		});
 		this.currentIndex++;
 		this.cleanupHistory();
 	}
+	saveSnapshot(survey, meta) {
+		this.saveEntry({
+			kind: "survey-snapshot",
+			survey: structuredCloneMethod(survey),
+			meta
+		});
+	}
+	getBaseAssetsSize() {
+		return this._initialAssets ? MemoryCalculator.calculateSize(this._initialAssets) : 0;
+	}
 	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;
-		}
+		while (this.history.length > this._config.minHistorySize && (this.getTotalMemoryUsage() > maxMemoryBytes || this.history.length > this._config.maxHistorySize)) if (this.dropOldestState() <= 0) break;
+	}
+	dropOldestState() {
+		if (this.history.length <= 1) return 0;
+		const nextStateIndex = 1;
+		const nextStateSurvey = this.getStateAtIndex(nextStateIndex);
+		const nextStateAssets = this.getAssetsAtIndex(nextStateIndex);
+		const nextEntry = this.history[nextStateIndex];
+		const newFirstEntry = {
+			kind: "survey-snapshot",
+			survey: nextStateSurvey,
+			meta: nextEntry.meta,
+			timestamp: nextEntry.timestamp,
+			memorySize: MemoryCalculator.calculateSize({
+				kind: "survey-snapshot",
+				survey: nextStateSurvey
+			})
+		};
+		const removedBytes = this.history[0].memorySize;
+		this._initialAssets = cloneAssets(nextStateAssets);
+		this.history = [newFirstEntry, ...this.history.slice(nextStateIndex + 1)];
+		this.currentIndex--;
+		return removedBytes;
 	}
 	getTotalMemoryUsage() {
-		return this.history.reduce((total, entry) => total + entry.memorySize, 0);
+		return this.getBaseAssetsSize() + this.history.reduce((total, entry) => total + entry.memorySize, 0);
+	}
+	getStateAtIndex(index) {
+		if (index < 0 || index >= this.history.length) throw new Error("Invalid history state");
+		for (let i = index; i >= 0; i--) {
+			const entry = this.history[i];
+			if (entry.kind === "survey-snapshot") return structuredCloneMethod(entry.survey);
+		}
+		throw new Error("Invalid history state");
+	}
+	applyAssetPatch(assets, patch) {
+		const nextAssets = structuredCloneMethod(assets);
+		if (patch.next) nextAssets[patch.assetId] = structuredCloneMethod(patch.next);
+		else delete nextAssets[patch.assetId];
+		return nextAssets;
+	}
+	getAssetsAtIndex(index) {
+		if (index < 0 || index >= this.history.length) throw new Error("Invalid history state");
+		let assets = cloneAssets(this._initialAssets) ?? {};
+		for (let i = 1; i <= index; i++) {
+			const entry = this.history[i];
+			if (entry.kind !== "asset-change") continue;
+			for (const patch of entry.changes) assets = this.applyAssetPatch(assets, patch);
+		}
+		return Object.keys(assets).length > 0 ? assets : void 0;
 	}
 	commit(survey, meta) {
 		this.saveSnapshot(survey, meta);
 	}
+	commitAssetChange(changes, meta) {
+		if (changes.length === 0) return;
+		this.saveEntry({
+			kind: "asset-change",
+			changes: structuredCloneMethod(changes),
+			meta
+		});
+	}
 	getCurrentState() {
 		if (this.currentIndex < 0 || this.currentIndex >= this.history.length) throw new Error("Invalid history state");
-		return structuredCloneMethod(this.history[this.currentIndex].survey);
+		return this.getStateAtIndex(this.currentIndex);
+	}
+	getCurrentAssets() {
+		if (this.currentIndex < 0 || this.currentIndex >= this.history.length) throw new Error("Invalid history state");
+		return this.getAssetsAtIndex(this.currentIndex);
 	}
 	undo() {
 		if (!this.canUndo()) return null;
@@ -614,6 +716,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	getHistory() {
 		return this.history.map((entry, index) => ({
 			index,
+			kind: entry.kind,
 			meta: entry.meta,
 			timestamp: entry.timestamp,
 			memorySize: entry.memorySize,
@@ -621,6 +724,25 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		}));
 	}
 	/**
+	* Get committed history entries after the initial state up to the current index.
+	*
+	* Redo-only future entries are intentionally omitted so the returned list describes the active
+	* change chain from the initial state to the current editor state.
+	*/
+	getCommitsSinceInitial() {
+		return this.history.slice(1, this.currentIndex + 1).map((entry, offset) => {
+			const index = offset + 1;
+			return {
+				index,
+				kind: entry.kind,
+				meta: entry.meta,
+				timestamp: entry.timestamp,
+				memorySize: entry.memorySize,
+				isCurrent: index === this.currentIndex
+			};
+		});
+	}
+	/**
 	* Get the current index in the history
 	*/
 	getCurrentIndex() {
@@ -654,14 +776,25 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	*/
 	serialize() {
 		return {
-			history: this.history.map((entry) => ({
-				survey: entry.survey,
-				timestamp: entry.timestamp,
-				meta: entry.meta,
-				memorySize: entry.memorySize
-			})),
+			history: this.history.map((entry) => {
+				if (entry.kind === "survey-snapshot") return {
+					kind: "survey-snapshot",
+					survey: entry.survey,
+					timestamp: entry.timestamp,
+					meta: entry.meta,
+					memorySize: entry.memorySize
+				};
+				return {
+					kind: "asset-change",
+					changes: entry.changes,
+					timestamp: entry.timestamp,
+					meta: entry.meta,
+					memorySize: entry.memorySize
+				};
+			}),
 			currentIndex: this.currentIndex,
-			config: { ...this._config }
+			config: { ...this._config },
+			initialAssets: cloneAssets(this._initialAssets)
 		};
 	}
 	/**
@@ -669,23 +802,34 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	* @param jsonData The serialized undo/redo state
 	* @returns A new SurveyEditorUndoRedo instance with the restored state
 	*/
-	static deserialize(jsonData) {
+	static deserialize(jsonData, initialAssetsOverride) {
 		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
-		}));
+		const normalizedHistory = jsonData.history.map(normalizeHistoryEntry);
+		const firstEntry = normalizedHistory[0];
+		const instance = new SurveyEditorUndoRedo(firstEntry.kind === "survey-snapshot" ? firstEntry.survey : (() => {
+			throw new Error("Invalid object: first history entry must resolve to a survey snapshot");
+		})(), jsonData.config, firstEntry.meta, initialAssetsOverride ?? jsonData.initialAssets);
+		instance.history = normalizedHistory;
 		instance.currentIndex = jsonData.currentIndex;
+		instance._initialAssets = cloneAssets(initialAssetsOverride ?? jsonData.initialAssets);
 		return instance;
 	}
 };
 //#endregion
 //#region src/editor/survey-editor.ts
+function stripAssetsFromSurveySnapshot(survey) {
+	const snapshot = structuredCloneMethod(survey);
+	delete snapshot.assets;
+	return snapshot;
+}
+function mergeSurveySnapshotWithAssets(snapshot, assets) {
+	const merged = structuredCloneMethod(snapshot);
+	if (assets && Object.keys(assets).length > 0) merged.assets = structuredCloneMethod(assets);
+	else delete merged.assets;
+	return merged;
+}
 var SurveyEditor = class SurveyEditor {
 	_survey;
 	_undoRedo;
@@ -695,7 +839,8 @@ var SurveyEditor = class SurveyEditor {
 		this._survey = survey;
 		const { pluginRegistry, ...undoRedoConfig } = config;
 		this._pluginRegistry = pluginRegistry;
-		this._undoRedo = new SurveyEditorUndoRedo(survey.serialize(), undoRedoConfig, meta);
+		const serialized = survey.serialize();
+		this._undoRedo = new SurveyEditorUndoRedo(stripAssetsFromSurveySnapshot(serialized), undoRedoConfig, meta, serialized.assets);
 	}
 	/** Returns an immutable copy of the current survey state. */
 	get survey() {
@@ -710,9 +855,13 @@ var SurveyEditor = class SurveyEditor {
 		return this._undoRedo;
 	}
 	commit(meta) {
-		this._undoRedo.commit(this._survey.serialize(), meta);
+		if (!this._hasUncommittedChanges) return;
+		this._undoRedo.commit(stripAssetsFromSurveySnapshot(this._survey.serialize()), meta);
 		this._hasUncommittedChanges = false;
 	}
+	restoreHistoryState(snapshot, assets) {
+		this._survey = Survey.fromJson(mergeSurveySnapshotWithAssets(snapshot, assets), this._pluginRegistry);
+	}
 	commitIfNeeded() {
 		if (this._hasUncommittedChanges) this.commit({
 			label: "Latest content changes",
@@ -721,13 +870,13 @@ var SurveyEditor = class SurveyEditor {
 	}
 	undo() {
 		if (this._hasUncommittedChanges) {
-			this._survey = Survey.fromJson(this._undoRedo.getCurrentState(), this._pluginRegistry);
+			this.restoreHistoryState(this._undoRedo.getCurrentState(), this._undoRedo.getCurrentAssets());
 			this._hasUncommittedChanges = false;
 			return true;
 		} else {
 			const previousState = this._undoRedo.undo();
 			if (previousState) {
-				this._survey = Survey.fromJson(previousState, this._pluginRegistry);
+				this.restoreHistoryState(previousState, this._undoRedo.getCurrentAssets());
 				this._hasUncommittedChanges = false;
 				return true;
 			}
@@ -738,7 +887,7 @@ var SurveyEditor = class SurveyEditor {
 		if (this._hasUncommittedChanges) return false;
 		const nextState = this._undoRedo.redo();
 		if (nextState) {
-			this._survey = Survey.fromJson(nextState, this._pluginRegistry);
+			this.restoreHistoryState(nextState, this._undoRedo.getCurrentAssets());
 			this._hasUncommittedChanges = false;
 			return true;
 		}
@@ -751,7 +900,7 @@ var SurveyEditor = class SurveyEditor {
 		if (this._hasUncommittedChanges) return false;
 		const targetState = this._undoRedo.jumpToIndex(targetIndex);
 		if (targetState) {
-			this._survey = Survey.fromJson(targetState, this._pluginRegistry);
+			this.restoreHistoryState(targetState, this._undoRedo.getCurrentAssets());
 			this._hasUncommittedChanges = false;
 			return true;
 		}
@@ -781,6 +930,12 @@ var SurveyEditor = class SurveyEditor {
 		return this._undoRedo.getConfig();
 	}
 	/**
+	* Get committed changes after the initial editor state up to the current undo/redo position.
+	*/
+	getCommitsSinceInitial() {
+		return this._undoRedo.getCommitsSinceInitial();
+	}
+	/**
 	* Serialize the SurveyEditor state to JSON
 	* @returns A JSON-serializable object containing the complete editor state
 	*/
@@ -804,8 +959,14 @@ var SurveyEditor = class SurveyEditor {
 		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;
+		editor._undoRedo = SurveyEditorUndoRedo.deserialize({
+			...jsonData.undoRedo,
+			history: jsonData.undoRedo.history.map((entry) => "survey" in entry ? {
+				...entry,
+				survey: stripAssetsFromSurveySnapshot(entry.survey)
+			} : entry)
+		}, jsonData.survey.assets);
+		editor._hasUncommittedChanges = JSON.stringify(stripAssetsFromSurveySnapshot(jsonData.survey)) !== JSON.stringify(editor._undoRedo.getCurrentState());
 		return editor;
 	}
 	markAsModified() {
@@ -919,8 +1080,8 @@ var SurveyEditor = class SurveyEditor {
 		this.markAsModified();
 	}
 	updateItemTranslations(itemId, updatedContent) {
+		if (!this._survey.surveyItems.get(itemId)) return false;
 		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;
 	}
@@ -996,6 +1157,49 @@ var SurveyEditor = class SurveyEditor {
 		this._survey.deleteTemplateValue(key);
 	}
 	/**
+	* Get a survey asset immutably.
+	*/
+	getAsset(assetId) {
+		const asset = this._survey.getAsset(assetId);
+		return asset ? structuredCloneMethod(asset) : void 0;
+	}
+	/**
+	* Get all survey assets immutably.
+	*/
+	getAssets() {
+		return this._survey.getAssets();
+	}
+	/**
+	* Add or replace a survey asset.
+	*/
+	setAsset(assetId, asset) {
+		const previousAsset = this._survey.getAsset(assetId);
+		this._survey.setAsset(assetId, structuredCloneMethod(asset));
+		this._undoRedo.commitAssetChange([{
+			assetId,
+			prev: previousAsset,
+			next: structuredCloneMethod(asset)
+		}], {
+			label: `Update asset: ${assetId}`,
+			source: CommitSource.USER
+		});
+	}
+	/**
+	* Remove a survey asset.
+	*/
+	removeAsset(assetId) {
+		const previousAsset = this._survey.getAsset(assetId);
+		if (!previousAsset) return;
+		this._survey.deleteAsset(assetId);
+		this._undoRedo.commitAssetChange([{
+			assetId,
+			prev: previousAsset
+		}], {
+			label: `Remove asset: ${assetId}`,
+			source: CommitSource.USER
+		});
+	}
+	/**
 	* Copy a survey item and all its data to clipboard format
 	* @param itemId - The ID of the item to copy
 	* @returns Clipboard data that can be serialized to JSON for clipboard