@teleporthq/teleport-plugin-common 0.42.35 → 0.43.0

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

@@ -32,7 +32,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRepeatSourceIdentifier = exports.createBinaryExpression = exports.createConditionalJSXExpression = exports.createConditionIdentifier = exports.createDynamicValueExpression = exports.addEventHandlerToTag = void 0;
+exports.getRepeatSourceIdentifier = exports.createBinaryExpression = exports.createConditionalJSXExpression = exports.createConditionIdentifier = exports.createDynamicValueExpression = exports.createGlobalStateExpression = exports.resolveAndRegisterGlobalStateSource = exports.resolveGlobalStateName = exports.createStateChangeStatement = exports.addEventHandlerToTag = void 0;
 var types = __importStar(require("@babel/types"));
 var ast_utils_1 = require("../../utils/ast-utils");
 var teleport_shared_1 = require("@teleporthq/teleport-shared");
@@ -45,7 +45,7 @@ var addEventHandlerToTag = function (tag, eventKey, eventHandlerStatements, para
     var propDefinitions = params.propDefinitions, stateDefinitions = params.stateDefinitions;
     eventHandlerStatements.forEach(function (eventHandlerAction) {
         if (eventHandlerAction.type === 'stateChange') {
-            var handler = createStateChangeStatement(eventHandlerAction, stateDefinitions, options);
+            var handler = (0, exports.createStateChangeStatement)(eventHandlerAction, stateDefinitions, options);
             if (handler) {
                 eventHandlerASTStatements.push(handler);
             }
@@ -91,7 +91,27 @@ var createPropCallStatement = function (eventHandlerStatement, propDefinitions,
         : '';
     return t.expressionStatement(t.callExpression(t.identifier(prefix + propFunctionKey), __spreadArray([], args.map(function (arg) { return (0, ast_utils_1.convertValueToLiteral)(arg); }), true)));
 };
+/**
+ * Plan v14 — Type-aware state setter emitter.
+ *
+ * The old emitter unconditionally produced `setX(!x)` for `$toggle` and
+ * `setX(<literal>)` for primitives, regardless of the declared state
+ * type. That broke every multi-step form: `$toggle` on a numeric step
+ * state turned `1` into `false`, hiding every `state === N` panel; a
+ * primitive written to an object state replaced the whole object.
+ *
+ * The codegen here is now the safety net for what server-side Layers 1-3
+ * could not catch (legacy projects, AI bypass). When a combination is
+ * incoherent (e.g. `$toggle` on a number, or a bare string targeting an
+ * object), we skip the statement and warn — the workflow runtime handler
+ * remains the source of truth. Coherent combinations emit the same code
+ * as before, plus four new modifier shapes (`$increment` / `$decrement` /
+ * `$patch` / `$append`) that produce React functional setters.
+ *
+ * Returns `null` when the emitter declines (caller already handles null).
+ */
 var createStateChangeStatement = function (eventHandlerStatement, stateDefinitions, options, t) {
+    var _a;
     if (t === void 0) { t = types; }
     if (!eventHandlerStatement.modifies) {
         console.warn("No state identifier referenced under the \"modifies\" field");
@@ -99,98 +119,451 @@ var createStateChangeStatement = function (eventHandlerStatement, stateDefinitio
     }
     var stateKey = eventHandlerStatement.modifies;
     var stateDefinition = stateDefinitions[stateKey];
+    if (!stateDefinition) {
+        console.warn("State change references an undeclared state \"".concat(stateKey, "\" \u2014 skipping setter emission."));
+        return null;
+    }
     var statePrefix = options.dynamicReferencePrefixMap.state
         ? options.dynamicReferencePrefixMap.state + '.'
         : '';
+    var declaredType = stateDefinition.type;
+    var newState = eventHandlerStatement.newState;
     var newStateValue;
-    if (eventHandlerStatement.newState === '$toggle') {
+    var useFunctionalSetter = false;
+    var functionalSetterBuilder;
+    if (newState === '$toggle') {
+        // Boolean-only. Reject for number / object / array — emitting `!x`
+        // on those types is the v13/v14 regression we are fixing.
+        if (declaredType !== 'boolean') {
+            console.warn("[createStateChangeStatement] '$toggle' is only valid for boolean state; state \"".concat(stateKey, "\" is declared as ").concat(declaredType, ". Skipping setter to avoid corrupting state."));
+            return null;
+        }
         newStateValue = t.unaryExpression('!', t.identifier(statePrefix + stateKey));
     }
-    else if (typeof eventHandlerStatement.newState === 'object') {
-        if (eventHandlerStatement.newState.type === 'expr') {
-            newStateValue = (0, ast_utils_1.getExpressionFromUIDLExpressionNode)(eventHandlerStatement.newState);
+    else if (typeof newState === 'object' && newState !== null) {
+        var obj = newState;
+        var objType = obj.type;
+        if (objType === 'expr') {
+            newStateValue = (0, ast_utils_1.getExpressionFromUIDLExpressionNode)(newState);
+        }
+        else if (objType === 'dynamic') {
+            newStateValue = (0, exports.createDynamicValueExpression)(newState, options);
+        }
+        else if (objType === '$increment' || objType === '$decrement') {
+            if (declaredType !== 'number') {
+                console.warn("[createStateChangeStatement] '".concat(objType, "' requires a numeric state; \"").concat(stateKey, "\" is declared as ").concat(declaredType, ". Skipping setter."));
+                return null;
+            }
+            // Honor the sign of `delta`: an $increment with delta -2 is a
+            // deliberate decrement by 2 (the type doc documents this). The
+            // builder emits `prev + delta` for $increment and `prev - delta`
+            // for $decrement, then the absolute value of |delta| is the
+            // numeric literal we feed in. Math.abs prevents the rare double-
+            // negative case where someone writes `{ type: '$decrement', delta: -1 }`
+            // (intended +1) from emitting `prev - -1` (which would be `+1`
+            // via JS coercion but is unreadable).
+            var rawDelta = (_a = obj.delta) !== null && _a !== void 0 ? _a : 1;
+            var operator_1 = objType === '$increment' ? (rawDelta < 0 ? '-' : '+') : rawDelta < 0 ? '+' : '-';
+            var magnitude_1 = Math.abs(rawDelta);
+            useFunctionalSetter = true;
+            functionalSetterBuilder = function (prevId) {
+                return t.binaryExpression(operator_1, prevId, t.numericLiteral(magnitude_1));
+            };
+        }
+        else if (objType === '$patch') {
+            if (declaredType !== 'object') {
+                console.warn("[createStateChangeStatement] '$patch' requires an object state; \"".concat(stateKey, "\" is declared as ").concat(declaredType, ". Skipping setter."));
+                return null;
+            }
+            var patch_1 = obj;
+            if (!patch_1.path || typeof patch_1.path !== 'string') {
+                console.warn("[createStateChangeStatement] '$patch' requires a string \"path\"; received \"".concat(String(patch_1.path), "\" for state \"").concat(stateKey, "\". Skipping setter."));
+                return null;
+            }
+            var patchValueAst_1 = (0, ast_utils_1.convertValueToLiteral)(patch_1.value, 'string');
+            useFunctionalSetter = true;
+            functionalSetterBuilder = function (prevId) {
+                return t.objectExpression([
+                    t.spreadElement(prevId),
+                    t.objectProperty(t.identifier(patch_1.path), patchValueAst_1, false, false),
+                ]);
+            };
         }
-        else if (eventHandlerStatement.newState.type === 'dynamic') {
-            newStateValue = (0, exports.createDynamicValueExpression)(eventHandlerStatement.newState, options);
+        else if (objType === '$append') {
+            if (declaredType !== 'array') {
+                console.warn("[createStateChangeStatement] '$append' requires an array state; \"".concat(stateKey, "\" is declared as ").concat(declaredType, ". Skipping setter."));
+                return null;
+            }
+            var appended = obj;
+            var appendedValueAst_1 = (0, ast_utils_1.convertValueToLiteral)(appended.value, 'string');
+            useFunctionalSetter = true;
+            functionalSetterBuilder = function (prevId) {
+                return t.arrayExpression([t.spreadElement(prevId), appendedValueAst_1]);
+            };
         }
         else {
-            newStateValue = (0, ast_utils_1.convertValueToLiteral)(eventHandlerStatement.newState, stateDefinition.type);
+            // Unknown object shape — fall back to literal conversion only when
+            // the declared type accepts a primitive write.
+            if (declaredType === 'object' || declaredType === 'array') {
+                console.warn("[createStateChangeStatement] Unrecognised modifier shape on a ".concat(declaredType, " state \"").concat(stateKey, "\"; skipping setter to avoid corrupting state."));
+                return null;
+            }
+            newStateValue = (0, ast_utils_1.convertValueToLiteral)(newState, declaredType);
         }
     }
     else {
-        newStateValue = (0, ast_utils_1.convertValueToLiteral)(eventHandlerStatement.newState, stateDefinition.type);
+        // Bare primitive (`'oily'`, `2`, `true`). Coerce against the declared type.
+        // For object/array state, writing a primitive REPLACES the structure.
+        // That is the bug — fail safe.
+        if (declaredType === 'object' || declaredType === 'array') {
+            console.warn("[createStateChangeStatement] Refusing to overwrite ".concat(declaredType, " state \"").concat(stateKey, "\" with a primitive value (").concat(JSON.stringify(newState), "). Use '$patch' / '$append' modifiers instead. Skipping setter."));
+            return null;
+        }
+        newStateValue = (0, ast_utils_1.convertValueToLiteral)(newState, declaredType);
     }
     switch (options.stateHandling) {
-        case 'hooks':
-            return t.expressionStatement(t.callExpression(t.identifier(teleport_shared_1.StringUtils.createStateStoringFunction(stateKey)), [
-                newStateValue,
-            ]));
-        case 'function':
+        case 'hooks': {
+            var setterId = t.identifier(teleport_shared_1.StringUtils.createStateStoringFunction(stateKey));
+            if (useFunctionalSetter && functionalSetterBuilder) {
+                var prevId = t.identifier('prev');
+                var arrow = t.arrowFunctionExpression([prevId], functionalSetterBuilder(prevId));
+                return t.expressionStatement(t.callExpression(setterId, [arrow]));
+            }
+            if (!newStateValue) {
+                return null;
+            }
+            return t.expressionStatement(t.callExpression(setterId, [newStateValue]));
+        }
+        case 'function': {
+            // Class-component setState path is legacy; functional setters aren't
+            // supported via `this.setState(prev => …)` here, so for the new
+            // modifiers we fall back to skipping. The hooks path is the path the
+            // multi-step form actually exercises.
+            if (useFunctionalSetter) {
+                console.warn("[createStateChangeStatement] Functional-setter modifiers are only supported under stateHandling=\"hooks\". Skipping setter for \"".concat(stateKey, "\"."));
+                return null;
+            }
+            if (!newStateValue) {
+                return null;
+            }
             return t.expressionStatement(t.callExpression(t.identifier('this.setState'), [
                 t.objectExpression([t.objectProperty(t.identifier(stateKey), newStateValue)]),
             ]));
+        }
         case 'mutation':
-        default:
+        default: {
+            if (useFunctionalSetter) {
+                console.warn("[createStateChangeStatement] Functional-setter modifiers are only supported under stateHandling=\"hooks\". Skipping setter for \"".concat(stateKey, "\"."));
+                return null;
+            }
+            if (!newStateValue) {
+                return null;
+            }
             return t.expressionStatement(t.assignmentExpression('=', t.identifier(statePrefix + stateKey), newStateValue));
+        }
+    }
+};
+exports.createStateChangeStatement = createStateChangeStatement;
+var resolveGlobalStateName = function (id, definitions) {
+    if (!definitions) {
+        return id;
+    }
+    for (var _i = 0, _a = Object.values(definitions); _i < _a.length; _i++) {
+        var def = _a[_i];
+        if (def.id === id) {
+            return def.name;
+        }
     }
+    return id;
 };
+exports.resolveGlobalStateName = resolveGlobalStateName;
+// Matches the leading JS identifier of an expression, e.g. `foo` from
+// `foo?.['bar'] || []`. Used to recognise when a string-encoded UIDL source
+// (cms-list-repeater `source`) is rooted at a global-state name so the
+// generator can register the reference for `useGlobalState()` destructuring.
+var LEADING_IDENTIFIER_RE = /^([A-Za-z_$][A-Za-z0-9_$]*)/;
+// Older versions of the UIDL emitter encoded a global-state reference as the
+// magic literal `globalState_<defId>` instead of the declared variable name.
+// Detect that prefix so we can rewrite it to the proper identifier and fix
+// already-published UIDL documents without forcing them to be regenerated.
+var LEGACY_GLOBAL_STATE_RE = /^globalState_([A-Za-z0-9_-]+)/;
+/**
+ * Given a string-encoded UIDL `source` expression, resolve any global-state
+ * reference into the proper JS identifier for the generator and ensure the
+ * reference is registered for `useGlobalState()` destructuring.
+ *
+ * Two upstream encodings are accepted:
+ *   1. Modern shape — leading identifier is the declared state name
+ *      (e.g. `countriesWithDescriptions || []`). We just register it.
+ *   2. Legacy shape — leading identifier is the magic placeholder
+ *      `globalState_<defId>` (e.g. `globalState_TQ_96vaRH5pdf['key']`). We
+ *      rewrite the placeholder to the declared name AND register it.
+ *
+ * Returns the (possibly rewritten) source string. The caller should embed
+ * the returned string instead of the input.
+ */
+var resolveAndRegisterGlobalStateSource = function (source, params) {
+    var original = source !== null && source !== void 0 ? source : '';
+    if (!original) {
+        return original;
+    }
+    var definitions = params.globalStateDefinitions;
+    if (!definitions || Object.keys(definitions).length === 0) {
+        return original;
+    }
+    var legacyMatch = original.match(LEGACY_GLOBAL_STATE_RE);
+    if (legacyMatch) {
+        var id = legacyMatch[1];
+        for (var _i = 0, _a = Object.values(definitions); _i < _a.length; _i++) {
+            var def = _a[_i];
+            if (def.id === id) {
+                params.globalStateReferences.push({ id: def.id, name: def.name });
+                return original.replace(LEGACY_GLOBAL_STATE_RE, def.name);
+            }
+        }
+        // Legacy prefix found but no matching definition (orphaned reference).
+        // Leave the source untouched; the downstream identifier creation will
+        // still emit something, and a separate sanity pass can flag it.
+        return original;
+    }
+    var leadingMatch = original.match(LEADING_IDENTIFIER_RE);
+    if (leadingMatch) {
+        var leadingName = leadingMatch[1];
+        for (var _b = 0, _c = Object.values(definitions); _b < _c.length; _b++) {
+            var def = _c[_b];
+            if (def.name === leadingName) {
+                params.globalStateReferences.push({ id: def.id, name: def.name });
+                return original;
+            }
+        }
+    }
+    return original;
+};
+exports.resolveAndRegisterGlobalStateSource = resolveAndRegisterGlobalStateSource;
+var createGlobalStateExpression = function (ref, definitions, t) {
+    if (t === void 0) { t = types; }
+    var name = (0, exports.resolveGlobalStateName)(ref.content.id, definitions);
+    var refPath = ref.content.refPath || [];
+    if (refPath.length === 0) {
+        return t.identifier(name);
+    }
+    var expr = t.identifier(name);
+    for (var _i = 0, refPath_1 = refPath; _i < refPath_1.length; _i++) {
+        var segment = refPath_1[_i];
+        expr = t.optionalMemberExpression(expr, t.identifier(segment), false, true);
+    }
+    return expr;
+};
+exports.createGlobalStateExpression = createGlobalStateExpression;
 var createDynamicValueExpression = function (identifier, options, t) {
+    var _a;
+    if (t === void 0) { t = types; }
+    var inner = createDynamicValueExpressionRaw(identifier, options, t);
+    // When the UIDL content carries a `valueMapper`, wrap the resolved
+    // expression in a sandboxed IIFE that runs the user's `mapValue(value)`
+    // and falls back to the raw value on error. This mirrors the state
+    // definition `wrapWithMappingFunction` pattern and lets any framework
+    // that re-uses `createDynamicValueExpression` inherit the behaviour.
+    var valueMapper = ((_a = identifier.content.valueMapper) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+    if (!valueMapper) {
+        return inner;
+    }
+    return wrapExpressionWithValueMapperAst(inner, valueMapper, t);
+};
+exports.createDynamicValueExpression = createDynamicValueExpression;
+var wrapExpressionWithValueMapperAst = function (innerExpression, valueMapper, t) {
+    if (t === void 0) { t = types; }
+    // Build: ((v) => { try { return (new Function('value', '"use strict"; <mapper>; return mapValue(value);')).call(null, v) } catch (_e) { return v } })(<inner>)
+    //
+    // We deliberately use `new Function(...)` at runtime rather than parsing
+    // the mapper body into AST statements here. That keeps this plugin free
+    // of a parser dependency, matches the sandboxing used by state-definition
+    // `wrapWithMappingFunction`, and ensures the generated code is framework
+    // agnostic — only stringify semantics + `toString()` on primitives are
+    // required for the output to render correctly.
+    var tryBlock = t.tryStatement(t.blockStatement([
+        t.returnStatement(t.callExpression(t.memberExpression(t.newExpression(t.identifier('Function'), [
+            t.stringLiteral('value'),
+            t.stringLiteral("\"use strict\"; ".concat(valueMapper, "; return mapValue(value);")),
+        ]), t.identifier('call')), [t.nullLiteral(), t.identifier('v')])),
+    ]), t.catchClause(t.identifier('_e'), t.blockStatement([t.returnStatement(t.identifier('v'))])));
+    var arrow = t.arrowFunctionExpression([t.identifier('v')], t.blockStatement([tryBlock]));
+    return t.callExpression(arrow, [innerExpression]);
+};
+var createDynamicValueExpressionRaw = function (identifier, options, t) {
+    var _a;
     if (t === void 0) { t = types; }
     var identifierContent = identifier.content;
     var refPath = identifier.content.refPath || [];
     var referenceType = identifierContent.referenceType, id = identifierContent.id;
-    var idWithPath = (0, uidl_utils_1.generateIdWithRefPath)(id, refPath);
     if (referenceType === 'attr' || referenceType === 'children' || referenceType === 'token') {
         throw new Error("Dynamic reference type \"".concat(referenceType, "\" is not supported yet"));
     }
+    // 'ctx' references resolve to the data source context render prop identifier
+    // using only the refPath to build property access
+    if (referenceType === 'ctx') {
+        var ctxPrefix = options.dynamicReferencePrefixMap.ctx || '';
+        if (ctxPrefix && refPath.length > 0) {
+            var expr = t.identifier(ctxPrefix);
+            for (var _i = 0, refPath_2 = refPath; _i < refPath_2.length; _i++) {
+                var path = refPath_2[_i];
+                expr = t.optionalMemberExpression(expr, t.identifier(path), false, true);
+            }
+            return expr;
+        }
+        // Fallback: use the id with refPath if no local prefix
+        var ctxFallbackIdWithPath = (0, uidl_utils_1.generateIdWithRefPath)(id, refPath);
+        return t.identifier(ctxFallbackIdWithPath);
+    }
+    // `urlSearchParams` references read a declared key from the URL query string.
+    // Next.js generators typically set `dynamicReferencePrefixMap.urlSearchParams`
+    // to `'router.query'` so we emit `router.query.<key>`. Static / HTML
+    // generators set it to `'__urlSearchParams'` and inject a `const
+    // __urlSearchParams = new URLSearchParams(location.search)` prelude.
+    //
+    // `options.urlSearchParamsRegistry` (set by the plugin based on the page
+    // UIDL's `searchParams` definition) supplies per-key defaults so we emit
+    // `(router.query.category ?? 'food')` with the declared fallback.
+    if (referenceType === 'urlSearchParams') {
+        var paramKey = refPath[0] || id;
+        var urlParamsPrefix = options.dynamicReferencePrefixMap.urlSearchParams ||
+            'router.query';
+        var _b = urlParamsPrefix.split('.'), rootPrefix = _b[0], restPath = _b.slice(1);
+        var expr = t.identifier(rootPrefix);
+        for (var _c = 0, restPath_1 = restPath; _c < restPath_1.length; _c++) {
+            var segment = restPath_1[_c];
+            expr = t.memberExpression(expr, t.identifier(segment));
+        }
+        expr = t.optionalMemberExpression(expr, t.identifier(paramKey), false, true);
+        var registry = options.urlSearchParamsRegistry;
+        var declaredDefault = (_a = registry === null || registry === void 0 ? void 0 : registry[paramKey]) === null || _a === void 0 ? void 0 : _a.defaultValue;
+        if (declaredDefault !== undefined && declaredDefault !== '') {
+            expr = t.logicalExpression('??', expr, t.stringLiteral(declaredDefault));
+        }
+        return expr;
+    }
+    // 'local' references resolve to the iteration variable of the enclosing repeater.
+    // The reference id in UIDL is a node id (e.g. "TQ_xxxxxx") and carries no meaning
+    // at runtime — the only load-bearing pieces are the refPath and the current
+    // localIdentifier (set when walking into a repeater/data-provider's children).
+    if (referenceType === 'local') {
+        var localPrefix = options.localIdentifier ||
+            options.dynamicReferencePrefixMap.local ||
+            '';
+        if (localPrefix) {
+            if (refPath.length === 0) {
+                return t.identifier(localPrefix);
+            }
+            var expr = t.identifier(localPrefix);
+            for (var _d = 0, refPath_3 = refPath; _d < refPath_3.length; _d++) {
+                var path = refPath_3[_d];
+                expr = t.optionalMemberExpression(expr, t.identifier(path), false, true);
+            }
+            return expr;
+        }
+        // Details-page fallback: a page-root `local` reference (no enclosing
+        // repeater) means "a column on the fetched row" exposed as a prop under
+        // `initialPropsData.exposeAs.name`. Resolve to `props.<name>.<refPath>`.
+        if (options.detailsPageExposeAsName && refPath.length > 0) {
+            var propPrefix = options.dynamicReferencePrefixMap.prop || 'props';
+            var expr = t.memberExpression(t.identifier(propPrefix), t.identifier(options.detailsPageExposeAsName));
+            for (var _e = 0, refPath_4 = refPath; _e < refPath_4.length; _e++) {
+                var path = refPath_4[_e];
+                expr = t.optionalMemberExpression(expr, t.identifier(path), false, true);
+            }
+            return expr;
+        }
+    }
+    var idWithPath = (0, uidl_utils_1.generateIdWithRefPath)(id, refPath);
     var prefix = options.dynamicReferencePrefixMap[referenceType] || '';
     return prefix === ''
         ? t.identifier(idWithPath)
         : t.memberExpression(t.identifier(prefix), t.identifier(idWithPath));
 };
-exports.createDynamicValueExpression = createDynamicValueExpression;
 // Prepares an identifier (from props or state or an expr) to be used as a conditional rendering identifier
 // Assumes the type from the corresponding props/state definitions if not expr. Expressions are expected to have a boolean return here
 var createConditionIdentifier = function (dynamicReference, params, options) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     if (dynamicReference.type === 'expr') {
         return {
             key: dynamicReference.content,
             type: 'boolean',
         };
     }
-    var _c = dynamicReference.content, id = _c.id, referenceType = _c.referenceType, refPath = _c.refPath;
+    var _e = dynamicReference.content, id = _e.id, referenceType = _e.referenceType, refPath = _e.refPath;
     // Handle local references (from repeaters/loops) - they don't have an id
     if (referenceType === 'local') {
         // For local references, the identifier comes from the refPath
-        var key = refPath && refPath.length > 0 ? refPath.join('.') : '';
+        var refPathKey = refPath && refPath.length > 0 ? refPath.join('.') : '';
         var prefix = options.localIdentifier || '';
+        // Details-page fallback: at the page root there is no enclosing repeater,
+        // so a `local` reference means "a column on the fetched row" exposed as a
+        // prop under `initialPropsData.exposeAs.name`.
+        if (!prefix && options.detailsPageExposeAsName && refPathKey) {
+            var propPrefix = ((_a = options.dynamicReferencePrefixMap) === null || _a === void 0 ? void 0 : _a.prop) || 'props';
+            return {
+                key: "".concat(options.detailsPageExposeAsName, ".").concat(refPathKey),
+                type: 'string',
+                prefix: propPrefix,
+            };
+        }
         return {
-            key: key,
+            key: refPathKey,
             type: 'string',
             prefix: prefix,
         };
     }
-    // Handle global references early - they don't use prop/state definitions
     if (referenceType === 'global') {
         return {
             key: teleport_shared_1.UIDLUtils.generateIdWithRefPath(id, refPath),
             type: 'string',
             prefix: '',
+            referenceType: 'global',
+        };
+    }
+    if (referenceType === 'globalState') {
+        var resolvedName = (0, exports.resolveGlobalStateName)(id, params.globalStateDefinitions);
+        var refPathSegments = refPath || [];
+        var key = refPathSegments.length > 0
+            ? refPathSegments.reduce(function (acc, seg) { return "".concat(acc, "?.").concat(seg); }, resolvedName)
+            : resolvedName;
+        return {
+            key: key,
+            type: 'string',
+            prefix: '',
+            referenceType: 'globalState',
         };
     }
     // in case the id is a member expression: eg: fields.name
     var referenceRoot = id.split('.')[0];
     var currentType = referenceType === 'prop'
-        ? (_a = params.propDefinitions[referenceRoot]) === null || _a === void 0 ? void 0 : _a.type
-        : (_b = params.stateDefinitions[referenceRoot]) === null || _b === void 0 ? void 0 : _b.type;
+        ? (_b = params.propDefinitions[referenceRoot]) === null || _b === void 0 ? void 0 : _b.type
+        : (_c = params.stateDefinitions[referenceRoot]) === null || _c === void 0 ? void 0 : _c.type;
     var type = currentType;
     if (refPath === null || refPath === void 0 ? void 0 : refPath.length) {
-        var currentValue = params.propDefinitions[referenceRoot].defaultValue;
-        for (var _i = 0, refPath_1 = refPath; _i < refPath_1.length; _i++) {
-            var path = refPath_1[_i];
-            currentValue = currentValue === null || currentValue === void 0 ? void 0 : currentValue[path];
-            type = currentValue ? typeof currentValue : currentType;
+        if (referenceType === 'prop' && ((_d = params.propDefinitions[referenceRoot]) === null || _d === void 0 ? void 0 : _d.defaultValue)) {
+            var currentValue = params.propDefinitions[referenceRoot].defaultValue;
+            for (var _i = 0, refPath_5 = refPath; _i < refPath_5.length; _i++) {
+                var path = refPath_5[_i];
+                currentValue = currentValue === null || currentValue === void 0 ? void 0 : currentValue[path];
+                type = currentValue ? typeof currentValue : currentType;
+            }
+        }
+        else if (referenceType === 'state' && currentType === 'object') {
+            var stateDef = params.stateDefinitions[referenceRoot];
+            if (stateDef &&
+                typeof stateDef.defaultValue === 'object' &&
+                stateDef.defaultValue !== null &&
+                !Array.isArray(stateDef.defaultValue)) {
+                var objectDefault = stateDef.defaultValue;
+                var entry = objectDefault[refPath[0]];
+                if ((entry === null || entry === void 0 ? void 0 : entry.type) === 'static' && entry.content !== undefined) {
+                    type = typeof entry.content;
+                }
+                else {
+                    type = 'string';
+                }
+            }
         }
     }
     switch (referenceType) {
@@ -216,7 +589,8 @@ var createConditionIdentifier = function (dynamicReference, params, options) {
     }
 };
 exports.createConditionIdentifier = createConditionIdentifier;
-var createConditionalJSXExpression = function (content, conditionalExpression, conditionalIdentifier, t) {
+var createConditionalJSXExpression = function (content, conditionalExpression, conditionalIdentifier, options, t) {
+    if (options === void 0) { options = {}; }
     if (t === void 0) { t = types; }
     var contentNode;
     if (typeof content === 'string') {
@@ -232,7 +606,7 @@ var createConditionalJSXExpression = function (content, conditionalExpression, c
     // When the stateValue is an object we will compute a logical/binary expression on the left side
     var conditions = conditionalExpression.conditions, matchingCriteria = conditionalExpression.matchingCriteria;
     var binaryExpressions = conditions.map(function (condition) {
-        return (0, exports.createBinaryExpression)(condition, conditionalIdentifier);
+        return (0, exports.createBinaryExpression)(condition, conditionalIdentifier, options);
     });
     if (binaryExpressions.length === 1) {
         binaryExpression = binaryExpressions[0];
@@ -251,12 +625,89 @@ var createConditionalJSXExpression = function (content, conditionalExpression, c
     return t.logicalExpression('&&', binaryExpression, contentNode);
 };
 exports.createConditionalJSXExpression = createConditionalJSXExpression;
-var createBinaryExpression = function (condition, conditionalIdentifier, t) {
+/**
+ * Resolves an operand value to an AST expression, handling dynamic refs, expressions, and static values.
+ */
+var resolveOperandExpression = function (operand, conditionalIdentifier, options) {
+    if (typeof operand === 'object' && 'type' in operand && operand.type === 'expr') {
+        return (0, ast_utils_1.getExpressionFromUIDLExpressionNode)(operand);
+    }
+    if (typeof operand === 'object' && 'type' in operand && operand.type === 'dynamic') {
+        return (0, exports.createDynamicValueExpression)(operand, {
+            dynamicReferencePrefixMap: {
+                prop: 'props',
+                state: '',
+                local: '',
+            },
+            localIdentifier: options.localIdentifier,
+            detailsPageExposeAsName: options.detailsPageExposeAsName,
+        });
+    }
+    return (0, ast_utils_1.convertValueToLiteral)(operand, conditionalIdentifier.type);
+};
+var createBinaryExpression = function (condition, conditionalIdentifier, options, t) {
+    if (options === void 0) { options = {}; }
     if (t === void 0) { t = types; }
-    var operand = condition.operand, operation = condition.operation;
+    var operand = condition.operand, operation = condition.operation, containsField = condition.containsField;
     var identifier = conditionalIdentifier.prefix
         ? t.memberExpression(t.identifier(conditionalIdentifier.prefix), t.identifier(conditionalIdentifier.key))
         : t.identifier(conditionalIdentifier.key);
+    // Array/Object operators
+    if (operation === 'isEmpty') {
+        // For objects, use Object.keys(x).length; for arrays (or unknown), use x.length
+        var lengthExpr = conditionalIdentifier.type === 'object'
+            ? t.memberExpression(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('keys')), [
+                identifier,
+            ]), t.identifier('length'))
+            : t.memberExpression(identifier, t.identifier('length'));
+        return t.binaryExpression('===', lengthExpr, t.numericLiteral(0));
+    }
+    if (operation === 'isNotEmpty') {
+        var lengthExpr = conditionalIdentifier.type === 'object'
+            ? t.memberExpression(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('keys')), [
+                identifier,
+            ]), t.identifier('length'))
+            : t.memberExpression(identifier, t.identifier('length'));
+        return t.binaryExpression('>', lengthExpr, t.numericLiteral(0));
+    }
+    if (operation === 'lengthEquals' && operand !== undefined) {
+        return t.binaryExpression('===', t.memberExpression(identifier, t.identifier('length')), resolveOperandExpression(operand, conditionalIdentifier, options));
+    }
+    if (operation === 'lengthGreaterThan' && operand !== undefined) {
+        return t.binaryExpression('>', t.memberExpression(identifier, t.identifier('length')), resolveOperandExpression(operand, conditionalIdentifier, options));
+    }
+    if (operation === 'lengthLessThan' && operand !== undefined) {
+        return t.binaryExpression('<', t.memberExpression(identifier, t.identifier('length')), resolveOperandExpression(operand, conditionalIdentifier, options));
+    }
+    if (operation === 'contains' && operand !== undefined) {
+        var operandExpr = resolveOperandExpression(operand, conditionalIdentifier, options);
+        if (containsField) {
+            var itemParam = t.identifier('__item');
+            return t.callExpression(t.memberExpression(identifier, t.identifier('some')), [
+                t.arrowFunctionExpression([itemParam], t.binaryExpression('===', t.memberExpression(itemParam, t.identifier(containsField)), operandExpr)),
+            ]);
+        }
+        return t.callExpression(t.memberExpression(identifier, t.identifier('includes')), [operandExpr]);
+    }
+    if (operation === 'notContains' && operand !== undefined) {
+        var operandExpr = resolveOperandExpression(operand, conditionalIdentifier, options);
+        if (containsField) {
+            var itemParam = t.identifier('__item');
+            return t.unaryExpression('!', t.callExpression(t.memberExpression(identifier, t.identifier('some')), [
+                t.arrowFunctionExpression([itemParam], t.binaryExpression('===', t.memberExpression(itemParam, t.identifier(containsField)), operandExpr)),
+            ]));
+        }
+        return t.unaryExpression('!', t.callExpression(t.memberExpression(identifier, t.identifier('includes')), [operandExpr]));
+    }
+    if (operation === 'hasKey' && operand !== undefined) {
+        var operandExpr = resolveOperandExpression(operand, conditionalIdentifier, options);
+        return t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier('Object'), t.identifier('prototype')), t.identifier('hasOwnProperty')), t.identifier('call')), [identifier, operandExpr]);
+    }
+    if (operation === 'notHasKey' && operand !== undefined) {
+        var operandExpr = resolveOperandExpression(operand, conditionalIdentifier, options);
+        return t.unaryExpression('!', t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier('Object'), t.identifier('prototype')), t.identifier('hasOwnProperty')), t.identifier('call')), [identifier, operandExpr]));
+    }
+    // Standard binary operators
     if (operation === '===') {
         if (operand === true) {
             return identifier;
@@ -277,11 +728,17 @@ var createBinaryExpression = function (condition, conditionalIdentifier, t) {
                     state: '',
                     local: '',
                 },
+                localIdentifier: options.localIdentifier,
             });
             return t.binaryExpression((0, ast_utils_1.convertToBinaryOperator)(operation), identifier, dynamicValueIdentifier);
         }
         var stateValueIdentifier = (0, ast_utils_1.convertValueToLiteral)(operand, conditionalIdentifier.type);
-        return t.binaryExpression((0, ast_utils_1.convertToBinaryOperator)(operation), identifier, stateValueIdentifier);
+        var lhs = (conditionalIdentifier.referenceType === 'global' ||
+            conditionalIdentifier.referenceType === 'globalState') &&
+            typeof operand === 'string'
+            ? t.optionalCallExpression(t.optionalMemberExpression(identifier, t.identifier('toString'), false, true), [], false)
+            : identifier;
+        return t.binaryExpression((0, ast_utils_1.convertToBinaryOperator)(operation), lhs, stateValueIdentifier);
     }
     else {
         return operation ? t.unaryExpression((0, ast_utils_1.convertToUnaryOperator)(operation), identifier) : identifier;