@wavemaker-ai/react-codegen 1.0.0-rc.309

package/src/variables/variable.transformer.js

@@ -0,0 +1,690 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bind_ex_transformer_1 = __importDefault(require("../transpile/bind.ex.transformer"));
+const lodash_1 = require("lodash");
+function isStaticParamsVariable(variable) {
+    const db = variable.dataBinding;
+    // No dataBinding at all → nothing dynamic
+    if (!db)
+        return true;
+    const entryIsStatic = (entry) => {
+        const v = Array.isArray(entry.value) ? entry.value[0] : entry.value;
+        return !v || !(typeof v === "string" && v.startsWith("bind:"));
+    };
+    if (Array.isArray(db)) {
+        return db.every(entryIsStatic);
+    }
+    if ((0, lodash_1.isObject)(db) && !Array.isArray(db)) {
+        return Object.values(db).every((opBindings) => {
+            if (!Array.isArray(opBindings))
+                return true;
+            return opBindings.every(entryIsStatic);
+        });
+    }
+    return true;
+}
+function parseStaticJsonValue(value) {
+    const trimmedValue = value.trim();
+    if (!trimmedValue.startsWith("{") && !trimmedValue.startsWith("[")) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmedValue);
+    }
+    catch (_a) {
+        return value;
+    }
+}
+function transformDataItem(d, scope) {
+    let v = (0, lodash_1.isArray)(d.value) ? d.value[0] : d.value;
+    let arrayIndex = null;
+    if (v) {
+        if (v.startsWith && v.startsWith("bind:")) {
+            // "value" : "bind:'Do you want to delete this product: \"'+Widgets.Cart_Details.selecteditem.productDetails.productName+'\" from your Cart'",
+            const originalValue = v.substr(5);
+            v = originalValue;
+            // Check if the value contains array indexing like [$i] or [0]
+            const arrayIndexMatch = v.match(/\[(\$i|\d+)\]/);
+            if (arrayIndexMatch) {
+                // Extract the index (convert $i to 0 for now, or use the number)
+                arrayIndex = arrayIndexMatch[1] === "$i" ? 0 : parseInt(arrayIndexMatch[1], 10);
+            }
+            // Remove trailing semicolons and trim whitespace from binding expressions
+            v = (v || "").trim().replace(/;+\s*$/, "");
+            if (v === "null") {
+                v = null;
+            }
+            else {
+                const transformed = (0, bind_ex_transformer_1.default)(v, scope, "attr").replace(/\\n/g, "");
+                // If the expression starts with '{', it's an object literal and needs to be wrapped in ()
+                // to distinguish it from a block statement in arrow functions
+                if (transformed.trim().startsWith("{")) {
+                    v = `${scope}.eval(() => (${transformed}))`;
+                }
+                else {
+                    v = `${scope}.eval(() => ${transformed})`;
+                }
+            }
+        }
+        else if (typeof v === "string") {
+            v = parseStaticJsonValue(v);
+        }
+        else if (d.type === "string") {
+            v = `${v}`;
+        }
+    }
+    return {
+        name: d.target,
+        value: v,
+        arrayIndex: arrayIndex,
+    };
+}
+function appendIfNotEmpty(input, str) {
+    return input && input + "";
+}
+function checkEmptyObject(obj) {
+    let isVariableEmpty = true;
+    (0, lodash_1.forEach)(obj, (value) => {
+        if ((0, lodash_1.isEmpty)(value) && !(0, lodash_1.isBoolean)(value) && !(0, lodash_1.isNumber)(value)) {
+            return;
+        }
+        if (!(0, lodash_1.isObject)(value)) {
+            isVariableEmpty = false;
+        }
+        else if ((0, lodash_1.isArray)(value)) {
+            isVariableEmpty = (0, lodash_1.isEmpty)(value) || (value.length === 1 ? (0, lodash_1.isEmpty)(value[0]) : false);
+        }
+        else {
+            isVariableEmpty = checkEmptyObject(value);
+        }
+        return isVariableEmpty;
+    });
+    return isVariableEmpty;
+}
+function transformVariable(variable, scope) {
+    var _a;
+    let params = {}, filters = {};
+    if (variable.category !== "wm.DeviceVariable") {
+        if ((0, lodash_1.isArray)(variable.dataSet)) {
+            if (variable.category === "wm.NavigationAction") {
+                variable.dataSet.forEach((d) => {
+                    const { name, value } = transformDataItem(d, scope);
+                    (0, lodash_1.set)(params, name, value);
+                });
+            }
+            else if (variable.category === "wm.Variable") {
+                params = (0, lodash_1.clone)(variable.dataSet);
+            }
+        }
+        else if ((0, lodash_1.isBoolean)(variable.dataSet) || (0, lodash_1.isNumber)(variable.dataSet)) {
+            if (variable.category === "wm.Variable") {
+                params = variable.dataSet;
+            }
+        }
+        else if (variable.dataSet) {
+            Object.keys(variable.dataSet).forEach(k => {
+                if (params[k] == undefined || params[k] == null) {
+                    (0, lodash_1.set)(params, k, (0, lodash_1.get)(variable.dataSet, k));
+                }
+            });
+        }
+    }
+    if (variable.dataBinding) {
+        if (Array.isArray(variable.dataBinding)) {
+            // First pass: collect all bindings and identify conflicts
+            const bindings = [];
+            const parentKeys = new Set(); // Keys that have direct bindings
+            const nestedKeys = new Map(); // Parent -> array of nested bindings
+            (_a = variable.dataBinding) === null || _a === void 0 ? void 0 : _a.forEach((d) => {
+                // Capture the original bind value BEFORE transformation
+                const originalValue = d.value && d.value.startsWith && d.value.startsWith("bind:")
+                    ? d.value.substr(5)
+                    : d.value;
+                const { name, value, arrayIndex } = transformDataItem(d, scope);
+                let finalValue = value;
+                if (variable.dataSet &&
+                    !(0, lodash_1.isArray)(variable.dataSet) &&
+                    variable.dataSet.hasOwnProperty(name)) {
+                    const defaultValue = (0, lodash_1.get)(variable.dataSet, name);
+                    // Only add fallback if:
+                    // 1. The binding is an expression (not a static value)
+                    // 2. There's a default value (including empty strings and arrays)
+                    if (d.value && d.value.startsWith && d.value.startsWith("bind:")) {
+                        // Format default value appropriately
+                        let formattedDefault;
+                        if (typeof defaultValue === "string") {
+                            formattedDefault = `"${defaultValue}"`;
+                        }
+                        else if ((0, lodash_1.isArray)(defaultValue)) {
+                            formattedDefault = JSON.stringify(defaultValue);
+                        }
+                        else if ((0, lodash_1.isObject)(defaultValue)) {
+                            formattedDefault = JSON.stringify(defaultValue);
+                        }
+                        else if (defaultValue === null) {
+                            formattedDefault = "null";
+                        }
+                        else if (defaultValue === undefined) {
+                            formattedDefault = "undefined";
+                        }
+                        else {
+                            formattedDefault = String(defaultValue);
+                        }
+                        // Append fallback: value || defaultValue
+                        finalValue = `${value} || ${formattedDefault}`;
+                    }
+                }
+                bindings.push({ name, value: finalValue, arrayIndex, originalValue });
+                const parts = name.split(".");
+                if (parts.length === 1) {
+                    // Direct binding for a key
+                    parentKeys.add(name);
+                }
+                else {
+                    // Nested binding
+                    const parentKey = parts[0];
+                    if (!nestedKeys.has(parentKey)) {
+                        nestedKeys.set(parentKey, []);
+                    }
+                    nestedKeys.get(parentKey).push({ name, value: finalValue, arrayIndex, originalValue });
+                }
+            });
+            // Helper to check if nested bindings involve arrays
+            const hasArrayBindings = (key) => {
+                const nested = nestedKeys.get(key);
+                if (!nested)
+                    return false;
+                // Check if any nested binding has an array index
+                return nested.some(n => n.arrayIndex !== null);
+            };
+            // Helper to check if nested bindings are complex (deep nesting > 2 levels)
+            const hasComplexNesting = (key) => {
+                const nested = nestedKeys.get(key);
+                if (!nested)
+                    return false;
+                // Check if any nested path has more than 2 levels (e.g., RequestBody.serviceQualificationItem.resource)
+                return nested.some(n => n.name.split(".").length > 2);
+            };
+            // Helper to group array bindings by their array path
+            const groupArrayBindings = (key) => {
+                const nested = nestedKeys.get(key) || [];
+                const arrayGroups = new Map();
+                // First, identify which paths have array bindings (have [$i] in their values)
+                const arrayPaths = new Set();
+                nested.forEach(n => {
+                    if (n.arrayIndex !== null) {
+                        const parts = n.name.split(".");
+                        if (parts.length >= 3) {
+                            const arrayPath = `${parts[0]}.${parts[1]}`;
+                            arrayPaths.add(arrayPath);
+                        }
+                    }
+                });
+                // Now group ALL bindings that go through these array paths
+                nested.forEach(n => {
+                    const parts = n.name.split(".");
+                    if (parts.length >= 3) {
+                        // Check if this path goes through any identified array path
+                        const potentialArrayPath = `${parts[0]}.${parts[1]}`;
+                        // Include if: either has arrayIndex OR goes through an array path
+                        if (n.arrayIndex !== null || arrayPaths.has(potentialArrayPath)) {
+                            if (!arrayGroups.has(potentialArrayPath)) {
+                                arrayGroups.set(potentialArrayPath, []);
+                            }
+                            // Remaining path after the array (e.g., resource.id from RequestBody.serviceQualificationItem.resource.id)
+                            const remainingPath = parts.slice(2).join(".");
+                            arrayGroups
+                                .get(potentialArrayPath)
+                                .push({ path: remainingPath, value: n.value, originalValue: n.originalValue });
+                        }
+                    }
+                });
+                return arrayGroups;
+            };
+            // Helper to generate map expression for array bindings
+            const generateMapExpression = (arrayPath, items, parentValue) => {
+                // Build the nested object structure for map
+                const structure = {};
+                items.forEach(item => {
+                    (0, lodash_1.set)(structure, item.path, {
+                        __isOverride: true,
+                        value: item.value,
+                        originalValue: item.originalValue,
+                    });
+                });
+                // Generate map expression
+                const arrayPathParts = arrayPath.split(".");
+                const arraySourcePath = arrayPathParts.join(".");
+                return `__MAP__${arraySourcePath}__STRUCTURE__${JSON.stringify(structure)}__PARENT__${parentValue}__ENDMAP__`;
+            };
+            // Second pass: process bindings based on conflicts
+            bindings.forEach(({ name, value, arrayIndex, originalValue }) => {
+                const parts = name.split(".");
+                if (parts.length === 1) {
+                    // This is a direct binding
+                    const hasNestedBindings = nestedKeys.has(name);
+                    if (hasNestedBindings && !hasComplexNesting(name) && !hasArrayBindings(name)) {
+                        // Simple case: There are nested bindings but they're not deep and no arrays
+                        // We can safely merge with spread operator
+                        // Example: RequestBody -> RequestBody.state
+                        const parentValue = value;
+                        const parentObj = { __base__: parentValue };
+                        nestedKeys.get(name).forEach(nested => {
+                            const nestedParts = nested.name.split(".");
+                            if (nestedParts.length === 2 && nestedParts[0] === name) {
+                                parentObj[nestedParts[1]] = nested.value;
+                            }
+                        });
+                        (0, lodash_1.set)(params, name, parentObj);
+                    }
+                    else if (hasNestedBindings && (hasComplexNesting(name) || hasArrayBindings(name))) {
+                        // Complex case with arrays - use map expression
+                        const parentObj = { __base__: value };
+                        // Group array bindings and create map expressions
+                        const arrayGroups = groupArrayBindings(name);
+                        arrayGroups.forEach((items, arrayPath) => {
+                            const mapExpr = generateMapExpression(arrayPath, items, value);
+                            // Extract the array property name (last part of the path)
+                            const arrayProp = arrayPath.split(".").pop();
+                            if (arrayProp) {
+                                // Store map marker directly in parent object, not using set()
+                                parentObj[arrayProp] = mapExpr;
+                            }
+                        });
+                        // Handle all non-array nested bindings (including deep paths like RequestBody.payload.templateInput.year)
+                        // Exclude bindings that go through array paths (already handled by arrayGroups above)
+                        const arrayRelativePaths = Array.from(arrayGroups.keys()).map(ap => ap.split(".").slice(1).join("."));
+                        nestedKeys.get(name).forEach(nested => {
+                            if (nested.arrayIndex === null) {
+                                const nestedParts = nested.name.split(".");
+                                if (nestedParts[0] === name && nestedParts.length > 1) {
+                                    const relativePath = nestedParts.slice(1).join(".");
+                                    // Skip if this path goes through an array (e.g. serviceQualificationItem.resource.id)
+                                    const goesThroughArray = arrayRelativePaths.some(rp => relativePath === rp || relativePath.startsWith(rp + "."));
+                                    if (!goesThroughArray) {
+                                        (0, lodash_1.set)(parentObj, relativePath, nested.value);
+                                    }
+                                }
+                            }
+                        });
+                        // For inline eval format: when no array bindings and base is JSON, store parsed base for stringify
+                        if (arrayGroups.size === 0 && originalValue && typeof originalValue === "string") {
+                            const trimmed = originalValue.trim();
+                            if ((trimmed.startsWith("{") || trimmed.startsWith("[")) && trimmed.length > 1) {
+                                try {
+                                    parentObj.__baseObject__ = JSON.parse(originalValue);
+                                    parentObj.__scope__ = scope;
+                                }
+                                catch (_a) {
+                                    // Ignore parse errors
+                                }
+                            }
+                        }
+                        // Set the parent object with all properties
+                        (0, lodash_1.set)(params, name, parentObj);
+                    }
+                    else {
+                        // No conflicts, just set the value
+                        (0, lodash_1.set)(params, name, value);
+                    }
+                }
+                else {
+                    // This is a nested binding - already handled in parent block for array cases
+                    const parentKey = parts[0];
+                    if (!parentKeys.has(parentKey)) {
+                        // No parent binding, set normally
+                        (0, lodash_1.set)(params, name, value);
+                    }
+                }
+            });
+            if (params.dataBinding) {
+                params = params.dataBinding;
+            }
+        }
+        else if (variable.category === "wm.CrudVariable" &&
+            (0, lodash_1.isObject)(variable.dataBinding) &&
+            !(0, lodash_1.isArray)(variable.dataBinding)) {
+            // Transform dataBinding object for CrudVariable
+            // Input: { list: [...], create: [...], update: [...], delete: [...] }
+            // Output: dataBinding: () => ({ list: [...], create: [...], update: [...], delete: [...] })
+            // Helper function to format value for JavaScript object literal
+            const formatValue = (value) => {
+                if (value === null) {
+                    return "null";
+                }
+                if (value === undefined) {
+                    return "undefined";
+                }
+                if (typeof value === "string") {
+                    // If it's already a transformed expression (contains .eval), return as-is without quotes
+                    if (value.includes(".eval(")) {
+                        return value;
+                    }
+                    // Otherwise, quote it as a string
+                    return JSON.stringify(value);
+                }
+                if (typeof value === "number" || typeof value === "boolean") {
+                    return String(value);
+                }
+                return JSON.stringify(value);
+            };
+            // Build array of binding objects
+            const buildBindingArray = (bindings) => {
+                return bindings
+                    .map((binding) => {
+                    const transformed = transformDataItem(binding, scope);
+                    const props = [];
+                    // Always include target
+                    props.push(`"target" : ${JSON.stringify(binding.target)}`);
+                    // Format value - use transformed value if it's an expression, otherwise use original
+                    let finalValue;
+                    if (transformed.value !== undefined && transformed.value !== null) {
+                        // If transformed value is a template literal (wrapped in backticks), extract the inner value
+                        if (typeof transformed.value === "string" &&
+                            transformed.value.startsWith("`") &&
+                            transformed.value.endsWith("`")) {
+                            finalValue = transformed.value.slice(1, -1);
+                        }
+                        else if (typeof transformed.value === "string" &&
+                            transformed.value.includes(".eval(")) {
+                            // It's a transformed expression, use as-is
+                            finalValue = transformed.value;
+                        }
+                        else {
+                            // Use transformed value, but check if we should preserve original type
+                            finalValue = transformed.value;
+                        }
+                    }
+                    else {
+                        finalValue = binding.value || "";
+                    }
+                    props.push(`"value" : ${formatValue(finalValue)}`);
+                    // Always include type
+                    props.push(`"type" : ${JSON.stringify(binding.type)}`);
+                    // Include isList if it exists
+                    if (binding.hasOwnProperty("isList")) {
+                        props.push(`"isList" : ${binding.isList}`);
+                    }
+                    return `{\n      ${props.join(`,\n      `)}\n    }`;
+                })
+                    .join(" , ");
+            };
+            // Build the object string
+            const objectParts = [];
+            Object.keys(variable.dataBinding).forEach((operationKey) => {
+                const operationBindings = variable.dataBinding[operationKey];
+                if ((0, lodash_1.isArray)(operationBindings)) {
+                    objectParts.push(`"${operationKey}" : [ ${buildBindingArray(operationBindings)} ]`);
+                }
+                else {
+                    objectParts.push(`"${operationKey}" : ${formatValue(operationBindings)}`);
+                }
+            });
+            // Store transformed dataBinding on variable object for use in transformCrudVariable
+            // Don't add it to params so it doesn't end up in paramProvider
+            variable._transformedDataBinding = `() => ({\n      ${objectParts.join(`,\n      `)}\n    })`;
+            // Remove dataBinding from params if it exists to prevent it from going into paramProvider
+            if (params.dataBinding) {
+                delete params.dataBinding;
+            }
+        }
+    }
+    const filterProvider = (rules) => {
+        rules === null || rules === void 0 ? void 0 : rules.forEach((r) => {
+            if (r.rules) {
+                filterProvider(r.rules);
+            }
+            else {
+                const { name, value } = transformDataItem(r, scope);
+                filters[name] = value;
+            }
+        });
+    };
+    if (variable.filterExpressions) {
+        filterProvider(variable.filterExpressions.rules);
+    }
+    // Todo: these properties directly on variable are to be handled from studio
+    if (variable.category === "wm.DeviceVariable" && variable.operation === "scanBarCode") {
+        params["barcodeFormat"] = variable.barcodeFormat;
+    }
+    if (variable.category === "wm.DeviceVariable" &&
+        variable.service === "file" &&
+        variable.operation === "upload") {
+        params["browse"] = !variable.localFile;
+    }
+    const obj = {
+        name: variable.name,
+        group: "variable",
+        params: params,
+        filters: filters,
+        onSuccess: appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onSuccess, scope, "event"), ";"),
+        onError: appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onError, scope, "event"), ";"),
+    };
+    if (variable.onCanUpdate) {
+        obj.onCanUpdate = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onCanUpdate, scope, "event"), ";");
+    }
+    if (variable.onBeforeUpdate) {
+        obj.onBeforeUpdate = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onBeforeUpdate, scope, "event"), ";");
+    }
+    if (variable.onResult) {
+        obj.onResult = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onResult, scope, "event"), ";");
+    }
+    if (variable.onOnline) {
+        obj.onOnline = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onOnline, scope, "event"), ";");
+    }
+    if (variable.onOffline) {
+        obj.onOffline = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onOffline, scope, "event"), ";");
+    }
+    if (variable.onBeforeDatasetReady) {
+        obj.onBeforeDatasetReady = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onBeforeDatasetReady, scope, "event"), ";");
+    }
+    if (variable.spinnerContext) {
+        obj.spinnerContext = variable.spinnerContext;
+        obj.spinnerMessage = variable.spinnerMessage;
+    }
+    if (variable.category === "wm.LoginAction" || variable.category === "wm.LogoutAction") {
+        obj.useDefaultSuccessHandler = variable.useDefaultSuccessHandler;
+    }
+    return obj;
+}
+function transformModelVariable(variable, scope) {
+    if ((0, lodash_1.isArray)(variable.dataSet) &&
+        variable.dataSet.length === 1 &&
+        checkEmptyObject(variable.dataSet[0])) {
+        variable.dataSet = [];
+    }
+    if (variable.dataBinding) {
+        delete variable.dataBinding;
+    }
+    const tv = transformVariable(variable, scope);
+    tv.classname = "ModelVariable";
+    tv.twoWayBinding = variable.twoWayBinding;
+    tv.isList = !!variable.isList;
+    return tv;
+}
+function transformServiceVariable(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "ServiceVariable";
+    tv.operationId = variable.operationId;
+    tv.isList = !!variable.isList;
+    tv.inFlightBehavior = variable.inFlightBehavior;
+    tv.service = variable.service;
+    tv.operation = variable.operation;
+    tv.operationType = variable.operationType;
+    tv.maxResults = variable.maxResults;
+    tv._context = variable._context;
+    tv.serviceType = variable.serviceType;
+    tv.controller = variable.controller;
+    tv.autoUpdate = variable.autoUpdate;
+    tv.orderBy = variable.orderBy;
+    tv.isStaticParams = isStaticParamsVariable(variable);
+    return tv;
+}
+function transformNavigationAction(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "NavigationAction";
+    tv.group = "action";
+    tv.operation = variable.operation;
+    tv.params = (0, lodash_1.isArray)(tv.params) && tv.params.length == 0 ? {} : tv.params;
+    if (!tv.params["pageName"] && variable.pageName) {
+        tv.params["pageName"] = variable.pageName;
+    }
+    return tv;
+}
+function transformTimerAction(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "TimerAction";
+    tv.group = "action";
+    tv.repeating = variable.repeating;
+    tv.delay = variable.delay;
+    if (variable.onTimerFire) {
+        tv.onTimerFire = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onTimerFire, scope, "event"), ";");
+    }
+    return tv;
+}
+function transformNotificationAction(variable, scope, imports) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "NotificationAction";
+    tv.group = "action";
+    tv.operation = variable.operation;
+    const partialContent = Array.isArray(variable.dataBinding)
+        ? variable.dataBinding.filter((binding) => {
+            return binding.target === "page";
+        })[0]
+        : null;
+    if (variable.onOk || variable.onClick) {
+        tv.onOk = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onOk || variable.onClick, scope, "event"), ";");
+    }
+    if (variable.onCancel) {
+        tv.onCancel = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onCancel, scope, "event"), ";");
+    }
+    if (variable.onClose || variable.onHide) {
+        tv.onClose = appendIfNotEmpty((0, bind_ex_transformer_1.default)(variable.onClose || variable.onHide, scope, "event"), ";");
+    }
+    if (variable.operation === "alert" || variable.operation === "confirm") {
+        const owner = scope === "App" ? "App" : scope;
+        const widgetName = `Common${(0, lodash_1.upperFirst)(variable.operation)}Dialog`;
+        if (owner === "App") {
+            tv.showDialog = `App.openActionDialog(options,"${widgetName}");`;
+        }
+        else {
+            tv.showDialog = `${owner}.App.openActionDialog(options,"${widgetName}");`;
+        }
+    }
+    if (partialContent) {
+        const partialName = partialContent.value.charAt(0).toUpperCase() + partialContent.value.slice(1);
+        const importItem = `import ${partialName} from "@/app/components/${partialContent.value}/${partialContent.value}";`;
+        if (!imports.includes(importItem)) {
+            imports.push(importItem);
+        }
+        tv.partialContent = { component: partialName };
+    }
+    return tv;
+}
+function transformDeviceVariable(variable, scope, appUrl) {
+    if ((0, lodash_1.isArray)(variable.dataSet) &&
+        variable.dataSet.length === 1 &&
+        checkEmptyObject(variable.dataSet[0])) {
+        variable.dataSet = [];
+    }
+    const tv = transformVariable(variable, scope);
+    tv.classname = "DeviceVariable";
+    tv.operation = variable.operation;
+    tv.service = variable.service;
+    if (variable.service === "file") {
+        tv.params.serverUrl = `${scope}.eval(() => ${scope}.appConfig.url)`;
+    }
+    return tv;
+}
+function transformLoginVariable(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "LoginAction";
+    tv.group = "action";
+    return tv;
+}
+function transformLogoutVariable(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "LogoutAction";
+    tv.group = "action";
+    tv.redirectTo = variable.redirectTo;
+    return tv;
+}
+function transformLiveVariable(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv.classname = "LiveVariable";
+    tv.isList = !!variable.isList;
+    tv.inFlightBehavior = variable.inFlightBehavior;
+    tv.maxResults = variable.maxResults;
+    tv._context = variable._context;
+    tv.operation = variable.operation;
+    tv.type = variable.type;
+    tv.autoUpdate = variable.autoUpdate;
+    tv.orderBy = variable.orderBy;
+    tv.liveSource = variable.liveSource;
+    tv.category = variable.category;
+    tv.tableName = variable.tableName;
+    tv.tableType = variable.tableType;
+    tv.relatedTables = variable.relatedTables;
+    tv.filterExpressions = variable.filterExpressions;
+    tv._id = variable._id;
+    tv.isStaticParams = isStaticParamsVariable(variable);
+    return tv;
+}
+function transformCrudVariable(variable, scope) {
+    const tv = transformVariable(variable, scope);
+    tv._id = variable._id;
+    tv.name = variable.name;
+    tv.owner = variable.owner;
+    tv.category = variable.category;
+    tv.type = variable.type;
+    tv.service = variable.service;
+    tv.operation = variable.operation;
+    tv.operationId = variable.operationId;
+    tv.crudOperationId = variable.crudOperationId;
+    tv.operationType = variable.operationType;
+    tv.serviceType = variable.serviceType;
+    tv.dataSet = variable.dataSet;
+    tv.isList = variable.isList;
+    tv.maxResults = variable.maxResults;
+    tv.startUpdate = variable.startUpdate;
+    tv.autoUpdate = variable.autoUpdate;
+    tv.inFlightBehavior = variable.inFlightBehavior;
+    tv.transformationRequired = variable.transformationRequired;
+    tv.saveInPhonegap = variable.saveInPhonegap;
+    tv.controller = variable.controller;
+    // Use transformed dataBinding if available, otherwise use original
+    tv.dataBinding = variable._transformedDataBinding || variable.dataBinding;
+    tv.classname = "CrudVariable";
+    tv.group = "variable";
+    tv.isStaticParams = isStaticParamsVariable(variable);
+    return tv;
+}
+exports.default = (variable, scope, appUrl, imports) => {
+    switch (variable.category) {
+        case "wm.Variable":
+            return transformModelVariable(variable, scope);
+        case "wm.ServiceVariable":
+            return transformServiceVariable(variable, scope);
+        case "wm.NavigationAction":
+            return transformNavigationAction(variable, scope);
+        case "wm.TimerAction":
+            return transformTimerAction(variable, scope);
+        case "wm.NotificationAction":
+            return transformNotificationAction(variable, scope, imports);
+        case "wm.DeviceVariable":
+            return transformDeviceVariable(variable, scope, appUrl);
+        case "wm.LoginAction":
+            return transformLoginVariable(variable, scope);
+        case "wm.LogoutAction":
+            return transformLogoutVariable(variable, scope);
+        case "wm.LiveVariable":
+            return transformLiveVariable(variable, scope);
+        case "wm.CrudVariable":
+            return transformCrudVariable(variable, scope);
+    }
+    return null;
+};
+//# sourceMappingURL=variable.transformer.js.map