@teleporthq/teleport-plugin-common 0.42.35 → 0.43.0

package/dist/cjs/node-handlers/node-to-jsx/index.js

@@ -50,6 +50,107 @@ var ast_utils_1 = require("../../utils/ast-utils");
 var ast_builders_1 = require("../../builders/ast-builders");
 var constants_1 = require("./constants");
 var __1 = require("../..");
+// Global references in the UIDL come in two shapes:
+// Shape A: { id: "ecommerce", refPath: ["Cart", "total"] }
+// Shape B: { id: undefined, refPath: ["E-commerce", "Settings", "Delivery", "..."] }
+// This helper normalizes Shape B into Shape A so downstream code can handle
+// both uniformly. The first refPath segment is mapped to a variable name via
+// GLOBAL_REF_ID_MAP (exported from ast-utils so all sites stay in sync).
+// Expression attributes (UIDLExpressionValue) bypass the dynamic-reference
+// tracking in createDynamicValueExpression. When such an expression mentions
+// a known global (currentUser/ecommerce/cart/locale/userIsLoggedIn) we still
+// Plan v15 Layer 4 — junk-name attribute guard.
+// AI fabrication artefacts emit attributes whose KEY is a JS literal
+// (`true="true"`, `false="false"`, `0="x"`, `null="..."`). They survive JSX
+// parsing (treated as string-valued attrs) but break DOM semantics. The
+// upstream Layer 1–3 pipeline should already strip them; this is the final
+// codegen safety net.
+var CODEGEN_JUNK_ATTR_NAMES = new Set(['true', 'false', 'null', 'undefined']);
+function isJunkAttributeName(name) {
+    if (typeof name !== 'string' || name.length === 0) {
+        return true;
+    }
+    var lower = name.toLowerCase();
+    if (CODEGEN_JUNK_ATTR_NAMES.has(lower)) {
+        return true;
+    }
+    if (/^[0-9]+$/.test(name)) {
+        return true;
+    }
+    return false;
+}
+function hasCorruptBindingMarkers(value) {
+    // Entity-escaped `{` / `}` from upstream serialization that should never
+    // reach the JSX output verbatim.
+    if (/{|}/.test(value)) {
+        return true;
+    }
+    // Unbalanced `{{` (no matching `}}`).
+    var opens = (value.match(/\{\{/g) || []).length;
+    var closes = (value.match(/\}\}/g) || []).length;
+    if (opens > closes) {
+        return true;
+    }
+    return false;
+}
+function truncate(value) {
+    if (value.length <= 60) {
+        return value;
+    }
+    return value.slice(0, 57) + '...';
+}
+// need to push it into params.globalReferences so downstream plugins inject
+// the corresponding `useGlobalContext()` destructuring.
+var GLOBAL_EXPRESSION_IDENTIFIERS = [
+    { pattern: /\bcurrentUser\b/, id: 'currentUser' },
+    { pattern: /\buserIsLoggedIn\b/, id: 'userIsLoggedIn' },
+    { pattern: /\becommerce\b/, id: 'ecommerce' },
+    { pattern: /\bcart\b/, id: 'cart' },
+    { pattern: /\blocales?\b/, id: 'locale' },
+];
+var trackGlobalRefsInExpression = function (expression, params) {
+    if (!expression) {
+        return;
+    }
+    for (var _i = 0, GLOBAL_EXPRESSION_IDENTIFIERS_1 = GLOBAL_EXPRESSION_IDENTIFIERS; _i < GLOBAL_EXPRESSION_IDENTIFIERS_1.length; _i++) {
+        var _a = GLOBAL_EXPRESSION_IDENTIFIERS_1[_i], pattern = _a.pattern, id = _a.id;
+        if (pattern.test(expression)) {
+            params.globalReferences.push(id);
+        }
+    }
+    // Global-state identifiers behave the same way: an expression-shaped UIDL
+    // attribute (e.g. cms-mixed-type `itemData`) bypasses the dynamic-ref
+    // pipeline that registers `useGlobalState()` destructuring, so we walk the
+    // raw expression text and re-attach any state name we recognise. The
+    // matched names are added to `globalStateReferences` and the
+    // next-global-state component plugin destructures them at codegen time.
+    var definitions = params.globalStateDefinitions;
+    if (!definitions || Object.keys(definitions).length === 0) {
+        return;
+    }
+    for (var _b = 0, _c = Object.values(definitions); _b < _c.length; _b++) {
+        var def = _c[_b];
+        var name_1 = def === null || def === void 0 ? void 0 : def.name;
+        if (!name_1) {
+            continue;
+        }
+        var escaped = name_1.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        if (new RegExp("\\b".concat(escaped, "\\b")).test(expression)) {
+            params.globalStateReferences.push({ id: def.id, name: name_1 });
+        }
+    }
+};
+var normalizeGlobalRef = function (node) {
+    if (node.content.id || !node.content.refPath || node.content.refPath.length === 0) {
+        return node;
+    }
+    var firstSeg = node.content.refPath[0];
+    var mappedId = ast_utils_1.GLOBAL_REF_ID_MAP[firstSeg];
+    if (!mappedId) {
+        return node;
+    }
+    return __assign(__assign({}, node), { content: __assign(__assign({}, node.content), { id: mappedId, refPath: node.content.refPath.slice(1) }) });
+};
 var getElementType = function (node) {
     if (node.type === 'element' &&
         node.content &&
@@ -71,6 +172,65 @@ var getClassName = function (node) {
     }
     return null;
 };
+var REACT_CHARTJS2_CHART_TAGS = new Set([
+    'Line',
+    'Bar',
+    'Doughnut',
+    'Pie',
+    'Radar',
+    'Bubble',
+    'PolarArea',
+    'Scatter',
+]);
+var isReactChartjs2Chart = function (dependency, elementType) {
+    if ((dependency === null || dependency === void 0 ? void 0 : dependency.path) !== 'react-chartjs-2') {
+        return false;
+    }
+    return REACT_CHARTJS2_CHART_TAGS.has(elementType);
+};
+/**
+ * Chart.js with maintainAspectRatio:false fills the parent; if height is on the chart
+ * component via className, react-chartjs-2 may not apply it to the canvas host correctly
+ * inside flex layouts, causing unbounded growth. Wrap in a bounded div and move className
+ * to the wrapper; the chart fills with height/width 100%.
+ */
+var wrapReactChartJs2Element = function (chartElement, _node) {
+    var attrs = chartElement.openingElement.attributes;
+    var kept = [];
+    var classNameAttr = null;
+    for (var _i = 0, attrs_1 = attrs; _i < attrs_1.length; _i++) {
+        var a = attrs_1[_i];
+        if (a.type === 'JSXAttribute' &&
+            a.name.type === 'JSXIdentifier' &&
+            a.name.name === 'className') {
+            classNameAttr = a;
+        }
+        else {
+            kept.push(a);
+        }
+    }
+    chartElement.openingElement.attributes = kept;
+    var hasStyleAttr = kept.some(function (a) { return a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === 'style'; });
+    if (!hasStyleAttr) {
+        chartElement.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('style'), types.jsxExpressionContainer(types.objectExpression([
+            types.objectProperty(types.identifier('height'), types.stringLiteral('100%')),
+            types.objectProperty(types.identifier('width'), types.stringLiteral('100%')),
+        ]))));
+    }
+    var wrapperStyle = types.objectExpression([
+        types.objectProperty(types.identifier('position'), types.stringLiteral('relative')),
+        types.objectProperty(types.identifier('minHeight'), types.numericLiteral(0)),
+        types.objectProperty(types.identifier('flexShrink'), types.numericLiteral(0)),
+        types.objectProperty(types.identifier('overflow'), types.stringLiteral('hidden')),
+    ]);
+    var wrapperAttrs = [
+        types.jsxAttribute(types.jsxIdentifier('style'), types.jsxExpressionContainer(wrapperStyle)),
+    ];
+    if (classNameAttr) {
+        wrapperAttrs.push(classNameAttr);
+    }
+    return types.jsxElement(types.jsxOpeningElement(types.jsxIdentifier('div'), wrapperAttrs), types.jsxClosingElement(types.jsxIdentifier('div')), [chartElement], false);
+};
 var reorderChildrenForSearch = function (children) {
     var searchNodes = [];
     var dataProviderNodes = [];
@@ -117,6 +277,97 @@ var reorderChildrenForSearch = function (children) {
         return children;
     }
 };
+/**
+ * Extracts autocomplete context from a thq-autocomplete node's children.
+ * Returns the input's field name and the dropdown's isOpen state name,
+ * so child option/clear elements can wire up onClick handlers.
+ */
+var extractAutocompleteContext = function (children, formStateName) {
+    var _a, _b, _c, _d;
+    var fieldName = null;
+    var inputHtmlId = null;
+    var isOpenStateName = null;
+    for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+        var child = children_1[_i];
+        if (child.type === 'element') {
+            var content = child.content;
+            // Check both original elementType and data-thq attr (elementType may have been resolved)
+            var dataThq = (_a = content.attrs) === null || _a === void 0 ? void 0 : _a['data-thq'];
+            var thqValue = (dataThq === null || dataThq === void 0 ? void 0 : dataThq.type) === 'static' ? String(dataThq.content) : '';
+            if (content.elementType === 'thq-autocomplete-input' ||
+                thqValue === 'thq-autocomplete-input') {
+                var nameAttr = (_b = content.attrs) === null || _b === void 0 ? void 0 : _b.name;
+                if ((nameAttr === null || nameAttr === void 0 ? void 0 : nameAttr.type) === 'static' && typeof nameAttr.content === 'string') {
+                    fieldName = nameAttr.content;
+                }
+                var idAttr = (_c = content.attrs) === null || _c === void 0 ? void 0 : _c.id;
+                if ((idAttr === null || idAttr === void 0 ? void 0 : idAttr.type) === 'static' && typeof idAttr.content === 'string') {
+                    inputHtmlId = idAttr.content;
+                }
+            }
+        }
+        else if (child.type === 'conditional') {
+            var condContent = child.content;
+            var ref = (_d = condContent.reference) === null || _d === void 0 ? void 0 : _d.content;
+            if ((ref === null || ref === void 0 ? void 0 : ref.referenceType) === 'state' && typeof ref.id === 'string') {
+                isOpenStateName = ref.id;
+            }
+        }
+    }
+    if (fieldName && isOpenStateName) {
+        return { fieldName: fieldName, inputHtmlId: inputHtmlId || '', formStateName: formStateName, isOpenStateName: isOpenStateName };
+    }
+    return undefined;
+};
+var maybeAddFormStoreFieldBinding = function (elementTag, elementName, attrs, params, events) {
+    var stateKey = params.formStoreStateName;
+    if (!stateKey || !attrs) {
+        return;
+    }
+    var nameAttr = attrs.name;
+    if (!nameAttr || nameAttr.type !== 'static' || typeof nameAttr.content !== 'string') {
+        return;
+    }
+    var tag = elementName.toLowerCase();
+    var isRichTextEditor = tag === 'richtexteditor';
+    if (tag !== 'input' && tag !== 'textarea' && tag !== 'select' && !isRichTextEditor) {
+        return;
+    }
+    // Autocomplete inputs manage their own value through workflows and option onClick handlers.
+    // Do NOT bind them to the form store — it causes infinite loops with state-change workflows.
+    var dataThq = attrs['data-thq'];
+    if ((dataThq === null || dataThq === void 0 ? void 0 : dataThq.type) === 'static' && String(dataThq.content) === 'thq-autocomplete-input') {
+        return;
+    }
+    var fieldName = nameAttr.content;
+    var stateId = types.identifier(stateKey);
+    var fieldAccess = types.memberExpression(stateId, types.stringLiteral(fieldName), true);
+    var typeAttr = attrs.type;
+    var isCheckbox = (typeAttr === null || typeAttr === void 0 ? void 0 : typeAttr.type) === 'static' && String(typeAttr.content) === 'checkbox';
+    var hasValueInAttrs = Object.prototype.hasOwnProperty.call(attrs, 'value');
+    var hasCheckedInAttrs = Object.prototype.hasOwnProperty.call(attrs, 'checked');
+    if (isRichTextEditor) {
+        var valueForEditor = types.logicalExpression('||', fieldAccess, types.stringLiteral(''));
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('value'), types.jsxExpressionContainer(valueForEditor)));
+        var setterName = "set".concat(stateKey.charAt(0).toUpperCase()).concat(stateKey.slice(1));
+        var richHandler = (0, ast_utils_1.parseJSExpressionAsAST)("(html) => { ".concat(setterName, "(prev => ({ ...prev, ['").concat(fieldName, "']: html })); }"));
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onChange'), types.jsxExpressionContainer(richHandler)));
+        return;
+    }
+    if (!hasValueInAttrs && !isCheckbox) {
+        var valueExpr = types.logicalExpression('??', fieldAccess, types.stringLiteral(''));
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('value'), types.jsxExpressionContainer(valueExpr)));
+    }
+    else if (isCheckbox && !hasCheckedInAttrs) {
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('checked'), types.jsxExpressionContainer(fieldAccess)));
+    }
+    var hasUidlOnChange = events && Object.prototype.hasOwnProperty.call(events, 'onChange');
+    if (!hasUidlOnChange) {
+        var setterName = "set".concat(stateKey.charAt(0).toUpperCase()).concat(stateKey.slice(1));
+        var handler = (0, ast_utils_1.parseJSExpressionAsAST)("(e) => { const t = e.target; if (t.name) { ".concat(setterName, "(prev => ({ ...prev, [t.name]: t.type === 'checkbox' ? t.checked : t.value })); } }"));
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onChange'), types.jsxExpressionContainer(handler)));
+    }
+};
 var generateElementNode = function (node, params, jsxOptions) {
     var dependencies = params.dependencies, nodesLookup = params.nodesLookup;
     var options = __assign(__assign({}, constants_1.DEFAULT_JSX_OPTIONS), jsxOptions);
@@ -164,18 +415,86 @@ var generateElementNode = function (node, params, jsxOptions) {
         : tagName;
     var elementTag = selfClosing ? (0, ast_builders_1.createSelfClosingJSXTag)(elementName) : (0, ast_builders_1.createJSXTag)(elementName);
     if (attrs) {
-        addAttributesToJSXTag(attrs, elementTag, options, params);
+        addAttributesToJSXTag(attrs, elementTag, options, params, node.content.semanticType || elementType);
     }
     if (events) {
         Object.keys(events).forEach(function (eventKey) {
             (0, utils_1.addEventHandlerToTag)(elementTag, eventKey, events[eventKey], params, options);
         });
     }
+    // Generate onChange handler for form elements with data-store-values-state
+    var childParams = params;
+    if (attrs === null || attrs === void 0 ? void 0 : attrs['data-store-values-state']) {
+        var storeAttr = attrs['data-store-values-state'];
+        if (storeAttr.type === 'static' && typeof storeAttr.content === 'string') {
+            var stateName = storeAttr.content;
+            childParams = __assign(__assign({}, params), { formStoreStateName: stateName });
+            var setterName = "set".concat(stateName.charAt(0).toUpperCase()).concat(stateName.slice(1));
+            var handler = (0, ast_utils_1.parseJSExpressionAsAST)("(e) => { const t = e.target; if (t.name && t.getAttribute('data-thq') !== 'thq-autocomplete-input') { ".concat(setterName, "(prev => ({ ...prev, [t.name]: t.type === 'checkbox' ? t.checked : t.value })); } }"));
+            elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onChange'), types.jsxExpressionContainer(handler)));
+        }
+    }
+    maybeAddFormStoreFieldBinding(elementTag, elementName, attrs, childParams, events);
+    // thq-autocomplete-input: make uncontrolled by converting `value` → `defaultValue`
+    // A controlled autocomplete input triggers state-change workflows on every keystroke,
+    // which normalizes the typed text and prevents free typing for search/filtering.
+    var dataThqAttr = attrs === null || attrs === void 0 ? void 0 : attrs['data-thq'];
+    var dataThqValue = (dataThqAttr === null || dataThqAttr === void 0 ? void 0 : dataThqAttr.type) === 'static' ? String(dataThqAttr.content) : '';
+    if (dataThqValue === 'thq-autocomplete-input') {
+        var jsxAttrs = elementTag.openingElement.attributes;
+        var valueIdx = jsxAttrs.findIndex(function (a) { return a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === 'value'; });
+        if (valueIdx !== -1) {
+            // Convert value → defaultValue so the input is uncontrolled but has initial value
+            var valueAttr = jsxAttrs[valueIdx];
+            jsxAttrs.splice(valueIdx, 1, types.jsxAttribute(types.jsxIdentifier('defaultValue'), valueAttr.value));
+        }
+    }
+    if (dataThqValue === 'thq-autocomplete' && children) {
+        var acCtx = extractAutocompleteContext(children, childParams.formStoreStateName);
+        if (acCtx) {
+            childParams = __assign(__assign({}, childParams), { autocompleteContext: acCtx });
+        }
+    }
+    // thq-autocomplete-option: add onClick to select the option value
+    if (dataThqValue === 'thq-autocomplete-option' && params.autocompleteContext) {
+        var _b = params.autocompleteContext, fieldName = _b.fieldName, formStateName = _b.formStateName, isOpenStateName = _b.isOpenStateName, inputHtmlId = _b.inputHtmlId;
+        var isOpenSetterName = "set".concat(isOpenStateName.charAt(0).toUpperCase()).concat(isOpenStateName.slice(1));
+        var handlerCode 
+        // The autocomplete input is uncontrolled, so always set the DOM value.
+        // If form-store mode, also update the form state for form submission.
+        = void 0;
+        // The autocomplete input is uncontrolled, so always set the DOM value.
+        // If form-store mode, also update the form state for form submission.
+        var inputLookup = inputHtmlId
+            ? "document.getElementById('".concat(inputHtmlId, "')")
+            : "e.currentTarget.closest('[data-thq=\"thq-autocomplete\"]').querySelector('[data-thq=\"thq-autocomplete-input\"]')";
+        var formStoreUpdate = formStateName
+            ? "var setter = ".concat("set".concat(formStateName.charAt(0).toUpperCase()).concat(formStateName.slice(1)), "; setter(function(prev) { return Object.assign({}, prev, { ['").concat(fieldName, "']: text }); });")
+            : '';
+        handlerCode = "(e) => { var text = (e.currentTarget.textContent || '').trim(); var input = ".concat(inputLookup, "; if (input) { input.value = text; } ").concat(formStoreUpdate, " ").concat(isOpenSetterName, "(false); }");
+        var handler = (0, ast_utils_1.parseJSExpressionAsAST)(handlerCode);
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onClick'), types.jsxExpressionContainer(handler)));
+    }
+    // thq-autocomplete-clear: add onClick to clear the input value and close dropdown
+    if (dataThqValue === 'thq-autocomplete-clear' && params.autocompleteContext) {
+        var _c = params.autocompleteContext, fieldName = _c.fieldName, formStateName = _c.formStateName, isOpenStateName = _c.isOpenStateName, inputHtmlId = _c.inputHtmlId;
+        var isOpenSetterName = "set".concat(isOpenStateName.charAt(0).toUpperCase()).concat(isOpenStateName.slice(1));
+        var handlerCode = void 0;
+        var clearInputLookup = inputHtmlId
+            ? "document.getElementById('".concat(inputHtmlId, "')")
+            : "e.currentTarget.closest('[data-thq=\"thq-autocomplete\"]').querySelector('[data-thq=\"thq-autocomplete-input\"]')";
+        var clearFormStoreUpdate = formStateName
+            ? "var setter = ".concat("set".concat(formStateName.charAt(0).toUpperCase()).concat(formStateName.slice(1)), "; setter(function(prev) { return Object.assign({}, prev, { ['").concat(fieldName, "']: '' }); });")
+            : '';
+        handlerCode = "(e) => { var input = ".concat(clearInputLookup, "; if (input) { input.value = ''; } ").concat(clearFormStoreUpdate, " ").concat(isOpenSetterName, "(false); }");
+        var handler = (0, ast_utils_1.parseJSExpressionAsAST)(handlerCode);
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onClick'), types.jsxExpressionContainer(handler)));
+    }
     if (!selfClosing && children) {
         // Reorder children to ensure search nodes appear before DataProvider nodes
         var reorderedChildren = reorderChildrenForSearch(children);
         reorderedChildren.forEach(function (child) {
-            var childTags = generateNode(child, params, options);
+            var childTags = generateNode(child, childParams, options);
             childTags.forEach(function (childTag) {
                 if (typeof childTag === 'string') {
                     (0, ast_utils_1.addChildJSXText)(elementTag, childTag);
@@ -189,23 +508,71 @@ var generateElementNode = function (node, params, jsxOptions) {
             });
         });
     }
+    if (dependency && isReactChartjs2Chart(dependency, originalElementName)) {
+        var wrapped = wrapReactChartJs2Element(elementTag, node);
+        nodesLookup[key] = wrapped;
+        return wrapped;
+    }
     nodesLookup[key] = elementTag;
     return elementTag;
 };
 exports.default = generateElementNode;
-var addAttributesToJSXTag = function (attrs, elementTag, options, params) {
+var addAttributesToJSXTag = function (attrs, elementTag, options, params, elementName) {
     Object.keys(attrs !== null && attrs !== void 0 ? attrs : {}).forEach(function (attrKey) {
         var attributeValue = attrs[attrKey];
         if (!attributeValue.type) {
             return;
         }
+        // Skip code-gen directives - handled in generateElementNode
+        if (attrKey === 'data-store-values-state') {
+            return;
+        }
+        // Plan v15 Layer 4 — codegen safety net.
+        //
+        // Drop attributes that look like AI fabrication artefacts even when the
+        // upstream pipeline missed them. These never produce valid DOM/JSX:
+        //   1. attr names that are pure JS literals (`true`, `false`, bare
+        //      numbers, `null`, `undefined`) — e.g. the `true="true"` that
+        //      shipped with the broken Navigation in the 2026-05-24 run.
+        //   2. static string values that contain entity-escaped binding markers
+        //      (`&#123;` / `&#125;`) — emitting them produces broken DOM text.
+        //   3. static string values that contain an UNBALANCED `{{` (no
+        //      matching `}}`) — always garbage, never valid.
+        if (isJunkAttributeName(attrKey)) {
+            // eslint-disable-next-line no-console
+            console.warn("[codegen safety net] dropping junk-name attribute \"".concat(attrKey, "\" on <").concat(elementName !== null && elementName !== void 0 ? elementName : 'element', ">"));
+            return;
+        }
+        if (attributeValue.type === 'static') {
+            var staticContent = attributeValue.content;
+            if (typeof staticContent === 'string' && hasCorruptBindingMarkers(staticContent)) {
+                // eslint-disable-next-line no-console
+                console.warn("[codegen safety net] dropping attribute \"".concat(attrKey, "\" on <").concat(elementName !== null && elementName !== void 0 ? elementName : 'element', "> \u2014 value has entity-escaped or truncated binding markers (").concat(truncate(staticContent), ")"));
+                return;
+            }
+        }
         switch (attributeValue.type) {
             case 'dynamic':
-                var referenceType = attributeValue.content.referenceType;
+                var dynamicRef = attributeValue;
+                var referenceType = dynamicRef.content.referenceType;
+                if (referenceType === 'global') {
+                    var normRef = normalizeGlobalRef(dynamicRef);
+                    params.globalReferences.push(normRef.content.id);
+                    // Use the normalized ref to generate the attribute expression
+                    var globalExpr = (0, utils_1.createDynamicValueExpression)(normRef, options);
+                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.convertToReactAttributeName)(attrKey)), types.jsxExpressionContainer(globalExpr)));
+                    break;
+                }
+                if (referenceType === 'globalState') {
+                    var gsName = (0, utils_1.resolveGlobalStateName)(dynamicRef.content.id, params.globalStateDefinitions);
+                    params.globalStateReferences.push({ id: dynamicRef.content.id, name: gsName });
+                    var expr = (0, utils_1.createGlobalStateExpression)(dynamicRef, params.globalStateDefinitions);
+                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.convertToReactAttributeName)(attrKey)), types.jsxExpressionContainer(expr)));
+                    break;
+                }
                 switch (referenceType) {
                     default:
-                        var prefix = options.dynamicReferencePrefixMap[referenceType];
-                        var dynamicRef = attributeValue;
+                        var prefix = options.dynamicReferencePrefixMap[referenceType] || '';
                         var idWithRefPath = teleport_shared_1.UIDLUtils.generateIdWithRefPath(dynamicRef.content.id, dynamicRef.content.refPath);
                         (0, ast_utils_1.addDynamicAttributeToJSXTag)(elementTag, attrKey, idWithRefPath, prefix);
                         break;
@@ -214,15 +581,50 @@ var addAttributesToJSXTag = function (attrs, elementTag, options, params) {
             case 'import':
                 (0, ast_utils_1.addDynamicAttributeToJSXTag)(elementTag, attrKey, attributeValue.content.id);
                 break;
-            case 'raw':
+            case 'raw': {
+                var rawValue = attributeValue;
+                if (elementName === 'markdown-node') {
+                    if (rawValue.dynamic) {
+                        applyDynamicMarkdownInjection(elementTag, rawValue, params, options);
+                    }
+                    else {
+                        applyStaticMarkdownInjection(elementTag, rawValue, params);
+                    }
+                    break;
+                }
+                if (elementName === 'rich-text-editor-node') {
+                    applyRichTextEditorRawAttribute(elementTag, attrKey, rawValue, params, options);
+                    break;
+                }
+                if (rawValue.dynamic) {
+                    applyDynamicHtmlInjection(elementTag, rawValue, params, options);
+                    break;
+                }
                 (0, ast_utils_1.addRawAttributeToJSXTag)(elementTag, attrKey, attributeValue);
                 break;
+            }
             case 'comp-style':
-            case 'static':
                 (0, ast_utils_1.addAttributeToJSXTag)(elementTag, attrKey, attributeValue.content);
                 break;
+            case 'static':
+                if (typeof attributeValue.content === 'object' &&
+                    attributeValue.content !== null &&
+                    !Array.isArray(attributeValue.content)) {
+                    var constName = "__staticProp".concat(params.hoistedConstants.length);
+                    var expression = (0, ast_utils_1.objectToObjectExpression)(attributeValue.content);
+                    params.hoistedConstants.push({ name: constName, expression: expression });
+                    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier((0, ast_utils_1.convertToReactAttributeName)(attrKey)), types.jsxExpressionContainer(types.identifier(constName))));
+                }
+                else {
+                    (0, ast_utils_1.addAttributeToJSXTag)(elementTag, attrKey, attributeValue.content);
+                }
+                break;
             case 'expr':
                 (0, ast_utils_1.addDynamicExpressionAttributeToJSXTag)(elementTag, attributeValue, attrKey);
+                // Scan the *sanitized* content so any globals introduced by the
+                // repair (e.g. `/profile/${}` → `/profile/${currentUser?.id}`) still
+                // trigger the downstream useGlobalContext() wiring.
+                trackGlobalRefsInExpression((0, ast_utils_1.sanitizeExprContent)(String(attributeValue.content), attrKey), params);
                 break;
             case 'element':
                 (0, ast_utils_1.addAttributeToJSXTag)(elementTag, attrKey, generateElementNode(attributeValue, params, options));
@@ -241,23 +643,65 @@ var addAttributesToJSXTag = function (attrs, elementTag, options, params) {
         }
     });
 };
+/**
+ * Converts text containing {{ expr }} templates into a mix of JSX text and expression containers.
+ * e.g. "x{{ (state.score / 10) || '0' }}" → ["x", JSXExpressionContainer((score / 10) || '0')]
+ *
+ * Uses parseStringWithTemplateExpressions to parse the template into a TemplateLiteral AST,
+ * then converts its quasis (text parts) and expressions into JSX children.
+ */
+var convertTextTemplateToJSX = function (text) {
+    try {
+        var templateLiteral = (0, ast_utils_1.parseStringWithTemplateExpressions)(text);
+        var result = [];
+        for (var i = 0; i < templateLiteral.quasis.length; i++) {
+            var quasi = templateLiteral.quasis[i];
+            var textPart = quasi.value.cooked || quasi.value.raw;
+            if (textPart) {
+                result.push(teleport_shared_1.StringUtils.encode(textPart));
+            }
+            if (i < templateLiteral.expressions.length) {
+                result.push(types.jsxExpressionContainer(templateLiteral.expressions[i]));
+            }
+        }
+        return result.length > 0 ? result : [teleport_shared_1.StringUtils.encode(text)];
+    }
+    catch (_a) {
+        // If parsing fails, fall back to encoded text
+        return [teleport_shared_1.StringUtils.encode(text)];
+    }
+};
 var generateNode = function (node, params, options) {
+    var _a;
     switch (node.type) {
         case 'expr':
             return [generateExpressionNode(node, params, options)];
-        case 'raw':
+        case 'raw': {
+            var rawNode = node;
+            if (rawNode.dynamic) {
+                var dynamicExpr = resolveDynamicReferenceExpression(rawNode.dynamic, params, options);
+                var fallback = rawNode.fallback || rawNode.content;
+                return [__1.ASTBuilders.createDynamicDOMInjectionNode(dynamicExpr, fallback)];
+            }
             return [
                 options.domHTMLInjection
                     ? options.domHTMLInjection(node.content.toString())
                     : node.content.toString(),
             ];
+        }
         case 'inject':
             if (node === null || node === void 0 ? void 0 : node.dependency) {
                 params.dependencies.Script = node.dependency;
             }
             return [node.content.toString()];
-        case 'static':
-            return [teleport_shared_1.StringUtils.encode(node.content.toString())];
+        case 'static': {
+            var textContent = node.content.toString();
+            // Check if the text contains {{ }} template expressions
+            if (/\{\{/.test(textContent)) {
+                return convertTextTemplateToJSX(textContent);
+            }
+            return [teleport_shared_1.StringUtils.encode(textContent)];
+        }
         case 'dynamic':
             switch (node.content.referenceType) {
                 case 'prop': {
@@ -296,10 +740,18 @@ var generateNode = function (node, params, options) {
                     return [jsxTag];
                 }
                 case 'global': {
-                    params.globalReferences.push(node.content.id);
-                    return [(0, utils_1.createDynamicValueExpression)(node, options)];
+                    var globalNode = normalizeGlobalRef(node);
+                    params.globalReferences.push(globalNode.content.id);
+                    return [(0, utils_1.createDynamicValueExpression)(globalNode, options)];
                 }
                 default:
+                    if (node.content.referenceType === 'globalState') {
+                        var gsName = (0, utils_1.resolveGlobalStateName)(node.content.id, params.globalStateDefinitions);
+                        params.globalStateReferences.push({ id: node.content.id, name: gsName });
+                        return [
+                            (0, utils_1.createGlobalStateExpression)(node, params.globalStateDefinitions),
+                        ];
+                    }
                     return [(0, utils_1.createDynamicValueExpression)(node, options)];
             }
         case 'cms-item':
@@ -312,7 +764,7 @@ var generateNode = function (node, params, options) {
         case 'data-source-item':
         case 'data-source-list':
             return generateDataSourceNode(node, params, options);
-        case 'element':
+        case 'element': {
             // Check if this element node is wrapping a data-source node
             if (node.content &&
                 typeof node.content === 'object' &&
@@ -322,7 +774,15 @@ var generateNode = function (node, params, options) {
                 // tslint:disable-next-line:no-any
                 return generateDataSourceNode(node.content, params, options);
             }
-            return [generateElementNode(node, params, options)];
+            var elementTag = generateElementNode(node, params, options);
+            var renderingConditions = (_a = node.content) === null || _a === void 0 ? void 0 : _a.renderingConditions;
+            if (renderingConditions) {
+                return [
+                    wrapWithConditional(elementTag, renderingConditions.reference, renderingConditions.condition, params, options),
+                ];
+            }
+            return [elementTag];
+        }
         case 'repeat':
             return generateRepeatNode(node, params, options);
         case 'conditional':
@@ -383,7 +843,7 @@ var generateCMSNode = function (node, params, options) {
     }
     var cmsNode = __1.ASTBuilders.createJSXTag(jsxTag, [], true);
     if (node.type === 'cms-item') {
-        cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('renderSuccess'), types.jsxExpressionContainer(types.arrowFunctionExpression([types.identifier(renderPropIdentifier)], generateNode(success, params, options)[0]))));
+        cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('renderSuccess'), types.jsxExpressionContainer(types.arrowFunctionExpression([types.identifier(renderPropIdentifier)], generateNode(success, params, __assign(__assign({}, options), { localIdentifier: renderPropIdentifier }))[0]))));
     }
     if (node.type === 'cms-list') {
         cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('renderSuccess'), types.jsxExpressionContainer(types.arrowFunctionExpression([types.identifier('params')], generateNode(success, params, options)[0]))));
@@ -397,18 +857,24 @@ var generateCMSNode = function (node, params, options) {
     if (error) {
         cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('renderError'), types.jsxExpressionContainer(types.arrowFunctionExpression([], generateNode(error, params, options)[0]))));
     }
-    if (initialData && initialData.content.referenceType === 'prop') {
-        cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('initialData'), types.jsxExpressionContainer(types.memberExpression(types.identifier(options.dynamicReferencePrefixMap[initialData.content.referenceType]), types.identifier(initialData.content.id)))));
+    if (initialData && initialData.content.referenceType) {
+        var refType = initialData.content.referenceType;
+        var initialDataExpr = refType === 'prop'
+            ? types.memberExpression(types.identifier(options.dynamicReferencePrefixMap[refType]), types.identifier(initialData.content.id))
+            : types.identifier(initialData.content.id);
+        cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('initialData'), types.jsxExpressionContainer(initialDataExpr)));
         cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('persistDataDuringLoading'), types.jsxExpressionContainer(types.booleanLiteral(true))));
-        var keyValue = 'props?.pagination?.page';
-        if (node.type === 'cms-item') {
-            var entityKeyProperty = node.content.entityKeyProperty;
-            var entityName = initialData.content.id;
-            keyValue = entityKeyProperty
-                ? "props?.".concat(entityName, "?.").concat(entityKeyProperty)
-                : "props?.".concat(entityName, "?.id");
+        if (refType === 'prop') {
+            var keyValue = 'props?.pagination?.page';
+            if (node.type === 'cms-item') {
+                var entityKeyProperty = node.content.entityKeyProperty;
+                var entityName = initialData.content.id;
+                keyValue = entityKeyProperty
+                    ? "props?.".concat(entityName, "?.").concat(entityKeyProperty)
+                    : "props?.".concat(entityName, "?.id");
+            }
+            cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('key'), types.jsxExpressionContainer(types.identifier(keyValue))));
         }
-        cmsNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('key'), types.jsxExpressionContainer(types.identifier(keyValue))));
     }
     if (Object.keys(resourceParams || {}).length > 0) {
         var nodeParams = Object.keys(resourceParams).reduce(function (acc, attrKey) {
@@ -433,8 +899,8 @@ var generateCMSNode = function (node, params, options) {
     return [cmsNode];
 };
 var generateDataSourceNode = function (node, params, options) {
-    var _a, _b, _c, _d;
-    var _e = node.content, renderPropIdentifier = _e.renderPropIdentifier, elementType = _e.elementType, dependency = _e.dependency, resourceDefinition = _e.resourceDefinition;
+    var _a, _b, _c, _d, _e;
+    var _f = node.content, renderPropIdentifier = _f.renderPropIdentifier, elementType = _f.elementType, dependency = _f.dependency, resourceDefinition = _f.resourceDefinition;
     var key = node.content.key || "ds-".concat(resourceDefinition.dataSourceId, "-").concat(Date.now());
     var name = node.content.name || renderPropIdentifier;
     // tslint:disable-next-line:no-any
@@ -456,7 +922,10 @@ var generateDataSourceNode = function (node, params, options) {
     ]))));
     dataSourceNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('name'), types.jsxExpressionContainer(types.stringLiteral(name))));
     if (children && children.length > 0) {
-        var childrenNodes = children.flatMap(function (child) { return generateNode(child, params, options); });
+        // Pass the render prop identifier as the 'ctx' prefix for data source context references
+        // and as the localIdentifier so conditional nodes resolve local refs correctly
+        var childOptions_1 = __assign(__assign({}, options), { localIdentifier: renderPropIdentifier, dynamicReferencePrefixMap: __assign(__assign({}, options.dynamicReferencePrefixMap), { ctx: renderPropIdentifier }) });
+        var childrenNodes = children.flatMap(function (child) { return generateNode(child, params, childOptions_1); });
         var renderFunction = types.arrowFunctionExpression([types.identifier(renderPropIdentifier)], types.jsxFragment(types.jsxOpeningFragment(), types.jsxClosingFragment(), childrenNodes));
         dataSourceNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('renderSuccess'), types.jsxExpressionContainer(renderFunction)));
     }
@@ -509,6 +978,17 @@ var generateDataSourceNode = function (node, params, options) {
         }, []);
         dataSourceNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('params'), types.jsxExpressionContainer(types.objectExpression(nodeParams))));
     }
+    // Add initialData if the UIDL node has it (similar to CMS nodes)
+    // tslint:disable-next-line:no-any
+    var nodeInitialData = node.content.initialData;
+    if (nodeInitialData && ((_e = nodeInitialData.content) === null || _e === void 0 ? void 0 : _e.referenceType)) {
+        var refType = nodeInitialData.content.referenceType;
+        var initialDataExpr = refType === 'prop'
+            ? types.memberExpression(types.identifier(options.dynamicReferencePrefixMap[refType]), types.identifier(nodeInitialData.content.id))
+            : types.identifier(nodeInitialData.content.id);
+        dataSourceNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('initialData'), types.jsxExpressionContainer(initialDataExpr)));
+        dataSourceNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('persistDataDuringLoading'), types.jsxExpressionContainer(types.booleanLiteral(true))));
+    }
     params.nodesLookup[key] = dataSourceNode;
     return [dataSourceNode];
 };
@@ -531,30 +1011,86 @@ var generateRepeatNode = function (node, params, options) {
         ]));
     });
 };
-var generateConditionalNode = function (node, params, options) {
-    var _a = node.content, reference = _a.reference, value = _a.value;
-    var subTrees = generateNode(node.content.node, params, options);
-    // Track global references used in conditionals
+// Shared between UIDLConditionalNode (wraps a child subtree) and the inline
+// `renderingConditions` property on UIDLElement content. Tracks global and
+// globalState references on params, resolves the condition identifier, and
+// builds the `condition && <content/>` logical expression.
+var wrapWithConditional = function (subTree, reference, condition, params, options) {
     if (reference.type === 'dynamic' &&
         'referenceType' in reference.content &&
         reference.content.referenceType === 'global') {
-        params.globalReferences.push(reference.content.id);
+        var normCondRef = normalizeGlobalRef(reference);
+        params.globalReferences.push(normCondRef.content.id);
     }
+    if (reference.type === 'dynamic' &&
+        'referenceType' in reference.content &&
+        reference.content.referenceType === 'globalState') {
+        var gsName = (0, utils_1.resolveGlobalStateName)(reference.content.id, params.globalStateDefinitions);
+        params.globalStateReferences.push({ id: reference.content.id, name: gsName });
+    }
+    var effectiveRef = reference.type === 'dynamic' &&
+        'referenceType' in reference.content &&
+        reference.content.referenceType === 'global'
+        ? normalizeGlobalRef(reference)
+        : reference;
+    var conditionIdentifier = (0, utils_1.createConditionIdentifier)(effectiveRef, params, options);
+    return (0, utils_1.createConditionalJSXExpression)(subTree, condition, conditionIdentifier, {
+        localIdentifier: options.localIdentifier,
+        detailsPageExposeAsName: options.detailsPageExposeAsName || params.detailsPageExposeAsName,
+    });
+};
+var generateConditionalNode = function (node, params, options) {
+    var _a = node.content, reference = _a.reference, value = _a.value;
+    var subTrees = generateNode(node.content.node, params, options);
     var condition = value !== undefined && value !== null
         ? { conditions: [{ operand: value, operation: '===' }] }
         : node.content.condition;
-    var conditionIdentifier = (0, utils_1.createConditionIdentifier)(reference, params, options);
-    var conditionalExpressions = subTrees.map(function (subTree) {
-        return (0, utils_1.createConditionalJSXExpression)(subTree, condition, conditionIdentifier);
+    return subTrees.map(function (subTree) {
+        return wrapWithConditional(subTree, reference, condition, params, options);
     });
-    return conditionalExpressions;
 };
 var generateCMSListRepeaterNode = function (node, params, options) {
-    var _a, _b;
+    var _a, _b, _c;
     var jsxTag = teleport_shared_1.StringUtils.dashCaseToUpperCamelCase(node.content.elementType);
     var repeaterNode = __1.ASTBuilders.createJSXTag(jsxTag, [], true);
-    repeaterNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('items'), types.jsxExpressionContainer(types.identifier((_a = node.content.source) !== null && _a !== void 0 ? _a : 'params'))));
-    var listElement = generateNode(node.content.nodes.list, params, __assign(__assign({}, options), { localIdentifier: node.content.renderPropIdentifier }))[0];
+    var dataNodeIdAttr = (_a = node.content.attrs) === null || _a === void 0 ? void 0 : _a.dataNodeId;
+    if (dataNodeIdAttr === null || dataNodeIdAttr === void 0 ? void 0 : dataNodeIdAttr.content) {
+        (0, ast_utils_1.addAttributeToJSXTag)(repeaterNode, 'dataNodeId', dataNodeIdAttr.content);
+    }
+    // When the repeater source is a global context like "ecommerce", resolve to
+    // the appropriate array from the ecommerce context based on what the repeater
+    // iterates over (determined by renderPropIdentifier).
+    var repeaterItemsExpr;
+    var source = (_b = node.content.source) !== null && _b !== void 0 ? _b : 'params';
+    if (source === 'ecommerce') {
+        var rpId = node.content.renderPropIdentifier || '';
+        // Map renderPropIdentifier to the correct ecommerce context path
+        var ecommercePathMap = {
+            paymentProvider: ['paymentProviders'],
+            storeLocation: ['storeLocations'],
+        };
+        // Default: cart items for orderItem, cartItem, or any unrecognized identifier
+        var path = ecommercePathMap[rpId] || ['Cart', 'items'];
+        var expr = types.identifier('ecommerce');
+        for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
+            var seg = path_1[_i];
+            expr = types.optionalMemberExpression(expr, types.identifier(seg), false, true);
+        }
+        repeaterItemsExpr = types.logicalExpression('||', expr, types.arrayExpression([]));
+        params.globalReferences.push('ecommerce');
+    }
+    else {
+        // Resolve any global-state reference encoded in `source` and register it
+        // so the `next-global-state` component plugin destructures the matching
+        // identifier from `useGlobalState()`. Without this, sources emitted as
+        // either `<globalStateName> || []` (modern) or `globalState_<defId>`
+        // (legacy) compile to a `ReferenceError` at render time because the
+        // identifier never enters scope.
+        var resolvedSource = (0, utils_1.resolveAndRegisterGlobalStateSource)(source, params);
+        repeaterItemsExpr = types.identifier(resolvedSource);
+    }
+    repeaterNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('items'), types.jsxExpressionContainer(repeaterItemsExpr)));
+    var listElement = generateNode(node.content.nodes.list, params, __assign(__assign({}, options), { localIdentifier: node.content.renderPropIdentifier, dynamicReferencePrefixMap: __assign(__assign({}, options.dynamicReferencePrefixMap), { ctx: node.content.renderPropIdentifier }) }))[0];
     // Create key as template literal: `${item?.id}${index}`
     var keyAttribute = types.jsxAttribute(types.jsxIdentifier('key'), types.jsxExpressionContainer(types.templateLiteral([
         types.templateElement({ raw: '', cooked: '' }, false),
@@ -572,7 +1108,7 @@ var generateCMSListRepeaterNode = function (node, params, options) {
     if ('loading' in node.content.nodes) {
         generateNode(node.content.nodes.loading, params, options);
     }
-    if (((_b = node.content) === null || _b === void 0 ? void 0 : _b.dependency) && options.dependencyHandling === 'import') {
+    if (((_c = node.content) === null || _c === void 0 ? void 0 : _c.dependency) && options.dependencyHandling === 'import') {
         params.dependencies[jsxTag] = node.content.dependency;
     }
     return [repeaterNode];
@@ -622,4 +1158,127 @@ var generateNativeSlotNode = function (node, params, options) {
     }
     return slotNode;
 };
+var resolveDynamicReferenceExpression = function (dynamicRef, params, options) {
+    var referenceType = dynamicRef.content.referenceType;
+    if (referenceType === 'global') {
+        var normDynRef = normalizeGlobalRef(dynamicRef);
+        params.globalReferences.push(normDynRef.content.id);
+        return (0, utils_1.createDynamicValueExpression)(normDynRef, options);
+    }
+    if (referenceType === 'globalState') {
+        var gsName = (0, utils_1.resolveGlobalStateName)(dynamicRef.content.id, params.globalStateDefinitions);
+        params.globalStateReferences.push({ id: dynamicRef.content.id, name: gsName });
+        return (0, utils_1.createGlobalStateExpression)(dynamicRef, params.globalStateDefinitions);
+    }
+    return (0, utils_1.createDynamicValueExpression)(dynamicRef, options);
+};
+var applyDynamicHtmlInjection = function (elementTag, rawValue, params, options) {
+    var dynamicExpr = resolveDynamicReferenceExpression(rawValue.dynamic, params, options);
+    var fallbackContent = rawValue.fallback || rawValue.content;
+    var fallbackExpr = types.stringLiteral(fallbackContent);
+    var valueExpr = types.logicalExpression('||', dynamicExpr, fallbackExpr);
+    elementTag.openingElement.name.name = 'span';
+    if (elementTag.closingElement) {
+        ;
+        elementTag.closingElement.name.name = 'span';
+    }
+    elementTag.openingElement.selfClosing = true;
+    elementTag.closingElement = null;
+    elementTag.children = [];
+    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('dangerouslySetInnerHTML'), types.jsxExpressionContainer(types.objectExpression([types.objectProperty(types.identifier('__html'), valueExpr)]))));
+    Object.keys(params.dependencies).forEach(function (key) {
+        var _a, _b;
+        if ((_b = (_a = params.dependencies[key]) === null || _a === void 0 ? void 0 : _a.path) === null || _b === void 0 ? void 0 : _b.includes('dangerous-html')) {
+            delete params.dependencies[key];
+        }
+    });
+};
+var applyStaticMarkdownInjection = function (elementTag, rawValue, params) {
+    var content = rawValue.content || '';
+    elementTag.openingElement.name.name = 'div';
+    elementTag.openingElement.selfClosing = true;
+    elementTag.closingElement = null;
+    elementTag.children = [];
+    elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('dangerouslySetInnerHTML'), types.jsxExpressionContainer(types.objectExpression([
+        types.objectProperty(types.identifier('__html'), types.stringLiteral(content)),
+    ]))));
+    cleanupMarkdownMappingDependencies(params);
+};
+var applyDynamicMarkdownInjection = function (elementTag, rawValue, params, options) {
+    var dynamicExpr = resolveDynamicReferenceExpression(rawValue.dynamic, params, options);
+    var fallbackContent = rawValue.fallback || rawValue.content;
+    var reactMarkdownTag = (0, ast_builders_1.createJSXTag)('ReactMarkdown');
+    (0, ast_utils_1.addChildJSXTag)(reactMarkdownTag, types.jsxExpressionContainer(types.cloneNode(dynamicExpr)));
+    var fallbackTag = __1.ASTBuilders.createDOMInjectionNode(fallbackContent);
+    var conditionalExpr = types.conditionalExpression(dynamicExpr, reactMarkdownTag, fallbackTag);
+    elementTag.openingElement.name.name = 'div';
+    elementTag.openingElement.selfClosing = false;
+    if (!elementTag.closingElement) {
+        elementTag.closingElement = types.jsxClosingElement(types.jsxIdentifier('div'));
+    }
+    else {
+        ;
+        elementTag.closingElement.name.name = 'div';
+    }
+    elementTag.children = [types.jsxExpressionContainer(conditionalExpr)];
+    cleanupMarkdownMappingDependencies(params);
+    params.dependencies.ReactMarkdown = {
+        type: 'package',
+        path: 'react-markdown',
+        version: '^8.0.7',
+    };
+};
+var cleanupMarkdownMappingDependencies = function (params) {
+    Object.keys(params.dependencies).forEach(function (key) {
+        var _a, _b;
+        if ((_b = (_a = params.dependencies[key]) === null || _a === void 0 ? void 0 : _a.path) === null || _b === void 0 ? void 0 : _b.includes('markdown-to-jsx')) {
+            delete params.dependencies[key];
+        }
+    });
+};
+/**
+ * Handles raw attributes on a rich-text-editor-node element.
+ *
+ * - `html` attribute → becomes a `value` prop (static string or dynamic expression with fallback)
+ * - `quillFormats` attribute → parsed from JSON string into a JS array expression
+ */
+var applyRichTextEditorRawAttribute = function (elementTag, attrKey, rawValue, params, options) {
+    if (attrKey === 'html' && params.formStoreStateName) {
+        return;
+    }
+    if (attrKey === 'html') {
+        if (rawValue.dynamic) {
+            var dynamicExpr = resolveDynamicReferenceExpression(rawValue.dynamic, params, options);
+            var fallbackContent = rawValue.fallback || rawValue.content || '';
+            var valueExpr = types.logicalExpression('||', dynamicExpr, types.stringLiteral(fallbackContent));
+            elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('value'), types.jsxExpressionContainer(valueExpr)));
+        }
+        else {
+            var content = rawValue.content || '';
+            (0, ast_utils_1.addAttributeToJSXTag)(elementTag, 'value', content);
+        }
+        return;
+    }
+    if (attrKey === 'quillFormats') {
+        var formats = null;
+        try {
+            var parsed = JSON.parse(rawValue.content);
+            if (Array.isArray(parsed)) {
+                formats = parsed;
+            }
+        }
+        catch (_a) {
+            // Parsing failed → don't add the attribute; component will use all formats
+        }
+        if (formats === null) {
+            // Parse failure or not an array → omit attribute so component uses all formats
+            return;
+        }
+        var arrayExpr = types.arrayExpression(formats.map(function (f) { return types.stringLiteral(f); }));
+        elementTag.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('quillFormats'), types.jsxExpressionContainer(arrayExpr)));
+        return;
+    }
+    // Any other raw attribute on rich-text-editor-node: fall through to default handling
+    (0, ast_utils_1.addRawAttributeToJSXTag)(elementTag, attrKey, rawValue);
+};
 //# sourceMappingURL=index.js.map