@jbpark/live-editor 1.19.0 → 2.0.1

package/dist/{ast-CBAw3X_T.js → ast-BmGLa00g.js}

@@ -57,7 +57,13 @@ const dedent = (str) => {
 	}, Infinity);
 	return indent === Infinity ? str.trim() : lines.map((line) => line.slice(indent)).join("\n");
 };
-const evaluateLiteral = (node) => {
+const unwrapExpression = (node) => {
+	let current = node;
+	while (import_lib$2.isTSAsExpression(current) || import_lib$2.isTSSatisfiesExpression(current) || import_lib$2.isTSNonNullExpression(current) || import_lib$2.isTSTypeAssertion(current) || import_lib$2.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+};
+const evaluateLiteral = (rawNode) => {
+	const node = unwrapExpression(rawNode);
 	if (import_lib$2.isStringLiteral(node)) return node.value;
 	if (import_lib$2.isNumericLiteral(node)) return node.value;
 	if (import_lib$2.isBooleanLiteral(node)) return node.value;
@@ -204,9 +210,26 @@ const createNodeFromValue = (type, value) => {
 		default: return null;
 	}
 };
+const valueToExpression = (value) => {
+	if (typeof value === "string") return import_lib$2.stringLiteral(value);
+	if (typeof value === "number") return value < 0 ? import_lib$2.unaryExpression("-", import_lib$2.numericLiteral(-value)) : import_lib$2.numericLiteral(value);
+	if (typeof value === "boolean") return import_lib$2.booleanLiteral(value);
+	if (value === null) return import_lib$2.nullLiteral();
+	if (Array.isArray(value)) return import_lib$2.arrayExpression(value.map((item) => valueToExpression(item) ?? import_lib$2.nullLiteral()));
+	if (typeof value === "object") {
+		const properties = [];
+		for (const [key, item] of Object.entries(value)) {
+			const expr = valueToExpression(item);
+			if (expr === null) continue;
+			properties.push(import_lib$2.objectProperty(import_lib$2.stringLiteral(key), expr));
+		}
+		return import_lib$2.objectExpression(properties);
+	}
+	return null;
+};
 const parseArrayExpression = (value) => {
 	try {
-		const ast = (0, import_lib$1.parseExpression)(value, { plugins: ["jsx", "typescript"] });
+		const ast = unwrapExpression((0, import_lib$1.parseExpression)(value, { plugins: ["jsx", "typescript"] }));
 		if (!import_lib$2.isArrayExpression(ast)) return null;
 		return ast;
 	} catch (error) {
@@ -294,11 +317,7 @@ const sanitizeRenderMap = (value) => {
 	}
 	return Object.keys(map).length > 0 ? map : void 0;
 };
-const parseBinding = (bindingValue) => {
-	if (!bindingValue) return [];
-	const ast = parseArrayExpression(bindingValue);
-	if (!ast) return [];
-	const raw = evaluateLiteral(ast);
+const buildBindingItems = (raw) => {
 	if (!Array.isArray(raw)) return [];
 	const items = [];
 	for (const rawItem of raw) {
@@ -339,6 +358,13 @@ const parseBinding = (bindingValue) => {
 	}
 	return items;
 };
+const parseBinding = (bindingValue) => {
+	if (!bindingValue) return [];
+	const ast = parseArrayExpression(bindingValue);
+	if (!ast) return [];
+	return buildBindingItems(evaluateLiteral(ast));
+};
+const parseBindingExpression = (expression) => buildBindingItems(evaluateLiteral(expression));
 const getCurrentValue = (node, property) => {
 	switch (property) {
 		case BINDING_PROP.INNER_TEXT: return node.textContent || "";
@@ -360,6 +386,28 @@ const getCurrentValue = (node, property) => {
 		default: return node.attributes.find((attr) => attr.name === property)?.value || "";
 	}
 };
+const STRING_VALUED_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"url",
+	"date",
+	"color",
+	"jsx",
+	"richtext",
+	"icon-picker",
+	"asset-picker"
+]);
+const getStructuredValue = (node, property, type) => {
+	switch (property) {
+		case BINDING_PROP.INNER_TEXT:
+		case BINDING_PROP.INNER_HTML: return getCurrentValue(node, property);
+		case BINDING_PROP.CHILDREN: return node.children ?? [];
+		default: {
+			const raw = getCurrentValue(node, property);
+			if (node.attributes.find((a) => a.name === property)?.isStringLiteral || type && STRING_VALUED_TYPES.has(type)) return raw;
+			return parseValue(raw);
+		}
+	}
+};
 const hasEditableBindings = (node) => {
 	const bindingAttr = node.dataAttributes.find((attr) => attr.name === DATA_ATTR.BINDING);
 	if (!bindingAttr?.value) return false;
@@ -542,12 +590,20 @@ const markProcessedJSX = (node, processedNodes) => {
 	}
 	if (import_lib$2.isJSXExpressionContainer(node) || import_lib$2.isParenthesizedExpression(node)) markProcessedJSX(node.expression, processedNodes);
 };
+const getBindingExpression = (opening) => {
+	for (const attr of opening.attributes) if (import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === DATA_ATTR.BINDING && attr.value && import_lib$2.isJSXExpressionContainer(attr.value)) {
+		const expression = unwrapExpression(attr.value.expression);
+		if (import_lib$2.isArrayExpression(expression)) return expression;
+	}
+	return null;
+};
 const readNodeBindingInfo = (node) => {
 	const opening = node.openingElement;
 	const tagName = getTagName(opening);
 	const { allAttrs, dataAttrs } = extractAttributes(opening.attributes);
 	const bindingAttr = dataAttrs.find((attr) => attr.name === DATA_ATTR.BINDING);
-	const bindings = bindingAttr?.value ? parseBinding(bindingAttr.value) : [];
+	const bindingExpr = getBindingExpression(opening);
+	const bindings = bindingExpr ? parseBindingExpression(bindingExpr) : bindingAttr?.value ? parseBinding(bindingAttr.value) : [];
 	const childrenBinding = bindings.find((b) => b.property === BINDING_PROP.CHILDREN);
 	const arrayBindings = bindings.filter((b) => b.property === BINDING_PROP.ITEMS || b.type === "array");
 	const innerHtmlBinding = bindings.find((b) => b.property === BINDING_PROP.INNER_HTML);
@@ -627,59 +683,221 @@ function clearExtractCache() {
 	extractCache.clear();
 }
 //#endregion
-//#region src/utils/ast/update.ts
-const updateInnerText = (path, value) => {
-	const jsxChildren = path.node.children;
-	for (let i = jsxChildren.length - 1; i >= 0; i--) if (import_lib$2.isJSXText(jsxChildren[i])) jsxChildren.splice(i, 1);
-	jsxChildren.push(import_lib$2.jsxText(value));
+//#region src/utils/ast/patch.ts
+const hasOnlyLayoutNewlines = (content) => {
+	let index = 0;
+	while (index < content.length) {
+		const char = content[index];
+		if (char === "`" || char === "<") return false;
+		if (char === "\"" || char === "'") {
+			const next = skipStringLiteral(content, index);
+			if (next === -1) return false;
+			index = next;
+			continue;
+		}
+		if (char === "/") {
+			const following = content[index + 1];
+			if (following === "/") {
+				const lineEnd = content.indexOf("\n", index + 2);
+				index = lineEnd === -1 ? content.length : lineEnd;
+				continue;
+			}
+			if (following === "*") {
+				const commentEnd = content.indexOf("*/", index + 2);
+				if (commentEnd === -1) return false;
+				index = commentEnd + 2;
+				continue;
+			}
+			return false;
+		}
+		index++;
+	}
 	return true;
 };
-const injectPlaceholder = (prefix, value, placeholders, { asRawContent = false } = {}) => {
-	const name = `__${prefix}_${nanoid(6)}__`;
-	const container = import_lib$2.jsxExpressionContainer(import_lib$2.identifier(name));
-	placeholders.set(asRawContent ? `{${name}}` : name, value);
-	return container;
+const skipStringLiteral = (content, start) => {
+	const quote = content[start];
+	for (let index = start + 1; index < content.length; index++) {
+		const char = content[index];
+		if (char === "\\") {
+			const escaped = content[index + 1];
+			if (escaped === "\n" || escaped === "\r") return -1;
+			index++;
+			continue;
+		}
+		if (char === quote) return index + 1;
+		if (char === "\n") return -1;
+	}
+	return -1;
 };
-const updateInnerHTML = (path, value, placeholders) => {
-	path.node.children = [injectPlaceholder("HTML", value, placeholders, { asRawContent: true })];
-	return true;
+const lineIndentAt = (source, offset) => {
+	const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+	return /^[ \t]*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
 };
-const updateChildren = (path, value) => {
+const lineTerminatorOf = (source) => {
+	return source.includes("\r\n") ? "\r\n" : "\n";
+};
+const applyEdits = (source, edits) => {
+	if (edits.length === 0) return source;
+	const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+	for (const edit of ordered) if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end) || edit.start < 0 || edit.end > source.length || edit.start > edit.end) throw new Error(`Invalid source edit [${edit.start}, ${edit.end}) for a source of length ${source.length}`);
+	for (let i = 1; i < ordered.length; i++) {
+		const previous = ordered[i - 1];
+		const current = ordered[i];
+		if (current.start < previous.end) throw new Error(`Overlapping source edits: [${previous.start}, ${previous.end}) and [${current.start}, ${current.end})`);
+	}
+	let result = "";
+	let cursor = 0;
+	const terminator = lineTerminatorOf(source);
+	for (const edit of ordered) {
+		const content = edit.indent && edit.content.includes("\n") && hasOnlyLayoutNewlines(edit.content) ? edit.content.replace(/\n/g, `${terminator}${lineIndentAt(source, edit.start)}`) : edit.content;
+		result += source.slice(cursor, edit.start) + content;
+		cursor = edit.end;
+	}
+	return result + source.slice(cursor);
+};
+//#endregion
+//#region src/utils/ast/update.ts
+const childrenRange = (element) => {
+	const { openingElement, closingElement } = element;
+	if (!closingElement || openingElement.end == null || closingElement.start == null) return null;
+	return {
+		start: openingElement.end,
+		end: closingElement.start
+	};
+};
+const findAttribute = (opening, propertyName) => {
+	return opening.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
+};
+const attributeInsertPoint = (opening) => {
+	return opening.attributes[opening.attributes.length - 1]?.end ?? opening.name.end ?? null;
+};
+const editInnerText = (source, element, value) => {
+	const range = childrenRange(element);
+	if (!range) return [];
+	const [only] = element.children;
+	if (element.children.length === 1 && import_lib$2.isJSXText(only) && only.start != null && only.end != null) {
+		const raw = source.slice(only.start, only.end);
+		if (raw.trim() !== "") {
+			const leading = raw.length - raw.trimStart().length;
+			const trailing = raw.length - raw.trimEnd().length;
+			return [{
+				start: only.start + leading,
+				end: only.end - trailing,
+				content: value
+			}];
+		}
+	}
+	const edits = [];
+	for (const child of element.children) if (import_lib$2.isJSXText(child) && child.start != null && child.end != null) edits.push({
+		start: child.start,
+		end: child.end,
+		content: ""
+	});
+	edits.push({
+		start: range.end,
+		end: range.end,
+		content: value
+	});
+	return edits;
+};
+const editInnerHTML = (element, value) => {
+	const range = childrenRange(element);
+	if (!range) return [];
+	return [{
+		start: range.start,
+		end: range.end,
+		content: value
+	}];
+};
+const editChildren = (element, value) => {
 	try {
-		const childrenData = JSON.parse(value);
-		path.node.children.length = 0;
-		childrenData.forEach((childData) => {
-			const jsxElement = nodeToJSX(childData);
-			if (jsxElement) path.node.children.push(jsxElement);
-		});
-		return true;
+		const childrenData = typeof value === "string" ? JSON.parse(value) : value;
+		const range = childrenRange(element);
+		if (!range) return [];
+		const content = childrenData.map((childData) => nodeToJSX(childData)).filter((node) => node !== null).map((node) => generateCode(node)).join("");
+		return [{
+			start: range.start,
+			end: range.end,
+			content,
+			indent: true
+		}];
 	} catch (error) {
 		console.error("❌ Children update error:", error);
-		return false;
+		return null;
 	}
 };
-const updateRichtext = (path, value) => {
-	path.node.children = [];
-	const opening = path.node.openingElement;
-	const htmlObject = import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("__html"), import_lib$2.stringLiteral(value))]);
-	const existingAttr = opening.attributes.find((a) => import_lib$2.isJSXAttribute(a) && import_lib$2.isJSXIdentifier(a.name) && a.name.name === "dangerouslySetInnerHTML");
-	if (existingAttr && import_lib$2.isJSXAttribute(existingAttr)) existingAttr.value = import_lib$2.jsxExpressionContainer(htmlObject);
-	else opening.attributes.push(import_lib$2.jsxAttribute(import_lib$2.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$2.jsxExpressionContainer(htmlObject)));
-	return true;
-};
-const updateAttribute = (opening, propertyName, value) => {
-	const customAttr = opening.attributes.find((attr) => import_lib$2.isJSXAttribute(attr) && import_lib$2.isJSXIdentifier(attr.name) && attr.name.name === propertyName);
-	if (customAttr && import_lib$2.isJSXAttribute(customAttr)) {
-		const trimmed = value.trim();
-		const isExpression = trimmed.startsWith("[") || trimmed.startsWith("{") || REGEX.NUMBER.test(trimmed) || REGEX.BOOLEAN_OR_NULL.test(trimmed);
-		customAttr.value = attrValue({
-			name: propertyName,
-			value,
-			isStringLiteral: !isExpression
+const editRichtext = (element, value) => {
+	const edits = [];
+	const range = childrenRange(element);
+	if (range && range.start !== range.end) edits.push({
+		start: range.start,
+		end: range.end,
+		content: ""
+	});
+	const opening = element.openingElement;
+	const attribute = import_lib$2.jsxAttribute(import_lib$2.jsxIdentifier("dangerouslySetInnerHTML"), import_lib$2.jsxExpressionContainer(import_lib$2.objectExpression([import_lib$2.objectProperty(import_lib$2.identifier("__html"), import_lib$2.stringLiteral(value))])));
+	const content = generateCode(attribute);
+	const existing = findAttribute(opening, "dangerouslySetInnerHTML");
+	if (existing && existing.start != null && existing.end != null) {
+		edits.push({
+			start: existing.start,
+			end: existing.end,
+			content,
+			indent: true
 		});
-		return true;
+		return edits;
 	}
-	return false;
+	const insertAt = attributeInsertPoint(opening);
+	if (insertAt == null) return null;
+	edits.push({
+		start: insertAt,
+		end: insertAt,
+		content: ` ${content}`,
+		indent: true
+	});
+	return edits;
+};
+const editJsxAttribute = (opening, propertyName, value) => {
+	const attribute = findAttribute(opening, propertyName);
+	if (!attribute) return null;
+	const content = `{${String(value).trim()}}`;
+	if (attribute.value?.start != null && attribute.value.end != null) return [{
+		start: attribute.value.start,
+		end: attribute.value.end,
+		content
+	}];
+	const insertAt = attribute.name.end;
+	if (insertAt == null) return null;
+	return [{
+		start: insertAt,
+		end: insertAt,
+		content: `=${content}`
+	}];
+};
+const buildAttributeValue = (value, type) => {
+	if (type === "array" || type === "object") {
+		if (typeof value === "string") try {
+			return import_lib$2.jsxExpressionContainer((0, import_lib$1.parseExpression)(value.trim(), { plugins: ["jsx", "typescript"] }));
+		} catch {
+			return import_lib$2.stringLiteral(value);
+		}
+		const expr = valueToExpression(value);
+		return expr ? import_lib$2.jsxExpressionContainer(expr) : import_lib$2.stringLiteral("");
+	}
+	if (typeof value === "string") return import_lib$2.stringLiteral(value);
+	const expr = valueToExpression(value);
+	return expr ? import_lib$2.jsxExpressionContainer(expr) : import_lib$2.stringLiteral(String(value));
+};
+const editAttribute = (opening, propertyName, value, type) => {
+	const attribute = findAttribute(opening, propertyName);
+	if (!attribute || attribute.start == null || attribute.end == null) return null;
+	const content = generateCode(import_lib$2.jsxAttribute(attribute.name, buildAttributeValue(value, type)));
+	return [{
+		start: attribute.start,
+		end: attribute.end,
+		content,
+		indent: true
+	}];
 };
 const update = (code, dataId, label, value, property) => {
 	try {
@@ -689,7 +907,12 @@ const update = (code, dataId, label, value, property) => {
 			plugins: ["jsx", "typescript"]
 		});
 		let changed = false;
-		const jsxPlaceholders = /* @__PURE__ */ new Map();
+		const edits = [];
+		const collect = (result) => {
+			if (!result) return;
+			edits.push(...result);
+			changed = true;
+		};
 		traverse(ast, { JSXElement(path) {
 			const opening = path.node.openingElement;
 			if (!opening.attributes.find((attr) => {
@@ -709,32 +932,23 @@ const update = (code, dataId, label, value, property) => {
 			const propertyBinding = matches[0];
 			switch (propertyBinding.property) {
 				case BINDING_PROP.INNER_TEXT:
-					changed = updateInnerText(path, value);
+					collect(editInnerText(wrapped, path.node, String(value)));
 					break;
 				case BINDING_PROP.INNER_HTML:
-					if (propertyBinding.type === "richtext") changed = updateRichtext(path, value);
-					else changed = updateInnerHTML(path, value, jsxPlaceholders);
+					collect(propertyBinding.type === "richtext" ? editRichtext(path.node, String(value)) : editInnerHTML(path.node, String(value)));
 					break;
 				case BINDING_PROP.CHILDREN:
-					changed = updateChildren(path, value);
+					collect(editChildren(path.node, value));
 					break;
-				default: if (propertyBinding.type === "jsx") {
-					const attr = opening.attributes.find((a) => import_lib$2.isJSXAttribute(a) && import_lib$2.isJSXIdentifier(a.name) && a.name.name === propertyBinding.property);
-					if (attr && import_lib$2.isJSXAttribute(attr)) {
-						attr.value = injectPlaceholder("JSX", value.trim(), jsxPlaceholders);
-						changed = true;
-					}
-				} else changed = updateAttribute(opening, propertyBinding.property, value);
+				default: collect(propertyBinding.type === "jsx" ? editJsxAttribute(opening, propertyBinding.property, value) : editAttribute(opening, propertyBinding.property, value, propertyBinding.type));
 			}
 		} });
 		if (!changed) return {
 			code,
 			success: false
 		};
-		let result = unwrap(generateCode(ast));
-		for (const [placeholder, original] of jsxPlaceholders) result = result.replace(placeholder, () => original);
 		return {
-			code: result,
+			code: unwrap(applyEdits(wrapped, edits)),
 			success: true
 		};
 	} catch (error) {
@@ -787,13 +1001,12 @@ const validateBindingValue = (binding, value) => {
 		};
 		return VALID;
 	}
-	const numericValue = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value)) ? Number(value) : void 0;
-	if (numericValue !== void 0) {
-		if (binding.min !== void 0 && numericValue < binding.min) return {
+	if (typeof value === "number") {
+		if (binding.min !== void 0 && value < binding.min) return {
 			valid: false,
 			message: `Must be at least ${binding.min}.`
 		};
-		if (binding.max !== void 0 && numericValue > binding.max) return {
+		if (binding.max !== void 0 && value > binding.max) return {
 			valid: false,
 			message: `Must be at most ${binding.max}.`
 		};
@@ -827,6 +1040,6 @@ const validateBindingValue = (binding, value) => {
 	return VALID;
 };
 //#endregion
-export { parseArrayExpression as _, bulkUpdate as a, generateCode as b, extract as c, parseBinding as d, arrayExpressionToCode as f, flattenEditableValue as g, extractObjectProperties as h, replaceIds as i, findEditableChildren as l, extractNodeValue as m, clone as n, update as o, createNodeFromValue as p, fillIds as r, clearExtractCache as s, validateBindingValue as t, getCurrentValue as u, parseValue as v, setEditableValue as y };
+export { generateCode as S, extractObjectProperties as _, bulkUpdate as a, parseValue as b, extract as c, getStructuredValue as d, parseBinding as f, extractNodeValue as g, createNodeFromValue as h, replaceIds as i, findEditableChildren as l, arrayExpressionToCode as m, clone as n, update as o, parseBindingExpression as p, fillIds as r, clearExtractCache as s, validateBindingValue as t, getCurrentValue as u, flattenEditableValue as v, setEditableValue as x, parseArrayExpression as y };
 
-//# sourceMappingURL=ast-CBAw3X_T.js.map
+//# sourceMappingURL=ast-BmGLa00g.js.map