@case-framework/survey-core 0.1.0

package/build/survey-C3ZHI-5z.mjs

@@ -0,0 +1,931 @@
+//#region src/utils.ts
+/**
+* Shuffles an array of indices using the Fisher-Yates shuffle algorithm
+* @param length - The length of the array to create indices for
+* @returns A shuffled array of indices from 0 to length-1
+*/
+function shuffleIndices(length) {
+	const shuffledIndices = Array.from({ length }, (_, i) => i);
+	for (let i = shuffledIndices.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[shuffledIndices[i], shuffledIndices[j]] = [shuffledIndices[j], shuffledIndices[i]];
+	}
+	return shuffledIndices;
+}
+function structuredCloneMethod(obj) {
+	if (typeof structuredClone !== "undefined") return structuredClone(obj);
+	return JSON.parse(JSON.stringify(obj));
+}
+const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function generateId() {
+	const length = 10;
+	const timestamp = Date.now();
+	let encodedTimestamp = "";
+	let t = timestamp;
+	const base = 62;
+	while (t > 0) {
+		encodedTimestamp = ALPHABET.charAt(t % base) + encodedTimestamp;
+		t = Math.floor(t / base);
+	}
+	let randomPart = "";
+	for (let i = 0; i < length; i++) randomPart += ALPHABET.charAt(Math.floor(Math.random() * base));
+	return randomPart + encodedTimestamp;
+}
+
+//#endregion
+//#region src/survey/utils/value-reference.ts
+const SEPARATOR = "...";
+let ValueReferenceMethod = /* @__PURE__ */ function(ValueReferenceMethod) {
+	ValueReferenceMethod["get"] = "get";
+	ValueReferenceMethod["isDefined"] = "isDefined";
+	return ValueReferenceMethod;
+}({});
+var ValueReference = class ValueReference {
+	_itemId;
+	_name;
+	_slotId;
+	constructor(str) {
+		const parts = str.split(SEPARATOR);
+		if (parts.length !== 3) throw new Error("Invalid value reference: " + str);
+		this._itemId = parts[0];
+		this._name = parts[1];
+		this._slotId = parts[2];
+	}
+	get itemId() {
+		return this._itemId;
+	}
+	get name() {
+		return this._name;
+	}
+	get slotId() {
+		return this._slotId;
+	}
+	set itemId(itemId) {
+		this._itemId = itemId;
+	}
+	toString() {
+		return `${this._itemId}${SEPARATOR}${this._name}${this._slotId ? SEPARATOR + this._slotId : ""}`;
+	}
+	static fromParts(itemId, name, slotId) {
+		return new ValueReference(`${itemId}${SEPARATOR}${name}${SEPARATOR}${slotId}`);
+	}
+};
+let ReferenceUsageType = /* @__PURE__ */ function(ReferenceUsageType) {
+	ReferenceUsageType["displayConditions"] = "displayConditions";
+	ReferenceUsageType["templateValues"] = "templateValues";
+	ReferenceUsageType["validations"] = "validations";
+	ReferenceUsageType["disabledConditions"] = "disabledConditions";
+	return ReferenceUsageType;
+}({});
+
+//#endregion
+//#region src/expressions/expression.ts
+const ExpressionType = {
+	Const: "const",
+	ResponseVariable: "responseVariable",
+	ContextVariable: "contextVariable",
+	Function: "function"
+};
+const ContextVariableType = {
+	Locale: "locale",
+	ParticipantFlag: "participantFlag",
+	CustomValue: "customValue",
+	CustomExpression: "customExpression"
+};
+/**
+* Base class for all expressions.
+*/
+var Expression = class Expression {
+	type;
+	editorConfig;
+	constructor(type, editorConfig) {
+		this.type = type;
+		this.editorConfig = editorConfig;
+	}
+	static deserialize(json) {
+		if (!json) return;
+		switch (json.type) {
+			case ExpressionType.Const: return ConstExpression.deserialize(json);
+			case ExpressionType.ResponseVariable: return ResponseVariableExpression.deserialize(json);
+			case ExpressionType.ContextVariable: return ContextVariableExpression.deserialize(json);
+			case ExpressionType.Function: return FunctionExpression.deserialize(json);
+		}
+	}
+	clone() {
+		return Expression.deserialize(this.serialize()) ?? (() => {
+			throw new Error("Failed to clone expression");
+		})();
+	}
+};
+var ConstExpression = class ConstExpression extends Expression {
+	value;
+	constructor(value, editorConfig) {
+		super(ExpressionType.Const, editorConfig);
+		this.value = value;
+		this.type = ExpressionType.Const;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.Const) throw new Error("Invalid expression type: " + json.type);
+		return new ConstExpression(json.value, json.editorConfig);
+	}
+	get responseVariableRefs() {
+		return [];
+	}
+	serialize() {
+		return {
+			type: this.type,
+			value: this.value,
+			editorConfig: this.editorConfig
+		};
+	}
+	updateItemKeyReferences(_oldItemKey, _newItemKey) {
+		return false;
+	}
+};
+var ResponseVariableExpression = class ResponseVariableExpression extends Expression {
+	variableRef;
+	constructor(variableRef, editorConfig) {
+		super(ExpressionType.ResponseVariable, editorConfig);
+		this.variableRef = variableRef;
+		this.type = ExpressionType.ResponseVariable;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.ResponseVariable) throw new Error("Invalid expression type: " + json.type);
+		return new ResponseVariableExpression(json.variableRef, json.editorConfig);
+	}
+	get responseVariableRefs() {
+		return [new ValueReference(this.variableRef)];
+	}
+	get responseVariableRef() {
+		return new ValueReference(this.variableRef);
+	}
+	serialize() {
+		return {
+			type: this.type,
+			variableRef: this.variableRef,
+			editorConfig: this.editorConfig
+		};
+	}
+};
+var ContextVariableExpression = class ContextVariableExpression extends Expression {
+	contextType;
+	key;
+	arguments;
+	asType;
+	constructor(contextType, key, args, asType, editorConfig) {
+		super(ExpressionType.ContextVariable, editorConfig);
+		this.type = ExpressionType.ContextVariable;
+		this.contextType = contextType;
+		this.key = key;
+		this.arguments = args;
+		this.asType = asType;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.ContextVariable) throw new Error("Invalid expression type: " + json.type);
+		return new ContextVariableExpression(json.contextType, Expression.deserialize(json.key), json.arguments?.map((arg) => Expression.deserialize(arg)), json.asType, json.editorConfig);
+	}
+	get responseVariableRefs() {
+		return this.arguments?.flatMap((arg) => arg?.responseVariableRefs).filter((ref) => ref !== void 0) ?? [];
+	}
+	serialize() {
+		return {
+			type: this.type,
+			contextType: this.contextType,
+			key: this.key?.serialize(),
+			arguments: this.arguments?.map((arg) => arg?.serialize()),
+			asType: this.asType,
+			editorConfig: this.editorConfig
+		};
+	}
+};
+let FunctionExpressionNames = /* @__PURE__ */ function(FunctionExpressionNames) {
+	FunctionExpressionNames["and"] = "and";
+	FunctionExpressionNames["or"] = "or";
+	FunctionExpressionNames["not"] = "not";
+	FunctionExpressionNames["list_contains"] = "list_contains";
+	FunctionExpressionNames["eq"] = "eq";
+	FunctionExpressionNames["gt"] = "gt";
+	FunctionExpressionNames["gte"] = "gte";
+	FunctionExpressionNames["lt"] = "lt";
+	FunctionExpressionNames["lte"] = "lte";
+	FunctionExpressionNames["in_range"] = "in_range";
+	FunctionExpressionNames["sum"] = "sum";
+	FunctionExpressionNames["min"] = "min";
+	FunctionExpressionNames["max"] = "max";
+	FunctionExpressionNames["str_eq"] = "str_eq";
+	FunctionExpressionNames["date_eq"] = "date_eq";
+	return FunctionExpressionNames;
+}({});
+var FunctionExpression = class FunctionExpression extends Expression {
+	functionName;
+	arguments;
+	constructor(functionName, args, editorConfig) {
+		super(ExpressionType.Function);
+		this.type = ExpressionType.Function;
+		this.functionName = functionName;
+		this.arguments = args;
+		this.editorConfig = editorConfig;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.Function) throw new Error("Invalid expression type: " + json.type);
+		const functionName = json.functionName;
+		if (!Object.values(FunctionExpressionNames).includes(functionName)) throw new Error("Invalid function name: " + functionName);
+		const expr = new FunctionExpression(functionName, json.arguments.map((arg) => Expression.deserialize(arg)));
+		expr.editorConfig = json.editorConfig;
+		return expr;
+	}
+	get responseVariableRefs() {
+		const refStrings = this.arguments.flatMap((arg) => arg?.responseVariableRefs).filter((ref) => ref !== void 0).map((ref) => ref.toString());
+		return [...new Set(refStrings)].map((ref) => new ValueReference(ref));
+	}
+	serialize() {
+		return {
+			type: this.type,
+			functionName: this.functionName,
+			arguments: this.arguments.map((arg) => arg?.serialize()),
+			editorConfig: this.editorConfig
+		};
+	}
+};
+
+//#endregion
+//#region src/expressions/template-value.ts
+let TemplateDefTypes = /* @__PURE__ */ function(TemplateDefTypes) {
+	TemplateDefTypes["Default"] = "default";
+	TemplateDefTypes["Date2String"] = "date2string";
+	return TemplateDefTypes;
+}({});
+const serializeTemplateValue = (templateValue) => {
+	const json = {
+		type: templateValue.type,
+		returnType: templateValue.returnType,
+		expression: templateValue.expression?.serialize()
+	};
+	if (templateValue.type === TemplateDefTypes.Date2String) json.dateFormat = templateValue.dateFormat;
+	return json;
+};
+const serializeTemplateValues = (templateValues) => {
+	const json = {};
+	for (const [key, value] of templateValues.entries()) json[key] = serializeTemplateValue(value);
+	return json;
+};
+const deserializeTemplateValue = (json) => {
+	return {
+		type: json.type,
+		expression: json.expression ? Expression.deserialize(json.expression) : void 0,
+		returnType: json.returnType,
+		dateFormat: json.dateFormat
+	};
+};
+const deserializeTemplateValues = (json) => {
+	return new Map(Object.entries(json).map(([key, value]) => [key, deserializeTemplateValue(value)]));
+};
+
+//#endregion
+//#region src/survey/items/utils.ts
+const displayConditionsFromJson = (json) => {
+	return {
+		root: json.root ? Expression.deserialize(json.root) : void 0,
+		components: json.components ? Object.fromEntries(Object.entries(json.components).map(([key, value]) => [key, Expression.deserialize(value)])) : void 0
+	};
+};
+const disabledConditionsFromJson = (json) => {
+	return { components: json.components ? Object.fromEntries(Object.entries(json.components).map(([key, value]) => [key, Expression.deserialize(value)])) : void 0 };
+};
+
+//#endregion
+//#region src/survey/items/survey-item.ts
+/**
+* Base class for survey item handlers.
+* Each handler holds type, id, key, and config (properly typed) and implements core methods.
+* Subclass for each item type; the core works with SurveyItemHandler only—no casting needed.
+*/
+var SurveyItemCore = class {
+	id;
+	key;
+	config;
+	_rawItem;
+	displayConditions;
+	disabledConditions;
+	validations;
+	prefillRules;
+	constructor(rawItem) {
+		this._rawItem = rawItem;
+		this.updateExpressions();
+		this.id = this._rawItem.id;
+		this.key = this._rawItem.key;
+		this.config = this.parseConfig(this._rawItem.config);
+	}
+	get rawItem() {
+		return this._rawItem;
+	}
+	updateRawItem(rawItem) {
+		if (rawItem.id !== this.id) throw new Error("Cannot update raw item with a different id");
+		this._rawItem = rawItem;
+		this.updateExpressions();
+		this.key = rawItem.key;
+		this.config = this.parseConfig(rawItem.config);
+	}
+	updateExpressions() {
+		this.displayConditions = this._rawItem.displayConditions ? displayConditionsFromJson(this._rawItem.displayConditions) : void 0;
+		this.disabledConditions = this._rawItem.disabledConditions ? disabledConditionsFromJson(this._rawItem.disabledConditions) : void 0;
+		this.validations = this._rawItem.validations ? Object.fromEntries(Object.entries(this._rawItem.validations).map(([key, value]) => [key, Expression.deserialize(value)])) : void 0;
+		this.prefillRules = this._rawItem.prefillRules ? this._rawItem.prefillRules.map((rule) => rule ? Expression.deserialize(rule) : void 0) : void 0;
+	}
+	getReferenceUsages() {
+		const usages = [];
+		if (this.displayConditions) {
+			for (const ref of this.displayConditions.root?.responseVariableRefs || []) usages.push({
+				itemId: this.id,
+				usageType: ReferenceUsageType.displayConditions,
+				valueReference: ref
+			});
+			for (const [componentKey, expression] of Object.entries(this.displayConditions.components || {})) for (const ref of expression?.responseVariableRefs || []) usages.push({
+				itemId: this.id,
+				fullComponentKey: componentKey,
+				usageType: ReferenceUsageType.displayConditions,
+				valueReference: ref
+			});
+		}
+		if (this.disabledConditions) for (const [componentKey, expression] of Object.entries(this.disabledConditions.components || {})) for (const ref of expression?.responseVariableRefs || []) usages.push({
+			itemId: this.id,
+			fullComponentKey: componentKey,
+			usageType: ReferenceUsageType.disabledConditions,
+			valueReference: ref
+		});
+		if (this.validations) for (const [validationKey, expression] of Object.entries(this.validations)) for (const ref of expression?.responseVariableRefs || []) usages.push({
+			itemId: this.id,
+			fullComponentKey: validationKey,
+			usageType: ReferenceUsageType.validations,
+			valueReference: ref
+		});
+		return usages;
+	}
+};
+
+//#endregion
+//#region src/survey/items/types.ts
+let ReservedSurveyItemTypes = /* @__PURE__ */ function(ReservedSurveyItemTypes) {
+	ReservedSurveyItemTypes["Group"] = "group";
+	ReservedSurveyItemTypes["PageBreak"] = "page-break";
+	return ReservedSurveyItemTypes;
+}({});
+
+//#endregion
+//#region src/survey/item-key.ts
+/**
+* SurveyItemKey stores the key of the item and the path to the item.
+*/
+var SurveyItemKey = class {
+	_itemKey;
+	_path;
+	_keySeparator;
+	constructor(itemKey, path, keySeparator = ".") {
+		this._itemKey = itemKey;
+		this._path = path ?? [];
+		this._keySeparator = keySeparator;
+	}
+	get itemKey() {
+		return this._itemKey;
+	}
+	get path() {
+		return this._path;
+	}
+	get parentFullKey() {
+		return this._path.join(this._keySeparator);
+	}
+	get fullKey() {
+		return [...this._path, this._itemKey].join(this._keySeparator);
+	}
+	get isRoot() {
+		return this._path.length === 0;
+	}
+	get keySeparator() {
+		return this._keySeparator;
+	}
+	set keySeparator(keySeparator) {
+		this._keySeparator = keySeparator;
+	}
+};
+
+//#endregion
+//#region src/survey/survey-file-schema.ts
+const CURRENT_SURVEY_SCHEMA = "https://github.com/case-framework/case-survey-toolkit/packages/survey-core/schemas/survey-schema.json";
+
+//#endregion
+//#region src/survey/utils/translations.ts
+const validateLocale = (locale) => {
+	if (locale.trim() === "") throw new Error("Locale cannot be empty");
+};
+var SurveyItemTranslations = class {
+	_translations;
+	constructor() {
+		this._translations = {};
+	}
+	setContent(locale, contentKey, content) {
+		validateLocale(locale);
+		if (!this._translations?.[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		if (!content) delete this._translations[locale][contentKey];
+		else this._translations[locale][contentKey] = content;
+	}
+	setAllForLocale(locale, content) {
+		validateLocale(locale);
+		if (!this._translations?.[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		this._translations[locale] = content || {};
+	}
+	get locales() {
+		return Object.keys(this._translations || {});
+	}
+	getAllForLocale(locale) {
+		return this._translations?.[locale];
+	}
+	getContent(locale, contentKey, fallbackLocale) {
+		const content = this._translations?.[locale]?.[contentKey];
+		if (content) return content;
+		if (fallbackLocale) return this._translations?.[fallbackLocale]?.[contentKey];
+	}
+};
+var SurveyTranslations = class {
+	_translations;
+	constructor(translations) {
+		this._translations = translations || {};
+	}
+	serialize() {
+		if (this.locales.length === 0) return;
+		return this._translations;
+	}
+	get locales() {
+		return Object.keys(this._translations);
+	}
+	removeLocale(locale) {
+		validateLocale(locale);
+		delete this._translations[locale];
+	}
+	renameLocale(oldLocale, newLocale) {
+		validateLocale(oldLocale);
+		validateLocale(newLocale);
+		if (this._translations[oldLocale]) {
+			this._translations[newLocale] = this._translations[oldLocale];
+			delete this._translations[oldLocale];
+		}
+	}
+	cloneLocaleAs(locale, newLocale) {
+		validateLocale(locale);
+		validateLocale(newLocale);
+		if (this._translations[locale]) this._translations[newLocale] = structuredCloneMethod(this._translations[locale]);
+	}
+	get surveyCardContent() {
+		const translations = {};
+		for (const locale of this.locales) {
+			const contentForLocale = this._translations?.[locale]?.surveyCardContent;
+			if (contentForLocale) translations[locale] = contentForLocale;
+		}
+		return translations;
+	}
+	get navigationContent() {
+		const translations = {};
+		for (const locale of this.locales) {
+			const contentForLocale = this._translations?.[locale]?.navigationContent;
+			if (contentForLocale) translations[locale] = contentForLocale;
+		}
+		return translations;
+	}
+	get validationMessages() {
+		const translations = {};
+		for (const locale of this.locales) {
+			const contentForLocale = this._translations?.[locale]?.validationMessages;
+			if (contentForLocale) translations[locale] = contentForLocale;
+		}
+		return translations;
+	}
+	setSurveyCardContent(locale, content) {
+		validateLocale(locale);
+		if (!this._translations[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		this._translations[locale].surveyCardContent = content;
+	}
+	setNavigationContent(locale, content) {
+		validateLocale(locale);
+		if (!this._translations[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		this._translations[locale].navigationContent = content;
+	}
+	setValidationMessages(locale, content) {
+		validateLocale(locale);
+		if (!this._translations[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		this._translations[locale].validationMessages = content;
+	}
+	getItemTranslations(itemId) {
+		const itemTranslations = new SurveyItemTranslations();
+		for (const locale of this.locales) {
+			const contentForLocale = this._translations?.[locale].itemTranslations?.[itemId];
+			itemTranslations.setAllForLocale(locale, contentForLocale);
+		}
+		return itemTranslations;
+	}
+	setItemTranslations(itemId, itemContent) {
+		itemContent?.locales.forEach((locale) => validateLocale(locale));
+		if (!itemContent) {
+			for (const locale of this.locales) if (this._translations[locale].itemTranslations?.[itemId]) delete this._translations[locale].itemTranslations?.[itemId];
+		} else {
+			const localesInUpdate = itemContent.locales;
+			for (const locale of localesInUpdate) if (!this.locales.includes(locale)) this._translations[locale] = {};
+			for (const locale of this.locales) if (localesInUpdate.includes(locale)) {
+				if (!this._translations[locale]) this._translations[locale] = {};
+				if (!this._translations[locale].itemTranslations) this._translations[locale].itemTranslations = {};
+				this._translations[locale].itemTranslations[itemId] = itemContent.getAllForLocale(locale) ?? {};
+			} else delete this._translations[locale].itemTranslations[itemId];
+		}
+	}
+	/**
+	* Rename a component key (within an item) - update key in all translations and remove old key
+	* @param itemKey - The key of the item
+	* @param oldKey - The old key of the component
+	* @param newKey - The new key of the component
+	*/
+	onComponentKeyChanged(itemKey, oldKey, newKey) {
+		for (const locale of this.locales) {
+			const itemTranslations = this._translations?.[locale].itemTranslations?.[itemKey];
+			if (itemTranslations) {
+				for (const key of Object.keys(itemTranslations)) if (key.startsWith(oldKey + ".") || key === oldKey) {
+					itemTranslations[key.replace(oldKey, newKey)] = { ...itemTranslations[key] };
+					delete itemTranslations[key];
+				}
+			}
+		}
+	}
+	/**
+	* Remove all translations for a component
+	* @param itemId - The id of the item
+	* @param componentKey - The key of the component
+	*/
+	onComponentDeleted(itemId, componentKey) {
+		for (const locale of this.locales) {
+			const itemTranslations = this._translations?.[locale].itemTranslations?.[itemId];
+			if (itemTranslations) {
+				for (const key of Object.keys(itemTranslations)) if (key.startsWith(componentKey + ".") || key === componentKey) delete itemTranslations[key];
+			}
+		}
+	}
+	/**
+	* Remove all translations for an item
+	* @param id - The id of the item
+	*/
+	onItemDeleted(id) {
+		for (const locale of this.locales) delete this._translations[locale].itemTranslations?.[id];
+	}
+};
+
+//#endregion
+//#region src/survey/utils/group-utils.ts
+/**
+* Shared utilities for array operations.
+*/
+/**
+* Swap two elements in an array by index.
+* @returns A new array with the elements swapped
+*/
+function swapArrayElements(arr, fromIndex, toIndex) {
+	const result = [...arr];
+	[result[fromIndex], result[toIndex]] = [result[toIndex], result[fromIndex]];
+	return result;
+}
+/**
+* Move an element from one index to another.
+* @returns A new array with the element moved
+*/
+function moveArrayElement(arr, fromIndex, toIndex) {
+	const result = [...arr];
+	const [moved] = result.splice(fromIndex, 1);
+	result.splice(toIndex, 0, moved);
+	return result;
+}
+
+//#endregion
+//#region src/survey/registry/built-in-items.ts
+var GroupItemCore = class extends SurveyItemCore {
+	type = ReservedSurveyItemTypes.Group;
+	parseConfig(rawConfig) {
+		const cfg = rawConfig ?? {};
+		return {
+			items: cfg.items,
+			shuffleItems: cfg.shuffleItems,
+			isRoot: cfg.isRoot
+		};
+	}
+	serializeConfig() {
+		return this.config;
+	}
+	isInteractive() {
+		return false;
+	}
+	getAvailableResponseValueSlots() {
+		return {};
+	}
+	isRoot() {
+		return this.config.isRoot ?? false;
+	}
+	get items() {
+		return this.config.items ?? [];
+	}
+	/**
+	* Add a child item id to this group at the given index.
+	* @param itemId The id of the item to add to this group.
+	* @param index The index at which to add the item. If not provided, the item is added to the end of the group.
+	*/
+	addChild(itemId, index) {
+		const items = this.config.items ??= [];
+		const insertIndex = index !== void 0 ? Math.min(index, items.length) : items.length;
+		items.splice(insertIndex, 0, itemId);
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+	/**
+	* Remove a child item id from this group.
+	* @param itemId The id of the item to remove from this group.
+	*/
+	removeChild(itemId) {
+		const items = this.config.items ??= [];
+		const index = items.indexOf(itemId);
+		if (index !== -1) {
+			items.splice(index, 1);
+			this.updateRawItem({
+				...this.rawItem,
+				config: { ...this.config }
+			});
+		}
+	}
+	/**
+	* Check if an item is a direct child of this group.
+	*/
+	hasChild(itemId) {
+		return this.items.includes(itemId);
+	}
+	/** Whether items in this group should be shuffled. */
+	get shuffleItems() {
+		return this.config.shuffleItems ?? false;
+	}
+	set shuffleItems(value) {
+		this.config.shuffleItems = value;
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+	/**
+	* Get the ordered list of child item ids.
+	*/
+	getChildrenIds() {
+		return [...this.items];
+	}
+	/**
+	* Swap two items by their positions in the group.
+	* @throws Error if indices are out of bounds
+	*/
+	swapItemsByIndex(from, to) {
+		const items = this.items;
+		if (from < 0 || from >= items.length || to < 0 || to >= items.length) throw new Error(`Index out of bounds. Valid range is 0-${items.length - 1}`);
+		if (from === to) return;
+		this.config.items = swapArrayElements(items, from, to);
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+	/**
+	* Swap two items by their ids.
+	* @throws Error if either id is not found in this group
+	*/
+	swapItemsById(id, withId) {
+		const items = this.items;
+		const index1 = items.indexOf(id);
+		const index2 = items.indexOf(withId);
+		if (index1 === -1) throw new Error(`Item '${id}' not found in group '${this.key}'`);
+		if (index2 === -1) throw new Error(`Item '${withId}' not found in group '${this.key}'`);
+		this.swapItemsByIndex(index1, index2);
+	}
+	/**
+	* Move an item by id to a specific index.
+	* @throws Error if the item is not found or index is out of bounds
+	*/
+	moveItemToIndex(id, index) {
+		const items = this.items;
+		const fromIndex = items.indexOf(id);
+		if (fromIndex === -1) throw new Error(`Item '${id}' not found in group '${this.key}'`);
+		if (index < 0 || index >= items.length) throw new Error(`Index out of bounds. Valid range is 0-${items.length - 1}`);
+		if (fromIndex === index) return;
+		this.config.items = moveArrayElement(items, fromIndex, index);
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+};
+var PageBreakItemCore = class extends SurveyItemCore {
+	type = ReservedSurveyItemTypes.PageBreak;
+	parseConfig(_rawConfig) {
+		return {};
+	}
+	serializeConfig() {}
+	isInteractive() {
+		return false;
+	}
+	getAvailableResponseValueSlots() {
+		return {};
+	}
+};
+const builtInItemCoreRegistry = {
+	[ReservedSurveyItemTypes.Group]: GroupItemCore,
+	[ReservedSurveyItemTypes.PageBreak]: PageBreakItemCore
+};
+const isBuiltInItemType = (itemType) => itemType in builtInItemCoreRegistry;
+
+//#endregion
+//#region src/survey/registry/item-registry.ts
+/**
+* Creates a handler instance for a raw survey item.
+* Uses built-in registry for group/page-break, otherwise the provided plugin registry.
+*/
+function createItemCore(rawItem, pluginRegistry) {
+	if (isBuiltInItemType(rawItem.itemType)) {
+		const HandlerClass = builtInItemCoreRegistry[rawItem.itemType];
+		return new HandlerClass(rawItem);
+	}
+	if (pluginRegistry && rawItem.itemType in pluginRegistry) {
+		const HandlerClass = pluginRegistry[rawItem.itemType];
+		return new HandlerClass(rawItem);
+	}
+	throw new Error(`Unknown item type: ${rawItem.itemType}`);
+}
+
+//#endregion
+//#region src/survey/survey.ts
+var Survey = class Survey {
+	maxItemsPerPage;
+	metadata;
+	surveyItems = /* @__PURE__ */ new Map();
+	_templateValues = /* @__PURE__ */ new Map();
+	_translations;
+	constructor(pluginRegistry) {
+		this.pluginRegistry = pluginRegistry;
+		this._translations = new SurveyTranslations();
+	}
+	/**
+	* Create a survey item from raw JSON data.
+	* Uses the survey's plugin registry when available.
+	*/
+	createItemFromRaw(rawItem) {
+		return createItemCore(rawItem, this.pluginRegistry);
+	}
+	static fromJson(json, pluginRegistry) {
+		const survey = new Survey(pluginRegistry);
+		const rawSurvey = json;
+		if (rawSurvey.$schema !== CURRENT_SURVEY_SCHEMA) throw new Error(`Unsupported survey schema: ${rawSurvey.$schema}`);
+		survey.surveyItems = /* @__PURE__ */ new Map();
+		if (!rawSurvey.surveyItems || rawSurvey.surveyItems.length === 0) throw new Error("surveyItems is required");
+		rawSurvey.surveyItems.forEach((item) => {
+			const surveyItem = createItemCore(item, pluginRegistry);
+			survey.surveyItems.set(surveyItem.id, surveyItem);
+		});
+		if (rawSurvey.templateValues) survey._templateValues = deserializeTemplateValues(rawSurvey.templateValues);
+		survey._translations = new SurveyTranslations(rawSurvey.translations);
+		if (rawSurvey.maxItemsPerPage) survey.maxItemsPerPage = rawSurvey.maxItemsPerPage;
+		if (rawSurvey.metadata) survey.metadata = rawSurvey.metadata;
+		return survey;
+	}
+	serialize() {
+		const json = {
+			$schema: CURRENT_SURVEY_SCHEMA,
+			surveyItems: Array.from(this.surveyItems.values()).map((item) => item.rawItem)
+		};
+		json.translations = this._translations?.serialize();
+		if (this._templateValues) json.templateValues = serializeTemplateValues(this._templateValues);
+		if (this.maxItemsPerPage) json.maxItemsPerPage = this.maxItemsPerPage;
+		if (this.metadata) json.metadata = this.metadata;
+		return json;
+	}
+	get surveyKey() {
+		if (!this.rootItem) return;
+		return this.rootItem.key;
+	}
+	get locales() {
+		return this._translations?.locales || [];
+	}
+	get rootItem() {
+		return Array.from(this.surveyItems.values()).find((item) => item instanceof GroupItemCore && item.isRoot);
+	}
+	get keyIndex() {
+		const index = [];
+		for (const item of this.surveyItems.values()) {
+			const path = this.getItemPath(item.id);
+			index.push({
+				itemId: item.id,
+				key: item.key,
+				keyPath: path.map((id) => this.surveyItems.get(id)?.key ?? ""),
+				path
+			});
+		}
+		return index;
+	}
+	getItemPath(itemId) {
+		const item = this.surveyItems.get(itemId);
+		if (!item) throw new Error(`Item ${itemId} not found`);
+		if (item instanceof GroupItemCore && item.isRoot()) return [];
+		const parentItem = this.getParentItem(itemId);
+		if (!parentItem) throw new Error(`Parent item for ${itemId} not found`);
+		return [...this.getItemPath(parentItem.id), parentItem.id];
+	}
+	getItemKey(itemId) {
+		const item = this.surveyItems.get(itemId);
+		if (!item) return;
+		const keyPath = this.getItemPath(itemId).map((id) => this.surveyItems.get(id)?.key ?? "");
+		return new SurveyItemKey(item.key, keyPath);
+	}
+	getParentItem(itemId) {
+		const item = this.surveyItems.get(itemId);
+		if (!item) throw new Error(`Item ${itemId} not found`);
+		if (item instanceof GroupItemCore && item.isRoot()) return;
+		const parentItem = Array.from(this.surveyItems.values()).find((item) => item instanceof GroupItemCore && item.config.items?.includes(itemId));
+		if (!parentItem) return;
+		return parentItem;
+	}
+	getChildrenItems(parentId) {
+		const parentItem = this.surveyItems.get(parentId);
+		if (!parentItem || !(parentItem instanceof GroupItemCore)) return [];
+		return parentItem.config.items?.map((id) => this.surveyItems.get(id))?.filter((item) => item !== void 0) || [];
+	}
+	getSiblings(itemId) {
+		if (!this.surveyItems.get(itemId)) return [];
+		return this.getParentItem(itemId)?.items?.map((id) => this.surveyItems.get(id))?.filter((item) => item !== void 0) || [];
+	}
+	get translations() {
+		if (!this._translations) this._translations = new SurveyTranslations();
+		return this._translations;
+	}
+	getItemTranslations(id) {
+		if (!this.surveyItems.get(id)) throw new Error(`Item ${id} not found`);
+		return this._translations?.getItemTranslations(id);
+	}
+	getTemplateValue(templateValueKey) {
+		return this._templateValues?.get(templateValueKey);
+	}
+	setTemplateValue(templateValueKey, templateValue) {
+		if (!this._templateValues) this._templateValues = /* @__PURE__ */ new Map();
+		this._templateValues?.set(templateValueKey, templateValue);
+	}
+	deleteTemplateValue(templateValueKey) {
+		this._templateValues?.delete(templateValueKey);
+	}
+	getTemplateValueKeys() {
+		return Array.from(this._templateValues?.keys() || []);
+	}
+	getAvailableResponseValueSlots(byType) {
+		let valueRefs = {};
+		for (const item of this.surveyItems.values()) valueRefs = {
+			...valueRefs,
+			...item.getAvailableResponseValueSlots(byType)
+		};
+		return valueRefs;
+	}
+	/**
+	* Get all reference usages for the survey
+	* @param forItemId - optional item id to filter usages for a specific item and its children (if not provided, all usages are returned)
+	* @returns all reference usages for the survey (or for a specific item and its children)
+	*/
+	getReferenceUsages(forItemId) {
+		const usages = [];
+		for (const item of this.surveyItems.values()) {
+			if (forItemId && item.id !== forItemId && !this.isDescendantOf(item.id, forItemId)) continue;
+			usages.push(...item.getReferenceUsages());
+		}
+		if (this._templateValues) for (const [templateValueKey, templateValue] of this._templateValues.entries()) for (const ref of templateValue.expression?.responseVariableRefs || []) usages.push({
+			itemId: templateValueKey,
+			usageType: ReferenceUsageType.templateValues,
+			valueReference: ref
+		});
+		return usages;
+	}
+	isDescendantOf(targetId, ancestorId) {
+		if (targetId === ancestorId) return true;
+		return this.getItemPath(targetId).includes(ancestorId);
+	}
+};
+
+//#endregion
+export { ValueReference as C, structuredCloneMethod as D, shuffleIndices as E, ReferenceUsageType as S, generateId as T, Expression as _, validateLocale as a, FunctionExpressionNames as b, SurveyItemCore as c, deserializeTemplateValues as d, serializeTemplateValue as f, ContextVariableType as g, ContextVariableExpression as h, SurveyTranslations as i, TemplateDefTypes as l, ConstExpression as m, GroupItemCore as n, SurveyItemKey as o, serializeTemplateValues as p, SurveyItemTranslations as r, ReservedSurveyItemTypes as s, Survey as t, deserializeTemplateValue as u, ExpressionType as v, ValueReferenceMethod as w, ResponseVariableExpression as x, FunctionExpression as y };
+//# sourceMappingURL=survey-C3ZHI-5z.mjs.map